Il y a 5 valeurs d'origine dans JS, 6 types de jugement et 9 constructeurs intégrés natifs.
Ce 569 constitue la base de la langue JS.
Les 5 valeurs originales sont: nombres, caractères, booléens, nuls, indéfinis
TypeOf peut juger: nombres, caractères, booléens, objet, fonction, indéfini. Notez que Null et les tableaux, type de l'objet de sortie.
Le typeof ne peut pas distinguer les tableaux et les objets. Comment juger les types? Utilisez object.prototype.tostring.apply ().
if (value && typeof value === 'objet' && valeur.constructor === array)
Si la détection ci-dessus est créée dans différentes trames et fenêtres, FALSE sera donné et l'objet Window sera différent.
Une méthode fiable est if (object.prototype.tostring.apply (valeur) === "[Array d'objet]")
Le tableau des arguments n'est pas un tableau, c'est juste un objet avec un attribut de membre de longueur.
Comme indiqué dans l'exemple suivant, les arguments ne sont pas des tableaux ordinaires
La copie de code est la suivante:
var a = fonction () {
var b = object.prototype.toString.Apply (arguments);
console.log (b);
}
a (); // sortie [arguments d'objet]
La copie de code est la suivante:
var a = fonction () {
var c = [];
var b = object.prototype.toString.Apply (C);
console.log (b);
}
a (); // sortie [Array d'objets]
Comment l'instance de déterminer si une instance est une instance
Les propriétés du prototype ont un constructeur.
La propriété Prototype par défaut est un objet d'objet qui peut être défini sur n'importe quelle valeur complexe, ignorer le paramètre sur la valeur d'origine.
Bien qu'il soit tout un objet, il est spécial et la chaîne circulaire relie chaque instance à la propriété prototype de son constructeur. Il existe un lien caché entre l'instance et l'attribut prototype du constructeur, qui est le __proto__ de l'instance. Dans le même temps, l'attribut de constructeur de l'instance est obtenu via le constructeur du constructeur du prototype de fonction du constructeur.
Cependant, nous devons conserver le constructeur, afin que la nouvelle instance puisse avoir l'attribut de constructeur, et nous pouvons également utiliser l'instance pour juger.
La copie de code est la suivante:
var foo = function () {}
Foo.prototype = {constructeur: foo}
var fooInstance = new foo;
FOOInstance .__ proto __ === foo.prototype; // true
Foinstance.constructor === foo; //vrai
En fait, l'instance de jugement n'est pas basée sur le constructeur, mais sur la chaîne prototype, comme indiqué dans l'exemple suivant
La copie de code est la suivante:
var foo = function () {};
Foo.prototype = {};
var fooinstance = {};
FOOInstance .__ proto __ = foo.prototype;
console.log (instance fooinstance de foo); // true
Utilisez des valeurs d'origine, pas de constructeurs
Quelles valeurs sont fausses: fausses, "", null, 0, -0, nan, indéfini, ce sont faux, d'autres sont vrais
Mais faites attention à l'exemple suivant
La copie de code est la suivante:
var a = boolean (false);
var b = new boolean ("");
if (a) {console.log (a);} // ne peut pas sortir
if (b) {console.log (b);} // boolean {[[primitiveValue]]: false} nouveau est équivalent à un objet, ce n'est pas faux
L'article ci-dessus est un peu plus théorique, mais ce sont la base de la langue javascript, et vous devez le comprendre clairement.