Comment détecter divers types de javascript

1. Introduisez d'abord les 5 types originaux

5 Les types primitifs en JavaScript sont une chaîne , un nombre , booléen , indéfini , nul

 var name = "jack"; var age = 32; var single = false; var app; //undefinedConsole.log(ypeof name); //stringconsole.log(ypeof Âge); //numberconsole.log(ypeof single); //booleanconsole.log(ypeof app); //undefinedConsole.log(ypeof null); //objet

Il a été constaté que les quatre autres types de base, sauf NUL, peuvent être identifiés par typeof :

 if (typeof name === "String") {name + = "zhang"; } if (typeof Âge === "Number") {Age ++; } if (typeof single === "boolean" && single) {…} if (typeof app === "Undefined") {app = {}; }

Parce que le type de null obtiendra l'objet, utilisez === pour détecter directement Null:

 if (el === null) {…}

2. Objet

Les objets JavaScript incluent des objets intégrés ( date, regexp, erreur , etc.) et des objets personnalisés .

(Notez que bien que la fonction et le tableau soient également des objets intégrés, ils sont discutés séparément dans la section suivante)

Les objets ne peuvent pas être détectés à l'aide de types de base comme de base, car les résultats détectés sont tous des objets :

 console.log (typeof new Date ()); //ObjectConsole.log(Typeof new regexp ()); //ObjectConsole.log(Typeof new Error ()); //ObjectConsole.log(Typeof new Person ()); //ObjectConsole.log(Typeof new Person ()); // Utilisation de typeof pour détecter que l'objet personnalisé est également un objet

Pour utiliser l'instance à la place pour détecter:

 var date = new Date (); var reg = new regexp (); var err = new error (); var me = new personne (); if (date instanceof date) {// Date de détection Année = Date.getlyear (); } if (regGeOf regexp) {// Détection Expression régulière reg.Test (...); } if (err instanceof error) {// exception de détection Throw Err; } if (me instanceof personne) {// Détection objet personnalisé ...}

Mais il y a un problème avec les objets personnalisés, en supposant que la personne est définie à la fois dans Framea et Frameb du navigateur. L'objet ME est défini dans la Framea, et il est détecté comme vrai en utilisant me instanceof Person . Mais lorsque l'objet personnalisé ME est transmis à FrameB, l'instance de votre sera fausse dans FrameB.

Comme mentionné au début de cette section, bien que la fonction et le tableau soient également des objets intégrés, ils sont laissés à la section suivante. La raison en est que la fonction et le tableau ont également les mêmes problèmes ci-dessus que les objets personnalisés. Par conséquent, la fonction et le tableau n'utilisent généralement pas d'instance

3. Fonction

Ce qui précède indiquait que l'utilisation de l'instance de la fonction de détection ne peut pas traverser les cadres. Par conséquent, le typeof est utilisé pour détecter, qui peut être croisé:

 var func = function () {}; if (typeof func === 'function') {…}

Cependant, IE8 a utilisé le typeof pour détecter les fonctions DOM et obtiendrait un objet, donc IE8 utilisé dans:

 console.log (typeof document.getElementById); // objet, non functionconsole.log (typeof document.getElementsByTagName); // objet, non functionconsole.log (typeof document.CreateElement); // objet, pas fonction // les navigateurs IE avant IE8, utilisent dans pour détecter si la fonction DOM est prise en charge if ("getElementById" dans Document) {…} if ("getElementsByTagname" dans Document) {…} if ("getElementsByTagname" dans Document) {…} if ("CreateElement" dans le document) {…}

4. Array

Ce qui précède a indiqué que l'utilisation d'instructions pour détecter ce tableau ne peut pas traverser les cadres. Avant ES5, nous avons des méthodes de détection personnalisées. La méthode la plus précise: le toString qui dépend du tableau renvoie la chaîne fixe "[Array d'objets]" à détecter :

 fonction isArray (arr) {return object.prototype.tostring.call (arr) === "[Array d'objets]";}

Cette méthode est précise et élégante, elle a donc été adoptée par de nombreuses bibliothèques. Enfin, Array a été introduit comme une méthode ISARRAY dans ES5, faisant référence à MDN. Maintenant, vous n'avez pas besoin de personnaliser la méthode de détection, utilisez simplement ISArray () .

D'autres méthodes de détection ont leurs propres défauts et ne peuvent pas être précises à 100%. Mais comme un moyen de penser, il peut en tirer des leçons. Par exemple, en s'appuyant sur le fait que le tableau est le seul objet contenant la méthode de tri est détectée:

 fonction isArray (arr) {return typeof arr.sort === "fonction";}

Si la méthode de tri est également définie pour un objet personnalisé, la méthode sera invalide.

V. Attributs

Détecter si la propriété doit être utilisée dans l'objet d'instance. Si vous ne vous souciez pas de savoir si l'attribut est dans un objet d'instance ou dans un objet prototype, vous pouvez simplement utiliser

Par exemple, détecter les propriétés d'objets littéraux:

 var personne = {nom: "jack", âge: 33}; if ("name" en personne) {…} //trueif(person.hasownproperty("name ")) {…} // true

Par exemple les propriétés d'objet d'instance:

 var personne = fonction (nom, âge) {this.name = name; this.age = age;}; personne.prototype.location = "shanghai"; var me = new personne ("jack", 33) if ("name" in me) {…} //trueif(me.hasownproperty("name ")) {…} // truefif (" localisation "dans moi)".) " { … }//FAUX

Les autres méthodes ne sont pas bonnes:

 Si (objet [propName]) // pas bon, comment savez-vous que la valeur de la propriété n'est pas 0 ou 1? si (objet [propName] === null) // pas bon, comment savez-vous que la valeur de la propriété n'est pas nul? si (objet [propName] === Undefined) // pas bon, comment savez-vous que la valeur de la propriété n'est pas non définie?

Résumer

Utilisez le type de détection de chaîne, de numéro, booléen, indéfini, fonction

Détecter null avec ===

Détecter le tableau avec IsArray ()

Utilisez l'instance OFF pour détecter les objets intégrés (sauf la fonction et le tableau) et les objets personnalisés

Utilisez HasownProperty pour détecter si la propriété est dans l'objet d'instance. Si vous ne vous souciez pas de savoir si l'attribut est dans un objet d'instance ou dans un objet prototype, vous pouvez simplement utiliser

D'accord, c'est tout pour cet article sur la façon de détecter divers types de JavaScript. J'espère que tout le monde pourra étudier attentivement le contenu de cet article, ce qui peut être utile pour que tout le monde apprenne JavaScript.