Une analyse approfondie de la relation entre prototype et proto dans les compétences JavaScript_javascript

prototype, chaque objet fonction a un attribut prototype affiché, qui représente le prototype de l'objet (l'exception est l'objet fonction Function.prototype, qui n'a pas d'attribut prototype).

__proto__ : chaque objet possède un attribut caché interne nommé __proto__, qui pointe vers son objet prototype correspondant (le nom est __proto__ dans Chrome et Firefox, et est accessible). La chaîne de prototypes est formée sur la base de __proto__

(remarque : non basé sur le prototype de propriété de l'objet fonction).

Pour faire simple : __proto__ est le prototype interne, et prototype est le prototype du constructeur (le constructeur est en fait une fonction)

Le prototype du constructeur est un objet

Alors, qu'est-ce qu'un constructeur ?

Pour créer un objet, vous devez d'abord avoir un constructeur d'objet, tout comme en PHP. Si vous souhaitez créer un objet, vous devez d'abord avoir une classe
L'essence d'un constructeur est une fonction. La question suivante est : Comment créer un objet via ce constructeur ?

Réponse : nouveau

Le constructeur construit un objet.

1. Le __proto__ de tous les constructeurs/fonctions pointe vers Function.prototype, qui est une fonction vide (fonction vide)

Numéro.__proto__ === Fonction.prototype
// vrai
Boolean.__proto__ === Function.prototype
// vrai
String.__proto__ === Function.prototype
// vrai
Objet.__proto__ === Fonction.prototype
// vrai
Function.__proto__ === Function.prototype
// vrai
Tableau.__proto__ ===
Fonction.prototype
// vrai
RegExp.__proto__ === Function.prototype
// vrai
Erreur.__proto__ ===
Fonction.prototype
// vrai
Date.__proto__ ===
Fonction.prototype
// vrai

explique que Number et ainsi de suite sont tous des constructeurs, et ces constructeurs sont en fait un objet de Function. En d’autres termes, cela équivaut à var Number = new Function();

Il existe un total de 12 constructeurs/objets intégrés en JavaScript (JSON est nouvellement ajouté dans ES5). Voici 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__ === Objet.prototype
// vrai
JSON.__proto__ === Objet.prototype
// vrai

Les "tous les constructeurs/fonctions" mentionnés ci-dessus incluent certainement des constructeurs personnalisés. Comme suit

// Déclaration de fonction
fonction Personne()
{}
//Expression de fonction
var Homme
=
fonction()
{}
console.log(Person.__proto__ === Function.prototype)
// vrai
console.log(Man.__proto__ ===
Fonction.prototype)
// vrai

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 la longueur, l'appel, l'application, la liaison (ES5).

Function.prototype est également le seul prototype dont le type XXX.prototype est "fonction". Le prototype des autres constructeurs est un objet. Comme suit

console.log(typeof Function.prototype)
// fonction
console.log (type d'objet.prototype)
// objet
console.log(type de Number.prototype)
// objet
console.log(type de Boolean.prototype)
// objet
console.log (type de String.prototype)
// objet
console.log (type de tableau.prototype)
// objet
console.log (type de RegExp.prototype)
// objet
console.log (type d'erreur.prototype)
// objet
console.log(type de Date.prototype)
// objet
console.log (type d'objet.prototype)
// objet

Oh, il a également été mentionné ci-dessus qu'il s'agissait d'une fonction vide, jetons un coup d'œil à alert(Function.prototype).

Nous savons que le __proto__ de tous les constructeurs (y compris ceux intégrés et personnalisés) sont Function.prototype, alors qui est le __proto__ de Function.prototype ?

Je crois que vous avez entendu dire que les fonctions en JavaScript sont également des citoyens de premier ordre, alors où pouvez-vous montrer cela ? Comme suit

console.log(Function.prototype.__proto__ ===
Objet.prototype)
// vrai

Cela montre que tous les constructeurs sont également des objets JS ordinaires et que des attributs peuvent être ajoutés/supprimés au constructeur. En même temps, il hérite également de toutes les méthodes sur Object.prototype : toString, valueOf, hasOwnProperty, etc.

Qui est le __proto__ d'Object.prototype ?

Objet.prototype.__proto__ ===
nul //
vrai

Permettez-moi de partager avec vous un diagramme de relation mémoire entre fonction, objet, prototype et __proto__