Die ultimative detaillierte Erklärung von JavaScript-Prototypen und Prototyp-Ketten_Javascript-Fähigkeiten

Die ultimative detaillierte Erklärung von JavaScript-Prototypen und Prototypketten

1. Gewöhnliche Objekte und Funktionsobjekte

In JavaScript ist alles ein Objekt! Aber auch die Objekte sind unterschiedlich. Es ist in gewöhnliche Objekte und Funktionsobjekte unterteilt. Objekt und Funktion sind die Funktionsobjekte, die mit JS geliefert werden. Hier sind einige Beispiele

function f1(){};
var f2 = function(){};
var f3 = new Function('str','console.log(str)');
var o3 = new f1();
var o1 = {};
var o2 =new Object();
console.log(typeof Object); //function
console.log(typeof Function); //function
console.log(typeof o1); //object
console.log(typeof o2); //object
　console.log(typeof o3); //object
　　console.log(typeof f1); //function
　　console.log(typeof f2); //function
　　console.log(typeof f3); //function 

Im obigen Beispiel sind o1 o2 o3 gewöhnliche Objekte und f1 f2 f3 Funktionsobjekte. Der Unterschied ist eigentlich ganz einfach zu erkennen. Alle durch new Function() erstellten Objekte sind Funktionsobjekte, andere sind gewöhnliche Objekte. f1, f2 werden letztendlich alle durch new Function() erstellt. Funktionsobjekte werden auch durch New Function() erstellt.

2. Prototypobjekt

Wenn in JavaScript ein Objekt (eine Funktion) definiert wird, enthält das Objekt einige vordefinierte Eigenschaften. Eine der Eigenschaften des Funktionsobjekts ist das Prototypobjekt. Hinweis: Gewöhnliche Objekte haben keinen Prototyp, sondern das Attribut __proto__.

Prototypobjekte sind eigentlich gewöhnliche Objekte (außer Function.prototype, das ein Funktionsobjekt ist, aber etwas ganz Besonderes. Es hat kein Prototypattribut (wie bereits erwähnt, haben Funktionsobjekte alle Prototypattribute)). Schauen Sie sich das Beispiel unten an:

function f1(){};
console.log(f1. prototype) //f1 {}
console.log(typeof f1. prototype) //Object
console.log(typeof Function. prototype) // Function
console.log(typeof Object. prototype) // Object
console.log(typeof Function. prototype. prototype) //undefined

Aus der Ausgabe dieses Satzes console.log(f1. prototyp) //f1 {} können wir ersehen, dass f1 prototyp ein Instanzobjekt von f1 ist. Beim Erstellen von f1 wird ein Instanzobjekt erstellt und seinem Prototyp zugewiesen. Der grundlegende Prozess ist wie folgt:

var temp = new f1();
f1. prototype = temp;

Es ist also leicht zu verstehen, warum Function.prototype ein Funktionsobjekt ist. Wie oben erwähnt, sind alle von new Function () generierten Objekte Funktionsobjekte, also ist temp ein Funktionsobjekt.

var temp = new Function ();
Function. prototype = temp;

Wofür wird das Prototypobjekt verwendet? Wird hauptsächlich zur Vererbung verwendet. Geben Sie ein Beispiel:

var person = function(name){
　　this.name = name
};
person.prototype.getName = function(){
return this.name;
}
var zjh = new person(‘zhangjiahao');
zjh.getName(); //zhangjiahao

从这个例子可以看出，通过给person.prototype设置了一个函数对象的属性，那有person实例（例中：zjh）出来的普通对象就继承了这个属性。具体是怎么实现的继承，就要讲到下面的原型链了。

三．原型链

JS在创建对象（不论是普通对象还是函数对象）的时候，都有一个叫做__proto__的内置属性，用于指向创建它的函数对象的原型对象prototype。以上面的例子为例：

console.log(zjh.__proto__ === person.prototype) //true

同样，person.prototype对象也有__proto__属性，它指向创建它的函数对象（Object）的prototype

console.log(person.prototype.__proto__ === Object.prototype) //true

继续，Object.prototype对象也有__proto__属性，但它比较特殊，为null

console.log(Object.prototype.__proto__) //null

我们把这个有__proto__串起来的直到Object.prototype.__proto__为null的链叫做原型链。如下图：

四．内存结构图

为了更加深入和直观的进行理解，下面我们画一下上面的内存结构图：

画图约定：

疑点解释：

1.Object.__proto__ === Function.prototype // true

Object是函数对象，是通过new Function()创建，所以Object.__proto__指向Function. prototype。

2.Function.__proto__ === Function.prototype // true

Function 也是对象函数，也是通过new Function()创建，所以Function.__proto__指向Function. prototype。

自己是由自己创建的，好像不符合逻辑，但仔细想想，现实世界也有些类似，你是怎么来的，你妈生的，你妈怎么来的，你姥姥生的，……类人猿进化来的，那类人猿从哪来，一直追溯下去……，就是无，（NULL生万物）

正如《道德经》里所说“无，名天地之始”。

3.Function.prototype.__proto__ === Object.prototype //true

其实这一点我也有点困惑，不过也可以试着解释一下。

Function.prototype是个函数对象，理论上他的__proto__应该指向 Function.prototype，就是他自己，自己指向自己，没有意义。

JS一直强调万物皆对象，函数对象也是对象，给他认个祖宗，指向Object. prototype。Object. prototype.__proto__ === null，保证原型链能够正常结束。

五．constructor

原型对象prototype中都有个预定义的constructor属性，用来引用它的函数对象。这是一种循环引用

person.prototype. constructor === person //true
Function.prototype.constructor === Function //true
Object.prototype.constructor === Object //true

完善下上面的内存结构图：

有两点需要注意：

1.注意Object.constructor===Function；//true 本身Object就是Function函数构造出来的
2.如何查找一个对象的constructor，就是在该对象的原型链上寻找碰到的第一个constructor属性所指向的对象

六．总结

1.原型和原型链是JS实现继承的一种模型。

2.原型链的形成是真正是靠__proto__ 而非prototype

要深入理解这句话，我们再举个例子，看看前面你真的理解了吗？

var animal = function(){};
var dog = function(){};
animal.price = 2000;//
dog.prototype = animal;
var tidy = new dog();
console.log(dog. price) //undefined
console.log(tidy.price) // 2000

Warum? Zeichnen Sie ein Speicherdiagramm:

Was bedeutet das? Bei der Ausführung von dog.price wurde festgestellt, dass es kein Preisattribut gibt. Obwohl das Tier, auf das der Prototyp zeigt, dieses Attribut hat, wird nicht entlang dieser „Kette“ gesucht. Wenn „Tidy.price“ ausgeführt wird, gibt es ebenfalls kein solches Attribut, aber __proto__ zeigt auf „Tier“ und sucht entlang dieser Kette. „Tier“ hat das Preisattribut, sodass Tidy.Price 2000 ausgibt. Daraus folgt, dass die tatsächliche Bildung der Prototypenkette auf __proro__ und nicht auf Prototypen beruht.

Wenn also dog.__proto__ = animal so angegeben wird. Dieser Hundepreis = 2000.

1

Lassen Sie mich zum Schluss eine Metapher geben, die zwar nicht sehr genau ist, aber für das Verständnis des Prototyps hilfreich sein kann.

Vater (Funktionsobjekt) hat einen ältesten Sohn (Prototyp) zur Welt gebracht, der Ihr ältester Bruder ist. Als Sie geboren wurden, wird die familiäre Bindung zwischen Ihnen (__proto__) bestehen Damit besitzen Sie automatisch die Spielsachen Ihres großen Bruders. Wenn Sie zuerst einen älteren Sohn haben und ihm viele Spielsachen kaufen, wird Ihr jüngerer Sohn, wenn Sie einen weiteren Sohn bekommen, natürlich alle Spielsachen Ihres älteren Sohnes haben. Ob sie kämpfen oder nicht, geht uns nichts an.

Du hast es also von deinem ältesten Bruder geerbt, was das Sprichwort „Ein Bruder ist wie ein Vater“ beweist