Warum sollten Eigenschaften für den Prototyp für Instanzvariablen in JavaScript deklariert werden?

Ich versuche, meinen Kopf um dieses schwarze Kunst genannt, JavaScript - und, ich muss zugeben, ziemlich aufgeregt. Ich habe auf der Suche im code-Beispiele, vor allem aus easeljs, da das ist, was ich verwenden werde, vor allem. Und ich bin ein bisschen verwirrt..

Ich (denke ich) verstehen den Unterschied zwischen der Verwendung der Prototyp für Funktionen oder Eigenschaften, die 'class' - Variablen und verwenden diese.someProp für 'instance' - Variablen (ja, ich verstehe, dass es gibt keine Klassen in JavaScript.)

Den code habe ich mir angeschaut, und bin mit, die als Vorlage für meinen eigenen code erklären Prototyp Variablen und bezieht sich dann auf Sie mit diesem also

Im Konstruktor: this.name = name;

Dann eine Erklärung: Objekt.der Prototyp.name;

Und später.name = "Freddy";

Dies ist innerhalb von Funktionen aufgerufen, die mit 'neu' in diesem Fall also, so wie ich es verstehe, "diese" bezieht sich auf das aktuelle Objekt. Was mich verwirrt ist was der Prototyp-Deklaration macht und warum verwenden wir Sie für Instanz-Variablen?

Dank, Dave

OK, ein wenig Klärung. In den folgenden code, ich sehe nicht, was die Prototyp-Deklaration von radius erreichen:

(function(){
    //constructor
    function MyCircle(radius){
        this.radius = radius;
    }
    MyCircle.prototype.radius;
    this.area = function(){
        return 3.14*this.radius*this.radius;
    };
    window.MyCircle = MyCircle;
}());

InformationsquelleAutor der Frage DaveM | 2013-05-25

49

Den Wert auf einem Prototyp hat einen Schlüssel Verhalten, dass andere von einem Grundstück direkt auf die Instanz. Versuchen Sie dies:
```
//Create a constructor
function A() {}

//Add a prototype property
A.prototype.name = "Freddy";

//Create two object instances from
//the constructor
var a = new A();
var b = new A();

//Both instances have the property
//that we created on the prototype
console.log(a.name); //Freddy
console.log(b.name); //Freddy

//Now change the property on the
//prototype
A.prototype.name = "George";

//Both instances inherit the change.
//Really they are just reading the
//same property from the prototype
//rather than their own property
console.log(a.name); //George
console.log(b.name); //George
```
Dies wäre nicht möglich ohne die prototypische Vererbung.

Können Sie testen, ob die Eigenschaft der Instanzen-Eigenschaft oder die prototype-Eigenschaft mithilfe der hasOwnProperty Methode.
```
console.log(a.hasOwnProperty("name")); //false
```
Einer Instanz außer Kraft setzen können prototype Wert.
```
b.name = "Chris";
console.log(b.hasOwnProperty("name")); //true
console.log(a.name); //George
console.log(b.name); //Chris
```
Und zurück zu den prototype Wert.
```
delete b.name;
console.log(b.hasOwnProperty("name")); //false
console.log(b.name); //George
```
Dies ist ein mächtiger Teil der prototypischen Vererbung.

In die anderen Muster:
```
function A() {
  this.name = "George";
}
```
Den this.name variable deklariert ist wieder mit jeder neuen Instanz.

Macht es einen Sinn, um Methoden als Funktionen deklariert, die auf dem Prototyp. Anstatt die definition der Funktion neu deklariert, auf jeder Instanz, die alle Instanzen können gemeinsam eine einzige Funktion.

In Bezug auf die Variablen, sondern als Funktionen, die der Prototyp kann möglicherweise verwendet werden, für die default-Werte in dem Fall, dass eine Instanz nicht Ihren eigenen Wert.

Den code in ein Turnschuh

InformationsquelleAutor der Antwort Stuart Wakefield
11

Einem gespeicherten Wert für den Prototyp bietet eine Standard Wert für diese Eigenschaft.

Wenn Sie anschließend das schreiben eines Wertes an die Eigenschaft, die Instanz erwerben diesen neuen Wert, ausblenden der Wert, der auf den Prototyp, die intakt gelassen werden.

Im Kontext des code haben Sie nun die Frage:
```
MyCircle.prototype.radius;
```
tut absolut nichts. Es ist eine no-op - es wird versucht Lesendass Eigentum und verwirft dann das Resultat.

InformationsquelleAutor der Antwort Alnitak

Ja, ich Stimme der Prototyp kann verwendet werden, für die default-Werte der Eigenschaften (Variablen). Die Konstruktor-Funktion brauchen wir nicht zu erklären Vermögen; es kann getan werden, bedingt.

function Person( name, age ) {
    this.name = name;

    if ( age ) {
        this.age = age;
    }
}

Person.prototype.sayHello = function() {
    console.log( 'My name is ' + this.name + '.' );
};

Person.prototype.sayAge = function() {
    if ( this.age ) {
        console.log( 'I am ' + this.age + ' yrs old!' ); 
    } else {
        console.log( 'I do not know my age!' );
    }
};

Person.prototype.age = 0.7;

//-----------

var person = new Person( 'Lucy' );
console.log( 'person.name', person.name ); //Lucy
console.log( 'person.age', person.age );   //0.7
person.sayAge();                           //I am 0.7 yrs old!

Sehen, wie Lucy ' s age bedingt deklariert und initialisiert.

InformationsquelleAutor der Antwort Michael R

0

Anderen Antworten bereits erklärt, der Unterschied zwischen Prototyp vs-Instanz Eigenschaften.

Aber nur um die Antwort, lasst uns brechen Ihre code-snippet:
```
(function(){                         //<------- 1
   //constructor
   function MyCircle(radius){        //<------- 2
       this.radius = radius;         //<------- 2.1
   }
   MyCircle.prototype.radius;        //<------- 3
   this.area = function(){           //<------- 4
       return 3.14*this.radius*this.radius;
   };
   window.MyCircle = MyCircle;       //<------- 5
}());
```
1. Erstellen einer IIFE fungiert als scope-container für den inneren code
2. Deklarieren eine Funktion, die aufgerufen wird MyCircle mit einem Konstruktor-Muster (aber beachten Sie, dass es nie "gebaut", also wohl sollte loszuwerden, die Großbuchstaben, da es irreführend)
  - wenn Sie angerufen werden, erzeugt eine radius Instanz-Eigenschaft auf dem Objekt aufgerufen
3. Die versuchen auf eine radius Eigenschaft auf MyCircle Funktion prototype die nicht vorhanden sind, so auswertet, um undefined
4. Erstellen einer area Instanz-Eigenschaft auf den globalen window-Objekts und zuweisen einer Funktion Ausdruck
5. Erstellen einer MyCircle Instanz-Eigenschaft auf eine window - Objekt und weist es der MyCircle Funktion
Zusammenfassung: Es scheint, wie es um die Schaffung einer area und MyCircle Eigenschaften auf der globalen window Objekt, und wenn MyCircle aufgerufen wird, erstellt es eine zusätzliche radius Eigenschaft.

Verwendung: MyCircle aufgerufen werden soll, bevor die Fläche da Fläche stützt sich auf MyCircle Initialisierung des radius:
```
window.MyCircle(10);
window.area(); //evaluates to 314
```
InformationsquelleAutor der Antwort linasmnew

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.