Frage Wie funktioniert JavaScript .prototype?


Ich bin das nicht in dynamische Programmiersprachen, aber ich habe meinen gerechten Anteil an JavaScript-Code geschrieben. Ich habe mich nie wirklich mit dieser prototypbasierten Programmierung beschäftigt, weiß jemand, wie das funktioniert?

var obj = new Object(); // not a functional object
obj.prototype.test = function() { alert('Hello?'); }; // this is wrong!

function MyObject() {} // a first class functional object
MyObject.prototype.test = function() { alert('OK'); } // OK

Ich erinnere mich an eine Diskussion, die ich vor einiger Zeit mit Leuten hatte (ich bin mir nicht ganz sicher, was ich mache), aber so wie ich es verstehe, gibt es kein Konzept für eine Klasse. Es ist nur ein Objekt, und Instanzen dieser Objekte sind Klone des Originals, richtig?

Aber was ist der genaue Zweck? .prototype Eigenschaft in JavaScript? Wie verhält es sich mit der Instanziierung von Objekten?


Bearbeiten

Diese Dias hat mir sehr geholfen, dieses Thema zu verstehen.


1856
2018-02-21 12:31


Ursprung


Antworten:


Jedes JavaScript-Objekt hat eine interne Eigenschaft namens [[Prototyp]]. Wenn Sie über eine Immobilie nachschlagen obj.propName oder obj['propName'] und das Objekt hat keine solche Eigenschaft - die man über prüfen kann obj.hasOwnProperty('propName') - Die Laufzeit sucht nach der Eigenschaft in dem Objekt, auf das von [[Prototyp]] verwiesen wird. Wenn das Prototyp-Objekt auch keine solche Eigenschaft besitzt, wird sein Prototyp der Reihe nach geprüft, wodurch die ursprünglichen Objekte durchlaufen werden Prototyp-Kette bis eine Übereinstimmung gefunden oder ihr Ende erreicht wird.

Einige JavaScript-Implementierungen ermöglichen den direkten Zugriff auf die Eigenschaft [[Prototype]], z. B. über eine nicht standardmäßige Eigenschaft namens __proto__. Im Allgemeinen kann der Prototyp eines Objekts nur während der Objekterstellung festgelegt werden: Wenn Sie ein neues Objekt über erstellen new Func()wird die Eigenschaft [[Prototyp]] des Objekts auf das Objekt gesetzt, auf das verwiesen wird Func.prototype.

Dies ermöglicht die Simulation von Klassen in JavaScript, obwohl das Vererbungssystem von JavaScript - wie wir gesehen haben - prototypisch und nicht klassenbasiert ist:

Man denke nur an Konstruktorfunktionen als Klassen und an die Eigenschaften des Prototyps (dh an das Objekt, auf das die Konstruktorfunktion verweist) prototype Eigenschaft) als gemeinsame Mitglieder, dh Mitglieder, die für jede Instanz gleich sind. In klassenbasierten Systemen werden Methoden für jede Instanz auf die gleiche Weise implementiert, sodass normalerweise Methoden zum Prototyp hinzugefügt werden, während die Felder eines Objekts instanzspezifisch sind und daher während der Konstruktion zum Objekt selbst hinzugefügt werden.


925
2018-02-21 13:33



In einer Sprache, die klassische Vererbung wie Java, C # oder C ++ implementiert, erstellen Sie zunächst eine Klasse - einen Entwurf für Ihre Objekte - und können dann neue Objekte aus dieser Klasse erstellen oder die Klasse erweitern und eine neue Klasse definieren, die erweitert die ursprüngliche Klasse.

In JavaScript erstellen Sie zuerst ein Objekt (es gibt kein Konzept der Klasse), dann können Sie Ihr eigenes Objekt erweitern oder neue Objekte daraus erstellen. Es ist nicht schwierig, aber ein wenig fremd und schwer zu verstoffwechseln für jemanden, der auf die klassische Art und Weise gebraucht wird.

Beispiel:

//Define a functional object to hold persons in JavaScript
var Person = function(name) {
  this.name = name;
};

