Explication détaillée du prototype JS et de la chaîne de prototypes (3)

Cette fois, suite à l'article précédent, regardons le prototype JS et la chaîne de prototypes ainsi que les précautions Ce qui suit est un cas pratique, jetons un coup d'œil.

7. Objets fonction (revoir les points de connaissances précédents)

Proto de tous les objets fonction Tous pointez sur Function.prototype, qui est une fonction vide (fonction vide)

Number.__proto__ === Function.prototype  // true
Number.constructor == Function //true
Boolean.__proto__ === Function.prototype // true
Boolean.constructor == Function //true
String.__proto__ === Function.prototype  // true
String.constructor == Function //true
// 所有的构造器都来自于Function.prototype，甚至包括根构造器Object及Function自身
Object.__proto__ === Function.prototype  // true
Object.constructor == Function // true
// 所有的构造器都来自于Function.prototype，甚至包括根构造器Object及Function自身
Function.__proto__ === Function.prototype // true
Function.constructor == Function //true
Array.__proto__ === Function.prototype   // true
Array.constructor == Function //true
RegExp.__proto__ === Function.prototype  // true
RegExp.constructor == Function //true
Error.__proto__ === Function.prototype   // true
Error.constructor == Function //true
Date.__proto__ === Function.prototype    // true
Date.constructor == Function //true

Il y a un total de 12 constructeurs/objets intégrés (intégrés) en JavaScript (JSON est récemment ajouté dans ES5 ), ici répertorie 8 constructeurs accessibles. Le reste comme Global n'est pas accessible directement, les arguments ne sont créés par le moteur JS que lorsque la fonction est appelée, Math et JSON existent sous forme d'objets et n'en nécessitent pas de nouveaux. Leur proto est Object.prototype. Comme suit

Math.__proto__ === Object.prototype  // true
Math.construrctor == Object // true
JSON.__proto__ === Object.prototype  // true
JSON.construrctor == Object //true

Les objets fonction mentionnés ci-dessus incluent certainement des objets personnalisés. Comme suit

// 函数声明
function Person() {}
// 函数表达式
var Perosn = function() {}
console.log(Person.__proto__ === Function.prototype) // true
console.log(Man.__proto__ === Function.prototype)    // true

Qu'est-ce que cela signifie ?

** Tous les constructeurs proviennent de Function.prototype, même le constructeur racine Object et Function lui-même. Tous les constructeurs héritent des propriétés et méthodes de Function.prototype. Tels que longueur, appeler, postuler, lier**

(Vous devez comprendre la première phrase, nous continuerons à parler de la deuxième phrase dans la section suivante, creusez d'abord un trou :))
Fonction .prototype est également le seul prototype dont le type XXX.prototype est une fonction. Le prototype des autres constructeurs est un objet (la raison a été expliquée dans la section 3). Comme suit (revu à nouveau) :

console.log(typeof Function.prototype) // function
console.log(typeof Object.prototype)   // object
console.log(typeof Number.prototype)   // object
console.log(typeof Boolean.prototype)  // object
console.log(typeof String.prototype)   // object
console.log(typeof Array.prototype)    // object
console.log(typeof RegExp.prototype)   // object
console.log(typeof Error.prototype)    // object
console.log(typeof Date.prototype)     // object
console.log(typeof Object.prototype)   // object

Oh, il est aussi mentionné plus haut que c'est une fonction vide, console.log(Function.prototype), jetez un œil (attention, j'en parlerai dans la section suivante) Ceci)

Sachant que le __proto__ de tous les constructeurs (y compris ceux intégrés et personnalisés) est Function.prototype, alors qui est le __proto__ de Function.prototype ?
Je pense que vous avez tous entendu dire que les fonctions en JavaScript sont également des citoyens de premier ordre, alors comment pouvez-vous le montrer ? Comme suit

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

Cela montre que tous les constructeurs sont également des objets JS ordinaires et que vous pouvez ajouter/supprimer des attributs au constructeur. En même temps, il hérite également de toutes les méthodes d'Object.prototype : toString, valueOf, hasOwnProperty, etc. (Il faut aussi comprendre la première phrase. Nous continuerons à parler de la deuxième phrase dans la section suivante. Pas besoin de creuser un trou, c'est toujours le même trou ;))

Enfin, qui est le prototype d'Object.prototype ?
Object.prototype.__proto__ === null // true
a atteint le sommet et est nul. (Lisez-le maintenant et revenez au chapitre 5. Comprenez-vous ?)

8 Prototype

