Wie funktioniert JavaScript .prototype?

Ich Spiele eine Rolle als JavaScript-Lehrer und der Prototyp-Konzept war schon immer ein umstrittenes Thema abdecken, wenn ich unterrichte. Es dauerte eine Weile, um zu kommen mit eine gute Methode, zu klären, das Konzept, und jetzt in diesem text werde ich versuchen zu erklären, Wie funktioniert JavaScript .Prototyp arbeiten.

---

Dies ist eine sehr einfache Prototyp-basierten Objekt-Modell, dass würde als eine Probe, die während der Erläuterung, ohne Kommentar noch:

function Person(name){
    this.name = name;
}
Person.prototype.getName = function(){
    console.log(this.name);
}
var person = new Person("George");

---

Gibt es einige entscheidende Punkte, die wir berücksichtigen müssen, bevor wir über das Prototyp-Konzept.

1 - Wie JavaScript-Funktionen, die wirklich funktionieren:

Den ersten Schritt zu nehmen, müssen wir herausfinden, wie JavaScript-Funktionen, die wirklich funktionieren , da eine Klasse wie die Funktion mit this keyword oder halt als normale Funktion mit den Argumenten, was Sie tut und was Sie zurückgibt.

Sagen wir, wir möchten, erstellen Sie eine Person - Objekt-Modell. aber in diesem Schritt werde ich versuchen, tun exakt das gleiche Sache, ohne die Verwendung prototype und new Stichwort.

So, in diesem Schritt functionsobjects und this Schlüsselwort, sind alles, was wir haben.

Die erste Frage wäre wie this Stichwort könnte hilfreich sein, ohne mit new Stichwort.

So zu beantworten, dass wir sagen, wir haben ein leeres Objekt, und zwei Funktionen, wie:

var person = {};
function Person(name){  this.name = name;  }

function getName(){
    console.log(this.name);
}

und jetzt ohne Verwendung new Stichwortwie wir diese Funktionen verwenden. Also in JavaScript gibt es 3 verschiedene Möglichkeiten, das zu tun:

ein. erste Möglichkeit ist einfach, rufen Sie die Funktion wie eine normale Funktion:

Person("George");
getName();//would print the "George" in the console

in diesem Fall wäre der aktuelle Kontext-Objekt, das in der Regel ist die Globale window Objekt im browser oder GLOBAL im Node.js. Es heißt, wir müssten, Fenster.Namen im browser oder GLOBAL.name in Node.js mit "George" als seinen Wert.

b. Wir können befestigen Sie auf ein Objekt, dessen Eigenschaften

-Der einfachste Wegdies zu tun ist die änderung der leeren person Objekt, wie:

person.Person = Person;
person.getName = getName;

diese Weise können wir rufen Sie gerne:

person.Person("George");
person.getName();//-->"George"

und jetzt die person Objekt ist wie:

Object {Person: function, getName: function, name: "George"}

---

-Den anderen Weg, um das Anhängen einer Eigenschaftum ein Objekt mithilfe der prototype des Objekts, werden kann finden Sie in der JavaScript Objekt mit dem Namen __proto__und ich habe versucht zu erklären, es ein wenig an der übersicht Teil. So konnten wir das ähnliche Ergebnis von doing:

person.__proto__.Person = Person;
person.__proto__.getName = getName;

Aber diese Weise das, was wir tatsächlich tun, ist die änderung der Object.prototypedenn Wann immer wir erstellen ein JavaScript-Objekt mit literalen ({ ... }), wird es erstellt, basierend auf Object.prototypewas bedeutet, es wird befestigt, um das neu erstellte Objekt als Attribut mit dem Namen __proto__ , so dass, wenn wir es ändern, wie wir getan haben auf unseren vorherigen code-snippet, alle JavaScript-Objekte geändert werden, sind nicht eine gute Praxis. Also, was könnte die bessere Praxis jetzt:

person.__proto__ = {
    Person: Person,
    getName: getName
};

und nun andere Objekte in Ruhe, aber es immer noch nicht scheinen, um eine gute Praxis. So haben wir noch eine weitere Lösungen, aber diese Lösung sollten wir uns wieder auf, dass die Codezeile, wo person Objekt erstellt habe ( var person = {}; ), dann ändern Sie es wie:

var propertiesObject = {
    Person: Person,
    getName: getName
};
var person = Object.create(propertiesObject);

was es tut, ist erstellen Sie eine neue JavaScript - Object an und befestigen Sie die propertiesObject zu den __proto__ Attribut. So stellen Sie sicher, dass Sie tun können:

console.log(person.__proto__===propertiesObject); //true

Aber der schwierige Punkt ist hier, haben Sie Zugriff auf alle Eigenschaften definiert, die in __proto__ auf der ersten Ebene der person - Objekt(Lesen Sie die Zusammenfassung zum Teil für mehr detail).

---

als Sie sehen, mit diesen zwei Weise this wäre genau der Punkt, um den person Objekt.

c. JavaScript ist ein weiterer Weg, um die Funktion mit thisdie mit rufen oder bewerben zum aufrufen der Funktion.

Die apply () - Methode ruft eine Funktion mit einem bestimmten dieser Wert und
Argumente als array (oder ein array-artiges Objekt).

und

Die Methode call() ruft eine Funktion mit einem bestimmten dieser Wert und
Argumente individuell.

diese Weise, die ist mein Liebling, wir können einfach rufen Sie unsere Funktionen wie:

Person.call(person, "George");

oder

//apply is more useful when params count is not fixed
Person.apply(person, ["George"]);

getName.call(person);   
getName.apply(person);

diese 3 Methoden sind wichtige erste Schritte, um herauszufinden, die .Prototyp-Funktionalität.

---

2 - Wie funktioniert das new Stichwort funktioniert?

dies ist der zweite Schritt zu verstehen, die .prototype Funktionalität.dies ist, was ich verwenden, um den Prozess simulieren:

function Person(name){  this.name = name;  }
my_person_prototype = { getName: function(){ console.log(this.name); } };

in diesem Teil werde ich versuchen, alle Schritte, die JavaScript nimmt, ohne mit der new Schlüsselwort und prototypewenn Sie new Schlüsselwort. also, wenn wir tun new Person("George")Person Funktion dient als Konstruktor, Diese sind das, was JavaScript macht, eins nach dem anderen:

ein. Erstens macht es ein leeres Objekt, im Grunde eine leere hash wie:

var newObject = {};

b. der nächste Schritt, der JavaScript braucht, um befestigen die alle Prototyp-Objekte auf das neu erstellte Objekt

wir haben my_person_prototype hier ähnlich dem Prototyp-Objekt.

for(var key in my_person_prototype){
    newObject[key] = my_person_prototype[key];
}

Es ist nicht die Art und Weise, dass JavaScript tatsächlich legt die Eigenschaften, die definiert sind in dem Prototyp. Die tatsächliche Art und Weise ist in Bezug auf die prototype-chain-Konzept.

---

ein. & b. Im Gegensatz zu diesen beiden Schritten können Sie haben genau das gleiche Ergebnis, indem Sie tun:

var newObject = Object.create(my_person_prototype);
//here you can check out the __proto__ attribute
console.log(newObject.__proto__ === my_person_prototype); //true
//and also check if you have access to your desired properties
console.log(typeof newObject.getName);//"function"

nun nennen wir die getName Funktion in unserem my_person_prototype:

newObject.getName();

c. dann gibt es das Objekt an den Konstruktor,

dies können wir mit unserem sample-wie:

Person.call(newObject, "George");

oder

Person.apply(newObject, ["George"]);

dann der Konstruktor kann tun, was es will, weil diese die im inneren des Konstruktors ist das Objekt, das gerade erstellt wurde.

nun das Endergebnis vor der Simulation die weiteren Schritte:
Object {name: "George"}

---

Zusammenfassung:

Grundsätzlich, wenn Sie die neue Schlüsselwort für eine Funktion, die Sie fordern, und diese Funktion dient als Konstruktor, so, wenn Sie sagen:

new FunctionName()

JavaScript intern macht ein Objekt, wird eine leere hash-und dann gibt es das Objekt an den Konstruktor übergeben, dann wird der Konstruktor kann tun, was es will, weil diese die im inneren des Konstruktors ist das Objekt, das Sie gerade erstellt haben und dann gibt es Ihnen das Objekt natürlich, wenn Sie haven ' T verwendet die return-Anweisung in der Funktion, oder wenn Sie haben eine return undefined; am Ende Ihrer Funktion Körper.