//Add dynamically to the already defined object a new getter
Person.prototype.getName = function() {
  return this.name;
};

//Create a new object of type Person
var john = new Person("John");

//Try the getter
alert(john.getName());

//If now I modify person, also John gets the updates
Person.prototype.sayMyName = function() {
  alert('Hello, my name is ' + this.getName());
};

//Call the new method on john
john.sayMyName();

Bis jetzt habe ich das Basisobjekt erweitert, jetzt erstelle ich ein anderes Objekt und erben dann von Person.

//Create a new object of type Customer by defining its constructor. It's not 
//related to Person for now.
var Customer = function(name) {
    this.name = name;
};

//Now I link the objects and to do so, we link the prototype of Customer to 
//a new instance of Person. The prototype is the base that will be used to 
//construct all new instances and also, will modify dynamically all already 
//constructed objects because in JavaScript objects retain a pointer to the 
//prototype
Customer.prototype = new Person();     

//Now I can call the methods of Person on the Customer, let's try, first 
//I need to create a Customer.
var myCustomer = new Customer('Dream Inc.');
myCustomer.sayMyName();

//If I add new methods to Person, they will be added to Customer, but if I
//add new methods to Customer they won't be added to Person. Example:
Customer.prototype.setAmountDue = function(amountDue) {
    this.amountDue = amountDue;
};
Customer.prototype.getAmountDue = function() {
    return this.amountDue;
};

//Let's try:       
myCustomer.setAmountDue(2000);
alert(myCustomer.getAmountDue());

var Person = function (name) {
    this.name = name;
};
Person.prototype.getName = function () {
    return this.name;
};
var john = new Person("John");
alert(john.getName());
Person.prototype.sayMyName = function () {
    alert('Hello, my name is ' + this.getName());
};
john.sayMyName();
var Customer = function (name) {
    this.name = name;
};
Customer.prototype = new Person();

var myCustomer = new Customer('Dream Inc.');
myCustomer.sayMyName();
Customer.prototype.setAmountDue = function (amountDue) {
    this.amountDue = amountDue;
};
Customer.prototype.getAmountDue = function () {
    return this.amountDue;
};
myCustomer.setAmountDue(2000);
alert(myCustomer.getAmountDue());

Wie gesagt kann ich setAmountDue (), getAmountDue () für eine Person nicht aufrufen.

//The following statement generates an error.
john.setAmountDue(1000);

1755
2018-01-24 03:42



Ich spiele eine Rolle als JavaScript-Lehrer und das Prototyp-Konzept war schon immer ein kontroverses Thema, das ich behandeln sollte, wenn ich unterrichte. Es hat eine Weile gedauert, bis ich mir eine gute Methode ausgedacht habe, um das Konzept zu klären, und nun werde ich in diesem Text versuchen zu erklären, wie JavaScript .prototype funktioniert.


Dies ist ein sehr einfaches, prototypbasiertes Objektmodell, das während der Erklärung als Beispiel betrachtet wird, ohne Kommentar:

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

Es gibt einige entscheidende Punkte, die wir berücksichtigen müssen, bevor wir das Prototyp-Konzept durchgehen.

1- Wie JavaScript-Funktionen tatsächlich funktionieren:

Um den ersten Schritt zu machen, müssen wir herausfinden, wie JavaScript-Funktionen tatsächlich funktionieren, wie eine klassenähnliche Funktion this Schlüsselwort darin oder nur als eine reguläre Funktion mit ihren Argumenten, was sie tut und was sie zurückgibt.

Nehmen wir an, wir möchten ein erstellen Person Objektmodell. Aber in diesem Schritt werde ich es versuchen mach genau dasselbe ohne zu benutzen prototype und new Stichwort.

Also in diesem Schritt functions, objects und this Stichwort, sind alles was wir haben.

Die erste Frage wäre Wie this Schlüsselwort könnte ohne Verwendung nützlich sein new Stichwort.

Um dies zu beantworten, haben wir ein leeres Objekt und zwei Funktionen wie:

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

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

