Javascript adiciona método ao object

Suponha que eu tenha um object Foo

Como posso estender esse object adicionando um método bar() e também garantir que instâncias futuras do Foo tenham esse método?

você precisa adicioná-lo ao protótipo de Foo:

 function Foo(){} Foo.prototype.bar = function(){} var x = new Foo() x.bar() 

Isso tudo depende de como você está criando Foo e como pretende usar .bar() .

Primeiro, você está usando uma function de construtor para o seu object?

 var myFoo = new Foo(); 

Se assim for, então você pode estender a propriedade prototype da function Foo com .bar , da seguinte forma:

 function Foo () { /*...*/ } Foo.prototype.bar = function () { /*...*/ }; var myFoo = new Foo(); myFoo.bar(); 

Desta forma, cada instância de Foo agora tem access à mesma instância de .bar .
A saber: .bar terá access FULL a this , mas não terá absolutamente nenhum access a variables dentro da function de construtor:

 function Foo () { var secret = 38; this.name = "Bob"; } Foo.prototype.bar = function () { console.log(secret); }; Foo.prototype.otherFunc = function () { console.log(this.name); }; var myFoo = new Foo(); myFoo.otherFunc(); // "Bob"; myFoo.bar(); // error -- `secret` is undefined... // ...or a value of `secret` in a higher/global scope 

De outra forma, você poderia definir uma function para retornar qualquer object (não this ), com .bar criada como uma propriedade desse object:

 function giveMeObj () { var private = 42, privateBar = function () { console.log(private); }, public_interface = { bar : privateBar }; return public_interface; } var myObj = giveMeObj(); myObj.bar(); // 42 

Desta forma, você tem uma function que cria novos objects.
Cada um desses objects tem uma function .bar criada para eles.
Cada function .bar tem access, através do que é chamado de fechamento , às variables ​​”privadas” dentro da function que retornou seu object particular.
Cada .bar ainda tem access a this também, assim, quando você chama a function como myObj.bar(); sempre se referirá ao myObj ( public_interface , no meu exemplo Foo ).

A desvantagem desse formato é que, se você for criar milhões desses objects, também são milhões de cópias de .bar , que serão armazenadas na memory.

Você também pode fazer isso dentro de uma function construtora, configurando this.bar = function () {}; dentro do construtor – novamente, upside seria closure-access para variables ​​privadas no construtor e desvantagem seria aumento de requisitos de memory.

Então a primeira pergunta é:
Você espera que seus methods tenham access para ler / modificar dados “privados”, que não podem ser acessados ​​através do próprio object (através this ou do myObj.X )?

e a segunda pergunta é: você está fazendo bastante desses objects para que a memory seja uma grande preocupação, se você der a cada um a sua própria function pessoal, em vez de dar a eles um para compartilhar?

Por exemplo, se você deu a cada triângulo e a cada textura sua própria function .draw em um jogo 3D de alto nível, isso pode ser um exagero e provavelmente afetaria a taxa de frameworks em um sistema tão delicado …

Se, no entanto, você quiser criar 5 barras de rolagem por página, e quiser que cada um possa definir sua posição e controlar se está sendo arrastado, sem permitir que todos os outros aplicativos tenham access para ler / definir essas mesmas coisas , então não há realmente nenhuma razão para ter medo de que 5 funções extras matem seu aplicativo, supondo que ele já possa ter 10.000 linhas (ou mais).

Existem muitas maneiras de criar objects reutilizáveis ​​como este em JavaScript. Mozilla tem uma boa introdução aqui:

O seguinte irá funcionar no seu exemplo:

 function Foo(){ this.bar = function (){ alert("Hello World!"); } } myFoo = new Foo(); myFoo.bar(); // Hello World​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ 

Você pode fazer da barra uma function, tornando-a um método.

 Foo.bar = function(passvariable){ }; 

Como propriedade, seria atribuída apenas uma string, tipo de dados ou booleano

 Foo.bar = "a place";