Explication détaillée des types de base javascript_connaissances de base

Il existe un total de 5 valeurs primitives dans js, 6 qui peuvent être jugées par typeof et 9 constructeurs natifs intégrés.

Ces 569 constituent la base du langage js.

Les 5 valeurs primitives sont : nombres, caractères, booléen, nul, indéfini

Typeof peut juger : nombres, caractères, booléens, objets, fonctions, non définis. Notez que null et array, type des deux objets de sortie.

typeof ne peut pas faire la distinction entre les tableaux et les objets. Comment déterminer le type ? Utilisez Object.prototype.toString.apply().

if(value&&typeof value ==='object'&&value.constructor === Array)

La détection ci-dessus donnera faux si le tableau est créé dans des cadres et des fenêtres différents et que l'objet fenêtre est différent.

La méthode fiable est if(Object.prototype.toString.apply(value)==="[object Array]")

Le tableau arguments n'est pas un tableau, c'est juste un objet avec une propriété de membre length.
Comme le montre l'exemple suivant, les arguments ne sont pas des tableaux ordinaires

Copier le code Le code est le suivant :

var a = fonction (){
var b = Object.prototype.toString.apply(arguments);
console.log(b);

}
a();//Sortie [Arguments de l'objet]

Copier le code Le code est le suivant :

var a = fonction (){
var c = [];
var b = Object.prototype.toString.apply(c);
console.log(b);

}
a();//Sortie [tableau d'objets]

Comment instanceof détermine-t-il s'il s'agit d'une instance ?

Les attributs du prototype incluent le constructeur.

L'attribut prototype par défaut est un objet objet et peut être défini sur n'importe quelle valeur complexe, en ignorant la valeur d'origine.

Bien qu'il s'agisse d'un objet, il est spécial, et la chaîne circulaire relie chaque instance à l'attribut prototype de son constructeur. Il existe un lien caché entre l'instance et la propriété prototype du constructeur, qui est le __proto__ de l'instance. Dans le même temps, l'attribut constructeur de l'instance est obtenu via le constructeur du prototype constructeur.

Mais gardez le constructeur, afin que la nouvelle instance ait les attributs du constructeur, et vous pouvez également utiliser instanceof pour juger.

Copier le code Le code est le suivant :

var Foo = fonction(){}

Foo.prototype={constructeur:Foo}

var FooInstance = new Foo;

FooInstance.__proto__=== Foo.prototype;//true

FooInstance.constructor === Foo; //true

En fait, l'instance de jugement n'est pas basée sur le constructeur, mais sur la chaîne de prototypes, comme le montre l'exemple suivant

Copier le code Le code est le suivant :

var Foo = function(){};
Foo.prototype={};
var FooInstance = {};
FooInstance.__proto__=Foo.prototype;
console.log(FooInstance instanceof Foo);//true

Utiliser des valeurs primitives, pas de constructeurs

Quelles valeurs sont considérées comme fausses : false, "", null, 0, -0, NaN, undefined, celles-ci sont considérées comme fausses, les autres sont vraies

Mais s'il vous plaît faites attention à l'exemple suivant

Copier le code Le code est le suivant :

　　var a = Booléen(faux);
        var b = new Boolean(""
Si (a){console.log(a);}//Impossible de générer
Si (b){console.log(b);}//Boolean {[[PrimitiveValue]]: false} new est équivalent à un objet, ce n'est pas faux

L'article ci-dessus est un peu plus théorique, mais ceux-ci constituent la base du langage JavaScript et doivent être clairement compris.