JavaScript s'appuie sur les caractéristiques de nombreuses langues; Par exemple, la syntaxe Java, les fonctions s'appuient sur le schéma, l'héritage du prototype s'appuie sur soi et l'expression régulière tire de Perl. (DC JavaScript: Essence linguistique).
Premièrement, chaque JS est un langage orienté objet basé sur l'héritage du prototype. Le tableau à l'intérieur est un objet, la fonction est un objet, et bien sûr, "l'objet" est toujours un objet. De plus, chaque objet a un emplacement interne [[prototype]], qui est la clé pour connecter la chaîne prototype. Certes, nous pouvons définir une propriété prototype pour un objet, mais alors quoi? Ce n'est qu'une manifestation; Il y a une intention meurtrière cachée derrière elle.
OK, alors je peux utiliser isPrototypeOf () pour vérifier si un objet est un prototype d'un autre objet; Cependant, cela est également basé sur la chaîne [[prototype]].
Par exemple:
// Créer une fonction de fonction foo () {} // Modifiez la propriété du prototype de la fonction foo.prototype = {name: "foo.prototype"}; // créer une instance var a = new foo (); // Réécrivez le prototype par défaut de A, qui aurait dû être foo.prototype. a.prototype = {nom: "a.prototype"};La question suivante est de savoir si foo.prototype est le prototype de A? !
Cela doit être visualisé séparément: D'une part, a.prototype est en effet {nom: "a.prototype"}; Cependant, le résultat foo.prototype.isprototype de (a) est vrai.
Jetons un coup d'œil à la relation spécifique: (utiliser ---> signifie une chaîne [[prototype]] insignifiante, ---- signifie une relation de propriété prototype)
Fonction ---> function.prototype ---> objet.prototype
Function.prototype <--- foo ---- foo.prototype ------> objet.prototype.
De plus, [[Protptype]] du nombre, du booléen, de la chaîne, etc. est toujours un objet Function.prototype. L'objet fonction.prototype est "fonction" et ne contient pas [[construction]] à l'intérieur, il ne peut donc pas être utilisé comme constructeur; En fait, function.prototype est similaire: function () {}. En plus de la fente interne [[prototype]], le type "fonction" a également un attribut prototype. Chaque fonction a toujours un objet prototype: this.prototype = {constructeur: this} (un objet normal). Le [[prototype]] de cet objet normal est connecté à l'objet.prototype.
Le [[prototype]] de l'objet d'instance est-il créé par le constructeur un objet.prototype?
Le [[prototype]] de cette instance est initialisé par la propriété prototype du constructeur. Notez que ce n'est pas le [[prototype]] de la fonction. Donc, s'il s'agit d'un objet construit par la fonction objet, alors c'est en effet.
L'objet est une fonction, son prototype est le célèbre objet.prototype (un peu de non-sens), mais son [[prototype]] pointe vers la fonction.prototype. Veuillez voir ci-dessous:
Objet -----> function.prototype ------> objet.prototype.
Comment changer cette chaîne [[prototype]]?
Il peut être sous la forme de var a = object.create (obj) ou object.setprototypeof (obja, objb). Je ne pense pas qu'il soit nécessaire de donner des exemples, car la relation est très simple; Ne donnons que quelques exemples de merde. Aucun sens.
La dernière question est la suivante: la délégation comportementale basée sur la chaîne [[prototype]] est-elle?
Oui, c'est le cas.