Javascript dodać metoda sprzeciwić

Question

Załóżmy, że mam Foo obiekt

Jak mogę przedłużyć ten cel poprzez wprowadzenie metody bar() a także zapewnić, że przyszłe instancje Foo mają tę metodę?

Answer 1

trzeba dodać ją do prototypu Foo:

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

Answer 2

Istnieje wiele sposobów tworzenia obiektów wielokrotnego użytku takich jak ten w JavaScript. Mozilla mieć ładne wprowadzenie tutaj:

• https://developer.mozilla.org/en-US/docs/JavaScript/Introduction_to_Object-Oriented_JavaScript

Poniższa będzie pracować w swoim przykładzie:

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

myFoo = new Foo(); 
myFoo.bar(); // Hello World​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ 

Answer 3

Możesz sprawić, że bar staje się funkcją.

Foo.bar = function(passvariable){ }; 

jako własność byłoby to po prostu być przypisany ciąg znaków, typ danych lub wartość logiczną

Foo.bar = "a place"; 

Answer 4

To wszystko zależy od tego jak jesteś tworzenia Foo i jak masz zamiar używać .bar().

Po pierwsze, czy używasz funkcji konstruktora dla swojego obiektu?

var myFoo = new Foo(); 

Jeśli tak, to można wydłużyć Foo funkcyjnego prototype nieruchomości z .bar, tak:

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

var myFoo = new Foo(); 
myFoo.bar(); 

W ten sposób każde wystąpienie Foo ma teraz dostęp do SAMYM wystąpienie .bar.
słownie: .bar będą mieli pełny dostęp do this, lecz będzie miał absolutnie żadnego dostępu do variables w funkcji konstruktora:

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 

w inny sposób, można zdefiniować funkcję, aby powrócić dowolny obiekt (nie this), z .bar stworzony jako własność tego obiektu:

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

    return public_interface; 
} 

var myObj = giveMeObj(); 
myObj.bar(); // 42 

W ten sposób, masz funkcję, która tworzy nowe obiekty. Każdy obiekt ma utworzoną dla niego funkcję .bar.
Każda funkcja ma dostęp, poprzez to, co nazywa się , zamknięcie, do "prywatnych" zmiennych w funkcji, która zwróciła ich określony obiekt.
Każdy .bar nadal ma dostęp do this a także, jak this, kiedy zadzwonić funkcja jak myObj.bar(); zawsze odnoszą się do myObj (public_interface, w moim przykładzie Foo).

Wadą tego formatu jest to, że jeśli zamierzasz stworzyć miliony tych obiektów, to także miliony kopii .bar, które zjedzą do pamięci.

Można to również wykonać wewnątrz funkcji konstruktora, ustawiając wewnątrz konstruktora obiekt this.bar = function() {}; - znowu będzie to zamknięcie - dostęp do zmiennych prywatnych w konstruktorze, a wadą będzie zwiększone zapotrzebowanie na pamięć.

Więc pierwsze pytanie brzmi:
Czy można oczekiwać wasze metody, aby mieć dostęp do odczytu/modyfikacji „prywatne” dane, które nie mogą być udostępniane za pośrednictwem samego obiektu (poprzez this lub myObj.X)?

a drugie pytanie brzmi: Czy robisz wystarczająco dużo tych obiektów, aby pamięć była wielkim problemem, jeśli nadasz im każdą własną funkcję, zamiast dawać im jedną?

Na przykład, jeśli dał każdy trójkąt i każdą fakturę własnych .draw funkcji w high-end gry 3D, które mogą być przesadą, i to prawdopodobnie wpływa na płynność animacji w tak delikatnej systemu ...

Jeśli jednak chcesz utworzyć 5 pasków przewijania na stronę i chcesz, aby każdy mógł ustawić swoją pozycję i śledzić, czy jest on przeciągany, nie pozwalając każdej innej aplikacji mieć dostępu do odczytu/ustawiania tych samych rzeczy , to naprawdę nie ma powodu, aby bać się, że 5 dodatkowych funkcji zabije twoją aplikację, zakładając, że może ona mieć już 10 000 linii (lub więcej).