So, wenn JavaScript geht zu schauen, eine Eigenschaft auf ein Objekt, das erste, was Sie tut, ist, sucht er es auf das Objekt. Und dann gibt es eine geheime Eigenschaft [[prototype]]die in der Regel haben wir es wie __proto__ und diese Eigenschaft ist, was JavaScript sieht auf den nächsten. Und wenn es so aussieht, durch die __proto__wie weit es ist wieder ein JavaScript-Objekt, es hat seine eigene __proto__ Attribut, es geht höher und höher, bis es zu dem Punkt, wo sich die nächste __proto__ null ist. Der Punkt ist das einzige Objekt in JavaScript, das seine __proto__ Attributs null ist Object.prototype Objekt:

console.log(Object.prototype.__proto__===null);//true

und das ist, wie die Vererbung funktioniert in JavaScript.

In anderen Worten, wenn Sie haben eine prototype-Eigenschaft, die auf eine Funktion und rufen Sie eine neue auf, die nach JavaScript-Ausführungen an, dass der neu erstellte Objekt für Eigenschaften, es wird gehen, sehen Sie bei der Funktion .prototype und auch es ist möglich, dass dieses Objekt hat seinen eigenen internen Prototyp. und so weiter.

InformationsquelleAutor der Antwort Mehran Hatami

Nach der Lektüre dieses Threads, ich fühle mich verwirrt mit JavaScript-Prototype-Chain, dann fand ich diese charts

http://iwiki.readthedocs.org/en/latest/javascript/js_core.html#inheritance

es ist eine klare Diagramm, um zu zeigen, JavaScript Vererbung durch Prototypen-Kette

und

http://www.javascriptbank.com/javascript/article/JavaScript_Classical_Inheritance/

diese enthält ein Beispiel mit code und mehrere schöne Diagramme.

Prototyp-Kette, schließlich fällt zurück auf Objekt.der Prototyp.

Prototyp-Kette technisch verlängert sich, solange Sie wollen, jeder Zeit, durch die Einstellung der Prototyp der Unterklasse gleich ein Objekt der übergeordneten Klasse.

Hoffe, es ist auch hilfreich für Sie zu verstehen JavaScript-Prototype-Chain.

InformationsquelleAutor der Antwort rockXrock

Jedes Objekt hat eine interne Eigenschaft [[Prototype]], Verknüpfung zu einem anderen Objekt:

object [[Prototype]] -> anotherObject

In der traditionellen javascript, das verknüpfte Objekt ist die prototype Eigenschaft einer Funktion:

object [[Prototype]] -> aFunction.prototype

Einigen Umgebungen aussetzen [[Prototype]] als __proto__:

anObject.__proto__ === anotherObject

Erstellen Sie die [[Prototype]] - link, wenn Sie ein Objekt erstellen.

//(1) Object.create:
var object = Object.create(anotherObject)
//object.__proto__ = anotherObject

//(2) ES6 object initializer:
var object = { __proto__: anotherObject };
//object.__proto__ = anotherObject

//(3) Traditional JavaScript:
var object = new aFunction;
//object.__proto__ = aFunction.prototype

Also diese Aussagen sind gleichwertig:

var object = Object.create(Object.prototype);
var object = { __proto__: Object.prototype }; //ES6 only
var object = new Object;

Einen new Anweisung nicht zeigen, das link-Ziel (Object.prototype) selbst, sondern das Ziel ist implizit der Konstruktor (Object).

Denken Sie daran:

• Jedes Objekt hat einen link, [[Prototype]], manchmal ausgesetzt sind, wie __proto__.
• Jede Funktion hat eine prototype Eigenschaft.
• Erstellte Objekte new im Zusammenhang mit den prototype Eigentum Ihrer Konstruktor.
• Wenn eine Funktion wird nicht verwendet, da Sie einen Konstruktor, dessen prototype Eigenschaft ungenutzt.
• Wenn Sie nicht brauchen einen Konstruktor verwenden Objekt.erstellen statt new.

InformationsquelleAutor der Antwort sam

Dieser Artikel ist lang. Aber ich bin sicher, es wird klar, dass die meisten Ihrer Abfragen
in Bezug auf die "prototypische" Natur von JavaScript-Vererbung. Und sogar noch mehr. Bitte Lesen Sie den vollständigen Artikel.