und nun ohne zu benutzen new Stichwort wie wir diese Funktionen nutzen könnten. JavaScript hat also drei verschiedene Möglichkeiten:

ein. Der erste Weg besteht darin, die Funktion nur als reguläre Funktion zu bezeichnen:

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

In diesem Fall wäre dies das aktuelle Kontextobjekt, das normalerweise global ist window Objekt im Browser oder GLOBAL im Node.js. Das heißt, wir hätten window.name im Browser oder GLOBAL.name in Node.js mit "George" als Wert.

b. Wir können anfügen sie zu einem Objekt, wie seine Eigenschaften

-Der einfachste Weg Um dies zu tun, ändert man das leere person Objekt, wie:

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

So können wir sie wie nennen:

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

und jetzt die person Objekt ist wie:

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

-Die andere Möglichkeit, eine Eigenschaft anzuhängen zu einem Objekt verwendet die prototype des Objekts, das in jedem JavaScript-Objekt mit dem Namen gefunden werden kann __proto__und ich habe versucht, es im zusammenfassenden Teil ein wenig zu erklären. So könnten wir das gleiche Ergebnis erzielen, indem wir Folgendes tun:

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

Aber Auf diese Weise modifizieren wir das Object.prototype, denn wenn wir ein JavaScript-Objekt mit Literalen erstellen ({ ... }), es wird basierend auf erstellt Object.prototype, was bedeutet, dass es als ein benanntes Attribut an das neu erstellte Objekt angehängt wird __proto__ Wenn wir es also ändern, wie wir es bei unserem vorherigen Code-Snippet getan haben, werden alle JavaScript-Objekte geändert, was keine gute Übung ist. Was könnte jetzt die bessere Praxis sein:

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

und jetzt sind andere Objekte in Frieden, aber es scheint immer noch keine gute Übung zu sein. Wir haben also noch eine Lösung, aber um diese Lösung zu verwenden, sollten wir zu dieser Codezeile zurückkehren person Objekt wurde erstellt (var person = {};) dann ändere es wie folgt:

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

Was es tut, ist ein neues JavaScript zu erstellen Object und befestigen Sie die propertiesObject zum __proto__ Attribut. Um sicherzustellen, dass Sie Folgendes tun können:

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

Aber der knifflige Punkt hier ist, dass Sie Zugriff auf alle Eigenschaften haben, die in definiert sind __proto__ auf der ersten Ebene der person Objekt (lesen Sie den Zusammenfassungsteil für weitere Details).


wie du siehst, wenn du einen dieser beiden Wege benutzt this würde genau auf die hinweisen person Objekt.

c. JavaScript bietet eine andere Möglichkeit, die Funktion bereitzustellen this, die verwendet Anruf oder sich bewerben um die Funktion aufzurufen.

Die Methode apply () ruft eine Funktion mit einem gegebenen Wert und auf   Argumente, die als ein Array (oder ein Array-ähnliches Objekt) bereitgestellt werden.

und

Die Methode call () ruft eine Funktion mit einem gegebenen Wert und auf   Argumente einzeln angegeben.

Auf diese Weise, die ich am liebsten mag, können wir unsere Funktionen leicht wie folgt benennen:

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 die ersten wichtigen Schritte, um die .prototype-Funktionalität zu ermitteln.


2- Wie funktioniert das? new Stichwort funktioniert?

Dies ist der zweite Schritt, um das zu verstehen .prototype Funktionalität.dies verwende ich, um den Prozess zu simulieren:

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

In diesem Teil werde ich versuchen, alle Schritte zu nehmen, die JavaScript braucht, ohne die new Schlüsselwort und prototypewenn du benutzt new Stichwort. also wenn wir es tun new Person("George"), Person Funktion dient als Konstruktor, Dies ist was JavaScript tut, eins nach dem anderen:

ein. vor allem macht es ein leeres Objekt, im Grunde ein leerer Hash wie:

var newObject = {};

