Introduction à certaines fonctions cachées des objets d'objet

En JavaScript, les types de données sont principalement divisés en types primitifs et types de référence. Tous les types de référence proviennent de la copie de l'objet. Cet article est une introduction à certaines fonctions cachées de l'objet objet qui vous est apporté par l'éditeur du canal Error New Technology. Jetons un coup d'œil!

Cette propriété est définie dans le prototype de la classe. Une fois l'instance d'objet créée, il peut être appelé par l'instance d'objet via la chaîne __proto__ et pointe vers le constructeur de la classe actuelle. Cela peut déterminer à quelle classe appartient directement à un objet (contrairement à l'instance, l'instance ne se limite pas à la classe à laquelle l'objet appartient directement, même la classe parent renvoie true).

[Exemple]

trace (object.prototype.constructor == objet); // Sortie True

var a = nouveau objet ();

trace (a.Constructor == objet); // Sortie True

var b = new Array ();

trace (B.Contructor == Array); // Sortie True

trace (B.Constructor == Object); // Sortie fausse

trace (b instanceof objet); // Sortie True

Propriété: objet .__ Constructeur__

Cette fonction de propriété est similaire à object.constructor, la différence est qu'elle n'est pas définie dans le prototype de la classe, mais est attachée à l'instance d'objet lorsque l'instance d'objet est créée. Dans le même temps, cette propriété est également appelée implicitement lorsqu'elle est utilisée par le mot-clé Super comme constructeur de classe parent, et est utilisée pour pointer le constructeur de classe parent, c'est-à-dire super (...) équivaut à ce constructeur .__ Constructeur __. Call (this, ...).

[Exemple]

trace (object.prototype .__ Constructor__ == Object); // Sortie fausse

var a = nouveau objet ();

trace (a .__ Constructor__ == Object); // Sortie True

var b = new Array ();

trace (b .__ Constructor__ == Array); // Sortie True

trace (b .__ Constructor__ == Object); // Sortie fausse

Méthode: object.isprototypeof (classfunc)

Cette méthode est utilisée pour déterminer si l'objet actuel se trouve dans la chaîne __proto__ d'objet OBJ. Cette méthode peut être utilisée pour déterminer si une classe est un parent ou un enfant d'une autre classe.

[Exemple]

trace (object.prototype.isprototypeof (new object ())); // Sortie True

trace (object.prototype.isprototypeof (new Array ())); // Sortie True

trace (array.prototype.isprototypeof (new object ())); // Sortie fausse

trace (object.prototype.isprototypeof (array.prototype)); // juger si l'objet est la classe parent de Array, sortie true

Méthode: Object.SpropertyEnumerable (propName)

Cette méthode est utilisée pour déterminer si un membre nommé PropName existe dans l'objet actuel et peut être énuméré (en utilisant pour..in), en d'autres termes, s'il est visible (en utilisant la fonction globale AssetPropFlags pour définir si les propriétés de l'objet sont visibles).

[Exemple]

var a = {x: 1, y: 2};

AssetPropFlags (a, ["y"], 1); // set y est invisible

Trace (AY); // seule sortie 2

pour (var i dans a) trace (i); // seule sortie x

trace (a.ispropertyEnumableable ("x")); // Sortie True

trace (a.ispropertyenumableable ("y")); // Sortie fausse

Méthode: object.hasownproperty (propName)

Cette méthode est utilisée pour déterminer si un membre nommé PropName est un membre de l'objet actuel lui-même, plutôt que référencé à partir du prototype de la classe via la chaîne __proto__.

[Exemple]

Fonction Test () {}

test.prototype.x = 1;

var a = nouveau test ();

ay = 2;

trace (ax); // Sortie 1

trace (a.hasownproperty ("x")); // Sortie fausse

Trace (AY); // Sortie 2

Trace (a.hasownproperty ("y")); // Sortie True

Méthode: object.toString ()

Cette méthode peut définir le résultat de chaîne généré par un objet lorsqu'il est converti en type de chaîne, qui est généralement défini dans le prototype de classe.

[Exemple]

Point de fonction (x, y) {

this.x = x;

this.y = y;

}

Point.prototype.toString = function () {

return "[x:" + this.x + ", y:" + this.y + "]";

};

var pos = nouveau point (10, 20);

trace ("position est" + pos); // La position de sortie est [x: 10, y: 20]

Ce qui précède est une introduction à certaines fonctions cachées des objets d'objet. Je crois que tout le monde a une compréhension claire. Plus de connaissances sur le canal technique se trouvent dans le mauvais canal de la nouvelle technologie!