JavaScript hat im Grunde zwei Arten von Datentypen

• Nicht Objekte
• Objekte

Nicht Objekte

Folgenden sind die Nicht Objekt Datentypen

• string
• Anzahl (darunter NaN und Infinity)
• Boolesche Werte(true,false)
• undefined

Diese Datentypen zurück folgenden, wenn Sie die typeof Betreiber

typeof "string-literal" (oder eine variable, die string-literal) === 'string'

typeof 5 (oder einen beliebigen numerischen literal oder eine variable mit numerischen literal oder NaN oder Infynity) === 'Anzahl'

typeof wahr (oder false oder eine variable, die wahr oder false) === 'boolean'

typeof undefined (oder eine Undefinierte variable oder eine variable, die undefined) === 'undefined'

Den string,Anzahl und boolean Datentypen dargestellt werden können, sowohl als Objekte und Nicht Objekte.Wenn Sie als Objekte dargestellt werden, die Ihre typeof ist immer === 'object'. Wir werden darauf zurückkommen, sobald wir verstehen die Objekt-Datentypen.

Objekte

Den Objekt-Datentypen können weiter unterteilt werden in zwei Arten

1. - Funktion-Typ-Objekte
2. Nicht-Funktion-Typ-Objekte

Den - Funktion-Typ-Objekte sind diejenigen, die den string "Funktion" mit typeof Betreiber.
Alle vom Benutzer definierten Funktionen und alle JavaScript Objekte erstellen können neue Objekte über den operator new, fallen in diese Kategorie. Für zB.

• Objekt
• String
• Anzahl
• Boolean
• Array
• Typisierte Arrays
• RegExp
• Funktion
• Alle anderen integrierten Objekte erstellen können neue Objekte über den operator new,
• Funktion UserDefinedFunction(){ /*benutzerdefinierten code */}

So,
typeof(Object) === typeof(String) === typeof(Anzahl) === typeof(Boolean) === typeof(Array) === typeof(RegExp) === typeof(Funktion) === typeof(UserDefinedFunction) = = = "Funktion"

Alle - Funktion-Typ-Objekte sind eigentlich Instanzen der eingebauten JavaScript-Objekt Funktion (einschließlich der Funktion Objekt-ich.e es ist rekursiv definiert). Es ist, als ob diese Objekte wurden definiert, in der folgenden Weise

var Object= new Function ([native code for object Object])
var String= new Function ([native code for object String])
var Number= new Function ([native code for object Number])
var Boolean= new Function ([native code for object Boolean])
var Array= new Function ([native code for object Array])
var RegExp= new Function ([native code for object RegExp])
var Function= new Function ([native code  for object Function])
var UserDefinedFunction= new Function ("user defined code")

Wie bereits erwähnt, die - Funktion-Typ-Objekte können weitere erstellen Sie neue Objekte mit dem neuen Betreiber. Für e.g ein Objekt vom Typ ObjektStringAnzahlBooleanArrayRegExp Oder UserDefinedFunction können erstellt werden, mithilfe

var a=new Object() or var a=Object() or var a={} //Create object of type Object
var a=new String() //Create object of type String
var a=new Number() //Create object of type Number
var a=new Boolean() //Create object of type Boolean
var a=new Array() or var a=Array() or var a=[]  //Create object of type Array
var a=new RegExp() or var a=RegExp() //Create object of type RegExp
var a=new UserDefinedFunction() 

Die Objekte, die damit erstellt werden, sind alle Nicht-Funktion-Typ-Objekte und Rückgabe Ihrer typeof==='Objekt'. In all diesen Fällen ist das Objekt "a" nicht weiter schaffen
Objekte mit operator new. Also Folgendes ist falsch

var b=new a() //error. a is not typeof==='function'

Dem built in-Objekt Mathematik ist typeof==='Objekt'. Daher wird ein neues Objekt vom Typ Math kann nicht erstellt werden, durch die neuen Betreiber.

var b=new Math() //error. Math is not typeof==='function'

Beachten Sie auch, dass Objekt,Array und RegExp Funktionen können Sie ein neues Objekt erstellen auch ohne Verwendung operator new. Aber Folgendes nicht.

var a=String() //Create a new Non Object string. returns a typeof==='string' 
var a=Number() //Create a new Non Object Number. returns a typeof==='number'
var a=Boolean() //Create a new Non Object Boolean. returns a typeof==='boolean'