b. Der nächste Schritt, den JavaScript benötigt, ist anfügen die alle Prototyp-Objekte für 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, wie JavaScript die Eigenschaften anfügt, die im Prototyp definiert sind. Der tatsächliche Weg hängt mit dem Konzept der Prototypkette zusammen.


ein. & b. Anstatt dieser beiden Schritte können Sie genau das gleiche Ergebnis erzielen:

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"

jetzt können wir die anrufen getName Funktion in unserem my_person_prototype:

newObject.getName();

c. dann gibt es das Objekt dem Konstruktor,

wir können dies mit unserem Beispiel tun wie:

Person.call(newObject, "George");

oder

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

dann kann der Konstrukteur tun, was er will, denn Dies Innerhalb dieses Konstruktors befindet sich das Objekt, das gerade erstellt wurde.

nun das Endergebnis vor dem Simulieren der anderen Schritte:     Objekt {Name: "George"}


Zusammenfassung:

Grundsätzlich, wenn Sie das verwenden Neu Schlüsselwort auf einer Funktion, Sie rufen das auf und diese Funktion dient als Konstruktor, also wenn Sie sagen:

new FunctionName()

JavaScript macht intern ein Objekt, einen leeren Hash und dann gibt es das Objekt an den Konstruktor, dann kann der Konstruktor tun, was er will, weil Dies Innerhalb dieses Konstruktors befindet sich das Objekt, das gerade erstellt wurde, und dann gibt es dieses Objekt natürlich, wenn Sie die Rückgabeanweisung in Ihrer Funktion nicht verwendet haben oder wenn Sie eine return undefined; am Ende deines Funktionskörpers.

Wenn also JavaScript nach einer Eigenschaft eines Objekts sucht, sucht es als erstes nach dem Objekt. Und dann gibt es eine geheime Eigenschaft [[prototype]] wofür wir es normalerweise mögen __proto__ und diese Eigenschaft ist, was JavaScript als nächstes betrachtet. Und wenn es durch die aussieht __proto__Soweit es wieder ein anderes JavaScript-Objekt ist, hat es ein eigenes __proto__Attribut, es geht nach oben und nach oben, bis es an den Punkt kommt, wo der nächste __proto__ ist Null. Der Punkt ist das einzige Objekt in JavaScript, das seine __proto__ Attribut ist null ist Object.prototype Objekt:

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

Und so funktioniert die Vererbung in JavaScript.

The prototype chain

Mit anderen Worten, wenn Sie eine Prototypeigenschaft für eine Funktion haben und Sie eine neue Eigenschaft aufrufen, nachdem JavaScript das neu erstellte Objekt auf Eigenschaften überprüft hat, wird es sich die Funktion ansehen .prototype und es ist auch möglich, dass dieses Objekt seinen eigenen internen Prototyp hat. und so weiter.


162
2018-02-13 19:32



prototype ermöglicht es Ihnen, Klassen zu machen. wenn du nicht benutzt prototype dann wird es eine statische.

Hier ist ein kurzes Beispiel.

var obj = new Object();
obj.test = function() { alert('Hello?'); };

Im obigen Fall haben Sie einen statischen Funktionstest. Auf diese Funktion kann nur mit obj.test zugegriffen werden, wo Sie sich obj als Klasse vorstellen können.

wo wie im folgenden Code

function obj()
{
}

obj.prototype.test = function() { alert('Hello?'); };
var obj2 = new obj();
obj2.test();

Das Objekt ist zu einer Klasse geworden, die jetzt instanziiert werden kann. Mehrere Instanzen von obj können existieren und sie alle haben die test Funktion.

Das oben genannte ist mein Verständnis. Ich mache es zu einem Community-Wiki, damit Leute mich korrigieren können, wenn ich falsch liege.


66
2017-11-07 09:48



Nachdem ich diesen Thread gelesen habe, bin ich verwirrt mit JavaScript Prototype Chain, dann habe ich diese Diagramme gefunden

http://iwiki.readthedocs.org/en/latest/javascript/js_core.html#vererbung *[[protytype]]* and <code>prototype</code> property of function objects

Es ist ein übersichtliches Diagramm, um die JavaScript-Vererbung nach Prototypenkette anzuzeigen

