Comment Javascript détermine-t-il le type de données et le type de tableau ?

Une chose aussi basique ne devrait vraiment plus être enregistrée, mais passons en revue le passé et apprenons quelque chose de nouveau~ Commençons par les types de données

Les six principaux types de données de js : nombre, chaîne, objet , Booléen, null, non défini

string : Décrit par des guillemets simples ou doubles, tels que "string"

number : Les nombres entiers et les nombres à virgule flottante sont tous appelés des nombres, vous savez~

Booléen : C'est vrai et faux

undéfini : Indéfini, c'est-à-dire que vous créez une variable mais ne lui attribuez pas de valeur~

null : D'où le nom Sijiu, null ne veut rien dire et ne veut rien dire

objet : C'est difficile pour moi d'expliquer ça. Autrement dit, les types autres que les cinq types ci-dessus

-----------------------------------Ceux ci-dessus sont tous des nuages ​​​​flottants, et ceux ci-dessous sont les dieux --- --------------------------

Type de jugement de type de données

typeof peut résoudre la plupart des problèmes Le jugement du type de données est une opération unaire. Il est placé avant une valeur d'opération. La chaîne décrit le type de l'opérande. Par conséquent, pour juger si un certain objet est de type String. directement if(typeof(your value) == "string"){}

Voici les résultats renvoyés par différents types de données :

var a="string"; console.log(a); //string
var a=1; console.log(a); //number
var a=false; console.log(a); //boolean
var a; console.log(typeof a); //undfined
 
var a = null; console.log(typeof a); //object
var a = document; console.log(typeof a); //object
var a = []; console.log(a); //object
 
var a = function(){}; console.log(typeof a) //function 除了可以判断数据类型还可以判断function类型

Il est évident que, à l'exception du les quatre premiers types, null , les objets et les tableaux renvoient des types d'objets ;

renvoie les types de fonctions pour les types de fonctions, tels que typeof(Date), typeof(eval), etc.

Ensuite, cela conduit à un autre problème très populaire pour lequel les solutions sont courantes. Comment déterminer si les données sont de type tableau ?

---------------------------------------------------------En fait, c'est moi Le but, hein~-------------------------------------------------------- ------ -

Méthode JS pour déterminer le type de tableau

Une des méthodes instanceof

instance, donc le nom suggère, instance, exemple, donc instanceof est utilisé pour déterminer si une variable est une certaine Une instance d'un objet est une expression arithmétique ternaire --- la différence la plus substantielle avec typeof

a instanceof b?alert("true"):alert("false" ) //Notez que la valeur b est vous. Le type de données que vous souhaitez déterminer n'est pas une chaîne, comme Array

Par exemple :

var a=[];
console.log(a instanceof Array) //返回true

Méthode 2 constructeur

Définition dans la définition du W3C : L'attribut constructeur renvoie une référence à la fonction tableau qui a créé cet objet

Il s'agit de renvoyer le constructeur correspondant à l'objet. La définition n'est pas cohérente avec instanceof, mais l'effet est le même

Par exemple : (une instance de Array) //Est-ce qu'une instance de Array ? true ou false

　 (a.constructor == Array) // Le constructeur correspondant à une instance est-il un Array true ou false

Par exemple :

function employee(name,job,born){
 this.name=name;
 this.job=job;
 this.born=born;
}
 
var bill=new employee("Bill Gates","Engineer",1985);
console.log(bill.constructor); //输出function employee(name, jobtitle, born){this.name = name; this.jobtitle = job; this.born = born;}

Ensuite, la façon de juger les différents types est la suivante :

console.log([].constructor == Array);
console.log({}.constructor == Object);
console.log("string".constructor == String);
console.log((123).constructor == Number);
console.log(true.constructor == Boolean);

------ - ---------------------------------Ce qui suit n'est pas original------------ ---- -----------------------

Méthode plus rigoureuse et commune :

function isArray(object){
 return object && typeof object==='object' &&
   Array == object.constructor;
}

! ! Remarque :

Lors de l'utilisation de instanceof et construcor, le tableau jugé doit être déclaré sur la page actuelle ! Par exemple, une page (page parent) a un cadre, et une page (page enfant) est référencée dans le cadre. Un tableau est déclaré dans la page enfant et affecté à une variable de la page parent. est jugé, Array == object.constructor; retournera false

Raison :

1. le transfert de l'adresse de référence.
2. L'adresse référencée par l'objet natif Array de chaque page est différente. Le constructeur correspondant du tableau déclaré dans la sous-page est l'objet Array de la sous-page ; Tableau Ce n'est pas égal au tableau de sous-pages ; rappelez-vous, sinon il sera difficile de suivre le problème !

Méthode 3 : Méthode de jugement caractéristique

Les méthodes ci-dessus présentent toutes certains défauts, mais nous devons croire que la sagesse du peuple est toute-puissante. Nous pouvons juger le tableau en fonction de certaines de ses caractéristiques. . Le type

function isArray(object){
 return object && typeof object==='object' &&
   typeof object.length==='number' &&
   typeof object.splice==='function' &&
    //判断length属性是否是可枚举的 对于数组 将得到false
   !(object.propertyIsEnumerable('length'));
}

a une longueur et une épissure et n'est pas nécessairement un tableau, car des attributs peuvent être ajoutés à l'objet, mais l'attribut de longueur ne peut pas être énuméré, ce qui est le facteur de jugement le plus important.

ps : vulgarisez la méthode propertyIsEnumerable ici :

object. propertyIsEnumerable(proName)

Jugez si la propriété spécifiée est énumérable

Remarque : si proName existe dans l'objet et peut être énuméré à l'aide d'une boucle For...In, la propriété propertyIsEnumerable renvoie true. La propriété propertyIsEnumerable renvoie false si l'objet n'a pas la propriété spécifiée ou si la propriété spécifiée n'est pas énumérable.

La propriété propertyIsEnumerable ne prend pas en compte les objets dans la chaîne de prototypes.

Exemple :

var a = new Array("apple", "banana", "cactus");
document.write(a.propertyIsEnumerable(1));

Méthode 4 La méthode la plus simple

function isArray(o) {
 return Object.prototype.toString.call(o) === ‘[object Array]‘;
}

Plus de Javascript Comment déterminer le type de données et Pour les articles concernant les types de tableaux, veuillez faire attention au site Web PHP chinois !