Parmi tous les attributs définis par le noyau ECMAScript, le plus Quoi. Ce qui est intrigant, c'est l'attribut prototype. Pour les types référence dans ECMAScript, le prototype est le véritable endroit où sont stockées toutes leurs méthodes d'instance. En d'autres termes, les méthodes telles que toString() et valueOf() sont en fait stockées sous le nom du prototype, mais sont accessibles via les instances des objets respectifs.

——"JavaScript Advanced Programming" Troisième édition P116

Nous savons que JS dispose de méthodes intégrées que nous pouvons utiliser, telles que :
Les objets peuvent utiliser constructor/toString( )/valueOf () et d'autres méthodes ;
Les tableaux peuvent utiliser map()/filter()/reducer() et d'autres méthodes ;
Les nombres peuvent utiliser parseInt()/parseFloat() et d'autres méthodes ;
Pourquoi? ? ?

Lorsque nous créons une fonction :

var Person = new Object()
Person est une instance de Object, donc Person hérite de l'objet prototype d'Object Object.prototype Toutes les méthodes :

Object.prototype

Chaque instance de Object possède les propriétés et méthodes ci-dessus.
Je peux donc utiliser Person.constructor ou Person.hasOwnProperty.

Lorsque nous créons un tableau :

var num = new Array()
num est une instance de Array, donc num hérite de l'objet prototype d'Array Array.prototype Toutes les méthodes :

Array.prototype

Vous vous moquez de moi, pourquoi est-ce un tableau vide ? ? ?

Nous pouvons utiliser une nouvelle méthode fournie par ES5 : Object.getOwnPropertyNames
pour obtenir tous les noms de propriétés (y compris les propriétés non énumérables) à l'exclusion des propriétés du prototy, et renvoyer un tableau :

var arrayAllKeys = Array.prototype; // [] 空数组// 只得到 arrayAllKeys 这个对象里所有的属性名(不会去找 arrayAllKeys.prototype 中的属性)console.log(Object.getOwnPropertyNames(arrayAllKeys));
/* 输出：
["length", "constructor", "toString", "toLocaleString", "join", "pop", "push",
"concat", "reverse", "shift", "unshift", "slice", "splice", "sort", "filter", "forEach",
"some", "every", "map", "indexOf", "lastIndexOf", "reduce", "reduceRight",
"entries", "keys", "copyWithin", "find", "findIndex", "fill"]
*/

这样你就明白了随便声明一个数组，它为啥能用那么多方法了。

细心的你肯定发现了Object.getOwnPropertyNames(arrayAllKeys) 输出的数组里并没有 constructor/hasOwnPrototype等对象的方法（你肯定没发现）。
但是随便定义的数组也能用这些方法

var num = [1];console.log(num.hasOwnPrototype()) // false (输出布尔值而不是报错)

Why ？？？

因为Array.prototype 虽然没这些方法，但是它有原型对象（__proto__）：

// 上面我们说了 Object.prototype 就是一个普通对象。
Array.prototype.__proto__ == Object.prototype

所以 Array.prototype 继承了对象的所有方法，当你用num.hasOwnPrototype()时，JS 会先查一下它的构造函数 （Array） 的原型对象 Array.prototype 有没有有hasOwnPrototype()方法，没查到的话继续查一下 Array.prototype 的原型对象 Array.prototype.__proto__有没有这个方法。

当我们创建一个函数时：

var f = new Function("x","return x*x;");
//当然你也可以这么创建 f = function(x){ return x*x }
console.log(f.arguments) // arguments 方法从哪里来的？
console.log(f.call(window)) // call 方法从哪里来的？
console.log(Function.prototype) // function() {} （一个空的函数）
console.log(Object.getOwnPropertyNames(Function.prototype)); 
/* 输出
["length", "name", "arguments", "caller", "constructor", "bind", "toString", "call", "apply"]
*/

我们再复习第八小节这句话：

所有函数对象proto都指向 Function.prototype，它是一个空函数（Empty function）

嗯，我们验证了它就是空函数。不过不要忽略前半句。我们枚举出了它的所有的方法，所以所有的函数对象都能用，比如:

九. 复习一下

第八小节我们总结了：

所有函数对象的 __proto__ 都指向 Function.prototype，它是一个空函数（Empty function）

但是你可别忘了在第三小节我们总结的：

所有对象的 __proto__ 都指向其构造器的 prototype

我们下面再复习下这句话。

先看看 JS 内置构造器：