und

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

dieser enthält ein Beispiel mit Code und einigen schönen Diagrammen.

Die Prototypkette fällt letztendlich auf Object.prototype zurück.

Die Prototypkette kann technisch so lange erweitert werden, wie Sie möchten, indem Sie jedes Mal den Prototyp der Unterklasse einem Objekt der Elternklasse zuweisen.

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


59
2018-05-26 20:40



Die sieben Koans des Prototyps

Als Ciro San nach tiefer Meditation den Mount Fire Fox erreichte, war sein Geist klar und friedlich.

Seine Hand jedoch war unruhig und griff selbst nach einem Pinsel und notierte die folgenden Notizen.


0) Zwei verschiedene Dinge können als "Prototyp" bezeichnet werden:

  • die Prototyp - Eigenschaft, wie in obj.prototype

  • die interne Eigenschaft des Prototyps, bezeichnet als [[Prototype]]  in ES5.

    Es kann über die ES5 abgerufen werden Object.getPrototypeOf().

    Firefox macht es zugänglich durch die __proto__ Eigenschaft als Erweiterung. ES6 erwähnt jetzt einige optionale Anforderungen für __proto__.


1) Diese Konzepte existieren, um die Frage zu beantworten:

Wenn ich es tue obj.property, wo sucht JS? .property?

Intuitiv sollte die klassische Vererbung die Eigenschaftensuche beeinflussen.


2)

  • __proto__ wird für den Punkt verwendet . Eigenschaftensuche wie in obj.property.
  • .prototype ist nicht verwendet für die Suche direkt, nur indirekt, wie es bestimmt __proto__ bei der Objekterstellung mit new.

Nachschlage-Reihenfolge ist:

  • obj Eigenschaften hinzugefügt mit obj.p = ... oder Object.defineProperty(obj, ...)
  • Eigentum von obj.__proto__
  • Eigentum von obj.__proto__.__proto__, und so weiter
  • wenn einige __proto__ ist null, Rückkehr undefined.

Dies ist der sogenannte Prototyp-Kette.

Sie können vermeiden . Nachschlagen mit obj.hasOwnProperty('key') und Object.getOwnPropertyNames(f)


3) Es gibt zwei Hauptmöglichkeiten obj.__proto__:

  • new:

    var F = function() {}
    var f = new F()
    

    dann new wurde festgelegt:

    f.__proto__ === F.prototype
    

    Dies ist wo .prototype wird benutzt.

  • Object.create:

     f = Object.create(proto)
    

    Sätze:

    f.__proto__ === proto
    

4) Der Code:

var F = function() {}
var f = new F()

Entspricht dem folgenden Diagramm:

(Function)       (  F  )                                      (f)
 |  ^             | | ^                                        |
 |  |             | | |                                        |
 |  |             | | +-------------------------+              |
 |  |constructor  | |                           |              |
 |  |             | +--------------+            |              |
 |  |             |                |            |              |
 |  |             |                |            |              |
 |[[Prototype]]   |[[Prototype]]   |prototype   |constructor   |[[Prototype]]
 |  |             |                |            |              |
 |  |             |                |            |              |
 |  |             |                | +----------+              |
 |  |             |                | |                         |
 |  |             |                | | +-----------------------+
 |  |             |                | | |
 v  |             v                v | v
(Function.prototype)              (F.prototype)
 |                                 |
 |                                 |
 |[[Prototype]]                    |[[Prototype]]
 |                                 |
 |                                 |
 | +-------------------------------+
 | |
 v v
(Object.prototype)
 | | ^
 | | |
 | | +---------------------------+
 | |                             |
 | +--------------+              |
 |                |              |
 |                |              |
 |[[Prototype]]   |constructor   |prototype
 |                |              |
 |                |              |
 |                | -------------+
 |                | |
 v                v |
(null)           (Object)

Dieses Diagramm zeigt viele vordefinierte Objektknoten in Sprache: null, Object, Object.prototype, Function und Function.prototype. Unsere 2 Codezeilen wurden nur erstellt f, F und F.prototype.