Der user defined functions sind spezielle Fall.

var a=UserDefinedFunction() //may or may not create an object of type UserDefinedFunction() based on how it is defined.

Da die - Funktion-Typ-Objekte können neue Objekte erstellen, nennt man Sie auch Konstruktoren.

Jeder Konstruktor/Funktion (eingebaut in oder Benutzerdefiniert), wenn Sie automatisch definiert eine Eigenschaft namens " "Prototyp"dessen Wert standardmäßig eingestellt ist als ein Objekt. Das Objekt selbst hat eine Eigenschaft namens " "Konstruktor"die standardmäßig Referenzen zurück, die Konstruktor/Funktion .

Wenn wir zum Beispiel eine Funktion definieren, die

function UserDefinedFunction()
{
}

folgende geschieht automatisch

UserDefinedFunction.prototype={constructor:UserDefinedFunction}

Diese "prototype" - Eigenschaft ist nur vorhanden in der - Funktion-Typ-Objekte
(und nie in Nicht-Funktion-Typ-Objekte).

Dies ist, weil wenn ein neues Objekt erstellt wird (mittels new-operator)es erbt alle Eigenschaften und Methoden-Konstruktor-Funktion, die aktuelle Prototyp-Objekt, d.h. eine interne Referenz erstellt wird, in das neu erstellte Objekt, das Referenzen die referenzierten Objekts durch Konstruktor-Funktion der aktuellen Prototyp-Objekt.

Diese "interne Referenz"die erstellt wird, in das Objekt für die Referenzierung von vererbten Eigenschaften ist bekannt als die Objekt-Prototyp - (die Verweise, die referenzierten Objekts durch Konstruktor "Prototyp" Eigenschaft aber ist anders als es). Für jedes Objekt (Funktion oder Nicht-Funktion) diese können abgerufen werden, mit Objekt.getPrototypeOf() Methode. Mit dieser Methode kann man der Spur der Prototypkette des Objekts.

Auch, jedes Objekt, das erstellt wird, (Funktion Typ oder Nicht-Funktion geben) hat eine "Konstruktor" Eigenschaft, die vererbt wird von dem Objekt referenzierten Eigenschaft prototype der Konstruktorfunktion. Standardmäßig ist diese "Konstruktor" - Eigenschaft verweist auf die Konstruktor-Funktionder es erstellt (wenn die Konstruktorfunktion Standard "Prototyp" ist, wird nicht verändert).

Für alle - Funktion-Typ-Objekte der Konstruktor wird immer
Funktion Funktion(){}

Für Nicht-Funktion-Typ-Objekte (e.g Javascript im Math-Objekt) der Konstruktor-Funktion ist die Funktion, die es erstellt.
Für Mathematik Objekt ist es Funktion Object(){}.

Alle das Konzept oben erklärt, kann ein wenig entmutigend sein, zu verstehen, ohne jegliche Unterstützung von code. Bitte gehen Sie durch den folgenden code Zeile für Zeile zu verstehen, das Konzept. Versuchen Sie zu ausführen es, ein besseres Verständnis.

function UserDefinedFunction()
{ 

} 

/* creating the above function automatically does the following as mentioned earlier

UserDefinedFunction.prototype={constructor:UserDefinedFunction}

*/


var newObj_1=new UserDefinedFunction()

alert(Object.getPrototypeOf(newObj_1)===UserDefinedFunction.prototype)  //Displays true

alert(newObj_1.constructor) //Displays function UserDefinedFunction

//Create a new property in UserDefinedFunction.prototype object

UserDefinedFunction.prototype.TestProperty="test"

alert(newObj_1.TestProperty) //Displays "test"

alert(Object.getPrototypeOf(newObj_1).TestProperty)//Displays "test"

//Create a new Object

var objA = {
        property1 : "Property1",
        constructor:Array

}


//assign a new object to UserDefinedFunction.prototype
UserDefinedFunction.prototype=objA

alert(Object.getPrototypeOf(newObj_1)===UserDefinedFunction.prototype)  //Displays false. The object referenced by UserDefinedFunction.prototype has changed

//The internal reference does not change
alert(newObj_1.constructor) //This shall still Display function UserDefinedFunction