var obj = {name: 'jack'}
var arr = [1,2,3]
var reg = /hello/g
var date = new Date
var err = new Error('exception') 
console.log(obj.__proto__ === Object.prototype) // true
console.log(arr.__proto__ === Array.prototype)  // true
console.log(reg.__proto__ === RegExp.prototype) // true
console.log(date.__proto__ === Date.prototype)  // true
console.log(err.__proto__ === Error.prototype)  // true

再看看自定义的构造器，这里定义了一个 Person：

function Person(name) { 
 this.name = name;
}
var p = new Person('jack')
console.log(p.__proto__ === Person.prototype) // true

p 是 Person 的实例对象，p 的内部原型总是指向其构造器 Person 的原型对象 prototype。

每个对象都有一个 constructor 属性，可以获取它的构造器，因此以下打印结果也是恒等的：

function Person(name) {
    this.name = name
}
var p = new Person('jack')
console.log(p.__proto__ === p.constructor.prototype) // true

上面的Person没有给其原型添加属性或方法，这里给其原型添加一个getName方法：

function Person(name) { 
   this.name = name
}
// 修改原型
Person.prototype.getName = function() {}
var p = new Person('jack')
console.log(p.__proto__ === Person.prototype) // true
console.log(p.__proto__ === p.constructor.prototype) // true

可以看到p.__proto__与Person.prototype，p.constructor.prototype都是恒等的，即都指向同一个对象。

如果换一种方式设置原型，结果就有些不同了：

function Person(name) {  
  this.name = name
}
// 重写原型Person.prototype = {  
  getName: function() {}
}
var p = new Person('jack')
console.log(p.__proto__ === Person.prototype) // true
console.log(p.__proto__ === p.constructor.prototype) // false

这里直接重写了 Person.prototype（注意：上一个示例是修改原型）。输出结果可以看出p.__proto__仍然指向的是Person.prototype，而不是p.constructor.prototype。

这也很好理解，给Person.prototype赋值的是一个对象直接量{getName: function(){}}，使用对象直接量方式定义的对象其构造器（constructor）指向的是根构造器Object，Object.prototype是一个空对象{}，{}自然与{getName: function(){}}不等。如下：

var p = {}
console.log(Object.prototype) // 为一个空的对象{}
console.log(p.constructor === Object) // 对象直接量方式定义的对象其constructor为Objectconsole.log(p.constructor.prototype === Object.prototype) // 为true，
不解释(๑ˇ3ˇ๑)

十. 原型链（再复习一下：）

下面这个例子你应该能明白了！

function Person(){
}var person1 = new Person();
console.log(person1.__proto__ === Person.prototype); // true
console.log(Person.prototype.__proto__ === Object.prototype) //true
console.log(Object.prototype.__proto__) //null
Person.__proto__ == Function.prototype; //true
console.log(Function.prototype)// function(){} (空函数)
var num = new Array()console.log(num.__proto__ == Array.prototype) // true
console.log( Array.prototype.__proto__ == Object.prototype) // true
console.log(Array.prototype) // [] (空数组)
console.log(Object.prototype.__proto__) //null
console.log(Array.__proto__ == Function.prototype)// true

疑点解惑：

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

Object 是函数对象，是通过new Function()创建的，所以Object.__proto__指向Function.prototype。（参照第八小节：「所有函数对象的__proto__都指向Function.prototype」）

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

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

自己是由自己创建的，好像不符合逻辑，但仔细想想，现实世界也有些类似，你是怎么来的，你妈生的，你妈怎么来的，你姥姥生的，……类人猿进化来的，那类人猿从哪来，一直追溯下去……，就是无，（NULL生万物）
正如《道德经》里所说“无，名天地之始”。

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

其实这一点我也有点困惑，不过也可以试着解释一下。
Function.prototype是个函数对象，理论上他的__proto__应该指向 Function.prototype，就是他自己，自己指向自己，没有意义。
JS一直强调万物皆对象，函数对象也是对象，给他认个祖宗，指向Object.prototype。Object.prototype.__proto__ === null，保证原型链能够正常结束。

十一 总结

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

原型链的形成是真正是靠__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

这里解释一下：

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

这个明白吧？想一想我们上面说过这句话：

实例（tidy）和 原型对象（dog.prototype）存在一个连接。不过，要明确的真正重要的一点就是，这个连接存在于实例（tidy）与构造函数的原型对象（dog.prototype）之间，而不是存在于实例（tidy）与构造函数（dog）之间。

聪明的你肯定想通了吧 ：）

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!