5)  .constructor kommt normalerweise von F.prototype durch das . Sieh nach oben:

f.constructor === F
!f.hasOwnProperty('constructor')
Object.getPrototypeOf(f) === F.prototype
F.prototype.hasOwnProperty('constructor')
F.prototype.constructor === f.constructor

Wenn wir schreiben f.constructorJavaScript macht das . Nachschlagen als:

  • f hat nicht .constructor
  • f.__proto__ === F.prototype hat .constructor === F, also nimm es

Das Ergebnis f.constructor == F ist intuitiv richtig, da F wird verwendet, um zu konstruieren f, z.B. Felder setzen, ähnlich wie in klassischen OOP-Sprachen.


6) Klassische Vererbungssyntax kann durch Manipulieren von Prototypketten erreicht werden.

ES6 fügt das hinzu class und extends Schlüsselwörter, die einfach Syntaxzucker für bisher mögliche Manipulationswahnprototypen sind.

class C {
    constructor(i) {
        this.i = i
    }
    inc() {
        return this.i + 1
    }
}

class D extends C {
    constructor(i) {
        super(i)
    }
    inc2() {
        return this.i + 2
    }
}
// Inheritance syntax works as expected.
(new C(1)).inc() === 2
(new D(1)).inc() === 2
(new D(1)).inc2() === 3
// "Classes" are just function objects.
C.constructor === Function
C.__proto__ === Function.prototype
D.constructor === Function
// D is a function "indirectly" through the chain.
D.__proto__ === C
D.__proto__.__proto__ === Function.prototype
// "extends" sets up the prototype chain so that base class
// lookups will work as expected
var d = new D(1)
d.__proto__ === D.prototype
D.prototype.__proto__ === C.prototype
// This is what `d.inc` actually does.
d.__proto__.__proto__.inc === C.prototype.inc
// Class variables
// No ES6 syntax sugar apparently:
// http://stackoverflow.com/questions/22528967/es6-class-variable-alternatives
C.c = 1
C.c === 1
// Because `D.__proto__ === C`.
D.c === 1
// Nothing makes this work.
d.c === undefined

Vereinfachtes Diagramm ohne alle vordefinierten Objekte:

      __proto__
(C)<---------------(D)         (d)
| |                |           |
| |                |           |
| |prototype       |prototype  |__proto__
| |                |           |
| |                |           |
| |                | +---------+
| |                | |
| |                | |
| |                v v
|__proto__        (D.prototype)
| |                |
| |                |
| |                |__proto__
| |                |
| |                |
| | +--------------+
| | |
| | |
| v v
| (C.prototype)--->(inc)
|
v
Function.prototype

57
2018-06-18 19:48



Jedes Objekt hat eine interne Eigenschaft, [[Prototyp]], die es mit einem anderen Objekt verbindet:

object [[Prototype]] -> anotherObject

Im traditionellen JavaScript ist das verlinkte Objekt das prototype Eigenschaft einer Funktion:

object [[Prototype]] -> aFunction.prototype

In einigen Umgebungen ist [[Prototyp]] als verfügbar __proto__:

anObject.__proto__ === anotherObject

Sie erstellen den Link [[Prototyp]] beim Erstellen eines Objekts.

// (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

Diese Aussagen sind also äquivalent:

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

EIN new Aussage zeigt nicht das Linkziel (Object.prototype) selbst; stattdessen wird das Ziel vom Konstrukteur impliziert (Object).

Merken:

  • Jedes Objekt hat eine Verbindung, [[Prototyp]], manchmal als ausgesetzt __proto__.
  • Jede Funktion hat eine prototype Eigentum.
  • Objekte, die mit erstellt wurden new sind mit dem verbunden prototype Eigenschaft ihres Konstruktors.
  • Wenn eine Funktion niemals als Konstruktor verwendet wird, ist ihre prototype Eigentum wird ungenutzt bleiben.
  • Wenn Sie keinen Konstruktor benötigen, verwenden Sie Object.create Anstatt von new.

33
2018-02-21 12:41