alert(newObj_1.TestProperty) //This shall still Display "test" 

alert(Object.getPrototypeOf(newObj_1).TestProperty) //This shall still Display "test"


//Create another object of type UserDefinedFunction
var newObj_2= new UserDefinedFunction();

alert(Object.getPrototypeOf(newObj_2)===objA) //Displays true.

alert(newObj_2.constructor) //Displays function Array()

alert(newObj_2.property1) //Displays "Property1"

alert(Object.getPrototypeOf(newObj_2).property1) //Displays "Property1"

//Create a new property in objA
objA.property2="property2"

alert(objA.property2) //Displays "Property2"

alert(UserDefinedFunction.prototype.property2) //Displays "Property2"

alert(newObj_2.property2) //Displays Property2

alert(Object.getPrototypeOf(newObj_2).property2) //Displays  "Property2"

Die Prototyp-Kette von jedem Objekt, das letztlich führt wieder zurück zum Objekt.Prototyp (die selbst keine Prototyp-Objekt) .
Folgende code kann verwendet werden, die für die Verfolgung der Prototypkette des Objekts

var o=Starting object;

do {
    alert(o + "\n" + Object.getOwnPropertyNames(o))

}while(o=Object.getPrototypeOf(o))

Die Prototyp-Kette für die verschiedenen Objekte wie folgt.

• Jede Funktion Objekt (einschließlich integrierte Funktion object)->
  Funktion.Prototypen -> Object.Prototypen -> null
• Einfache Objekte (erstellt Durch new Object() oder {} einschließlich gebaut im Math-Objekt)-> Object.Prototypen -> null
• - Objekt erstellt, mit neuen oder Objekt.erstellen -> Einen oder Mehrere Prototyp-Ketten -> Object.Prototypen -> null

Für die Erstellung von ein Objekt ohne Prototyp verwenden Sie die folgenden:

var o=Object.create(null)
alert(Object.getPrototypeOf(o)) //Displays null

Könnte man denken, dass das setzen der Eigenschaft prototype des Konstruktors zu null ist ein Objekt mit einem null-Prototyp. Jedoch in solchen Fällen die neu erzeugte Objekt dem Prototyp festgelegt ist, zu widersprechen.Prototyp und seinem Konstruktor gesetzt ist function-Objekt. Dies belegt der folgende code

function UserDefinedFunction(){}
UserDefinedFunction.prototype=null//Can be set to any non object value (number,string,undefined etc.)

var o=new UserDefinedFunction()
alert(Object.getPrototypeOf(o)==Object.prototype)   //Displays true
alert(o.constructor)    //Displays Function Object

Folgenden in der Zusammenfassung dieses Artikels

• Es gibt zwei Arten von Objekten Funktion Arten und Nicht Funktion Arten

• Nur - Funktion-Typ-Objekte erstellen kann ein neues Objekt mit der operator new. Die Objekte, die damit erstellt werden, sind Nicht-Funktion geben Objekte. Die Nicht-Funktion-Typ-Objekte nicht weiter ein Objekt erstellen mit operator new.

• Alle - Funktion-Typ-Objekte haben standardmäßig eine "Prototyp" Eigenschaft. Diese "Prototyp" - Eigenschaft verweist auf ein Objekt, eine "Konstruktor" - Eigenschaft, die standardmäßig verweist auf die - Funktion-Typ-Objekt selbst.

• Alle Objekte (Funktion Typ und Nicht-Funktion geben) haben eine "constructor" - Eigenschaft, die standardmäßig verweist auf die - Funktion-Typ-Objekt/Konstruktorder es erstellt.

• Jedes Objekt, das erzeugt wird, intern Referenzen die referenzierten Objekts durch
  "Prototyp" - Eigenschaft des Konstruktors, der es erstellt. Dieses Objekt bekannt ist, wie die erstellte Objekt-Prototyp - (die verschiedenen aus-Funktion Art-Objekte "prototype" - Eigenschaft, welche es sich bezieht) . Auf diese Weise erstelltes Objekt kann direkt auf die Methoden und Eigenschaften definiert in der referenzierten Objekts durch den Konstruktor der "prototype" - Eigenschaft (zum Zeitpunkt der Objekterstellung).

• Einer Objekt-Prototyp - (und damit Ihre ererbten Namen der Eigenschaft) kann abgerufen werden, mithilfe der Objekt.getPrototypeOf() Methode. In der Tat ist diese Methode
  kann verwendet werden für die Navigation in der gesamten Prototypkette des Objekts.

• Die Prototyp-Kette von jedem Objekt, das letztlich führt wieder zurück zum Objekt.Prototyp (es sei denn, das Objekt erstellt wird mit dem Objekt.create(null) in diesem Fall hat das Objekt keine Prototypen).

• typeof(new Array())==='object' ist durch die Gestaltung von Sprache und nicht ein Fehler wie schon von Douglas Crockford

• Einstellung der Eigenschaft prototype des Konstruktors zu null(oder undefined,Zahl,true,false,string) wird nicht erstellen Sie ein Objekt mit einem null-Prototyp. In solchen Fällen wird das neu erzeugte Objekt dem Prototyp festgelegt ist, zu widersprechen.Prototyp und seinem Konstruktor gesetzt ist function-Objekt.

Hoffe, das hilft.

InformationsquelleAutor der Antwort Arup Hore

was ist der genaue Zweck dieser ".prototype" - Eigenschaft?

Die Schnittstelle zu standard-Klassen werden erweiterbar. Zum Beispiel, verwenden Sie die Array Klasse, und Sie müssen auch hinzufügen, um eine benutzerdefinierte serializer für alle array-Objekte. Würden Sie den Zeitaufwand für die Codierung eine Unterklasse, oder verwenden Zusammensetzung oder ... Die prototype-Eigenschaft löst dieses Problem, indem der Nutzer die Kontrolle über die exakte Menge von Elementen/Methoden zu einer Klasse.

Denken von Prototypen als zusätzliche vtable-Zeiger. Wenn einige Mitglieder fehlen von der ursprünglichen Klasse, der Prototyp sah runtime.

InformationsquelleAutor der Antwort dirkgently

Fand ich es hilfreich zu erklären, die "prototype-chain" als rekursive Konvention, wenn obj_n.prop_X verwiesen wird:

wenn obj_n.prop_X nicht vorhanden ist, überprüfen Sie obj_n+1.prop_X wo obj_n+1 = obj_n.[[prototype]]

Wenn die prop_X ist endlich gefunden, im k-TEN Prototyp-Objekt dann

obj_1.prop_X = obj_1.[[prototype]].[[prototype]]..(k-times)..[[prototype]].prop_X

Finden Sie einen Graphen, der die Beziehung von Javascript-Objekten mit Ihren Eigenschaften hier:

http://jsobjects.org

InformationsquelleAutor der Antwort B M

Lassen Sie mich Ihnen sagen, mein Verständnis von Prototypen. Ich werde nicht zu vergleichen, die Vererbung hier mit anderen Sprachen. Ich wünschte, die Leute würden aufhören zu vergleichen, Sprachen, und nur die Sprache versteht, als Sie selbst. Verständnis Prototypen und prototypal inheritance ist so einfach, wie ich zeigen werde, die Sie unter.

Prototyp ist wie ein Modell, auf dessen Grundlage Sie ein Produkt erzeugen. Der entscheidende Punkt zu verstehen ist, dass, wenn Sie erstellen ein Objekt mit einem anderen Objekt als Prototyp, der Verbindung zwischen dem Prototyp und das Produkt ewig. Zum Beispiel:

var model = {x:2};
var product = Object.create(model);
model.y = 5;
product.y
=>5

Jedes Objekt enthält eine interne Eigenschaft [[prototype]] zugegriffen werden kann, indem die Object.getPrototypeOf() Funktion. Object.create(model) erzeugt ein neues Objekt und setzt es [[prototype]] - Eigenschaft auf das Objekt Modell. Daher, wenn Sie tun Object.getPrototypeOf(product) erhalten Sie das Objekt Modell.

Eigenschaften in der Produkt werden auf folgende Weise behandelt:

• Wenn eine Eigenschaft zugegriffen wird, nur zu Lesen ist es Wert, seine blickte in die scope-chain. Die Suche nach der variable beginnt von der Produkt nach oben, es ist der Prototyp. Falls eine solche variable gefunden in der Suche, die Suche ist beendet und der Wert zurückgegeben. Wenn eine solche variable nicht gefunden werden kann in der scope-chain, undefined zurückgegeben wird.
• Wenn eine Eigenschaft geschrieben(verändert), dann ist die Immobilie steht immer auf der Produkt Objekt. Wenn die Produkt nicht über eine solche Eigenschaft bereits implizit angelegt und geschrieben werden.

Solche Verknüpfung von Objekten über die prototype-Eigenschaft aufgerufen wird prototypal inheritance. Es ist so einfach, einverstanden?

InformationsquelleAutor der Antwort Aravind

Anderen versuchen zu erklären, JavaScript-Prototyp-basierte Vererbung mit besseren Bildern

InformationsquelleAutor der Antwort rus1

Gibt es zwei verschiedene, aber Verwandte Wesen hier, die, dass Notwendigkeit, zu erklären:

• Die .prototype Eigenschaft von Funktionen.
• Die [[Prototype]]^[1] - Eigenschaft aller Objekte^[2].

Diese sind zwei verschiedene Dinge.

Die [[Prototype]] Eigenschaft:

Dies ist eine Eigenschaft, die vorhanden ist, auf alle^[2] - Objekte.

Was hier gespeichert ist, ein anderes Objekt, das als Objekt selber hat eine [[Prototype]] seiner eigenen, die Punkte auf ein anderes Objekt. Das andere Objekt hat einen [[Prototype]] seiner eigenen. Diese Geschichte wird fortgesetzt, bis Sie erreichen die prototypische Objekt stellt Methoden bereit, die den Zugriff auf alle Objekte (wie .toString).

Den [[Prototype]] Eigentum ist Teil von dem, was bildet die [[Prototype]] Kette. Diese Kette von [[Prototype]] Objekte ist, was wird überprüft, wenn beispielsweise [[Get]] oder [[Set]] Operationen durchgeführt werden, die auf ein Objekt:

var obj = {}
obj.a         //[[Get]] consults prototype chain
obj.b = 20    //[[Set]] consults prototype chain

Die .prototype Eigenschaft:

Dies ist eine Eigenschaft, die sich nur auf die Funktionen. Mit einer sehr einfachen Funktion:

function Bar(){};

Den .prototype Eigenschaft enthält ein Objekt zugewiesen b.[[Prototype]] wenn Sie var b = new Bar. Sie können ganz einfach prüfen:

//Both assign Bar.prototype to b1/b2[[Prototype]]
var b = new Bar;
//Object.getPrototypeOf grabs the objects [[Prototype]]
console.log(Object.getPrototypeOf(b) === Bar.prototype) //true

Einer der wichtigsten .prototypes ist, dass der Object - Funktion. Dieser Prototyp enthält die prototypische Objekt, das alle [[Prototype]] Ketten enthalten. Auf, alle verfügbaren Methoden für neue Objekte definiert:

//Get properties that are defined on this object
console.log(Object.getOwnPropertyDescriptors(Object.prototype))

Nun, da .prototype ist ein Objekt, es hat einen [[Prototype]] Eigenschaft. Wenn Sie es nicht schaffen, alle Aufgaben zu Function.prototypedie .prototype's [[Prototype]] Punkte zu prototypisches Objekt (Object.prototype). Dieser wird automatisch ausgeführt, wenn Sie erstellen Sie eine neue Funktion.

Diese Weise, jedes mal, wenn Sie new Bar; die Prototyp-Kette für Sie eingerichtet, Sie bekommen alles, was definiert Bar.prototype und alles definiert Object.prototype:

var b = new Bar;
//Get all Bar.prototype properties
console.log(b.__proto__ === Bar.prototype)
//Get all Object.prototype properties
console.log(b.__proto__.__proto__ === Object.prototype)

Wenn Sie tun Zuweisungen zu Function.prototype alles, was Sie tun, ist die Erweiterung der Prototyp-Kette gehören zu einem anderen Objekt. Es ist wie ein einfügen in eine einfach verkettete Liste.

Diese grundsätzlich verändert die [[Prototype]] Kette ermöglicht definierten Eigenschaften auf das Objekt zugewiesen Function.prototype gesehen werden von jedem Objekt erstellt die Funktion.

---

<sup>[1: nicht verwechseln jedermann; über die __proto__ Eigenschaft in vielen Implementierungen.

[2]: Alle außer null.</sup>

InformationsquelleAutor der Antwort Jim Fasarakis Hilliard