Une brève introduction à quatre méthodes de détection de type de données dans JS

En JS, nous pouvons définir tous les types de variables avec une seule variable, ce qui est très pratique, mais cela nous pose également des problèmes si nous voulons savoir quel est le type de la valeur de retour d'une fonction, ou quelles sont les informations d'entrée. est Lors de la détermination du type, nous devons détecter les données, alors comment détecter le type de données ?

Méthode de détection du type de données :

• typeof : Opérateur utilisé pour détecter le type de données

• instanceof : Utilisé pour détecter si une instance appartient à une certaine classe

• constructeur : La fonction constructeur est très similaire à instanceof

• Object.prototype.toString .call (); La méthode la plus précise et la plus couramment utilisée

typeof
typeof : opérateur utilisé pour détecter le type de données ; la méthode d'utilisation est typeof + contenu détecté.

Utilisez typeof pour détecter le type de données. La première chose renvoyée est une chaîne, qui contient le type de données correspondant

var num  = 2;
console.log(typeof num); // ->控制台输出字符串numberconsole.log(typeof typeof typeof typeof function () {}); 
 // 输出的结果为字符串String，因为第一次使用typeof检测后结果为一个字符串数据类型的数据，以后每次检测都是String

typeof Limitations< ; 🎜> 1. Le résultat de typeof null est « objet »
2. Il ne peut pas être spécifiquement décomposé s'il s'agit d'un tableau, d'une expression régulière ou d'autres valeurs dans l'objet, car typeof est utilisé pour détecter le type de données pour les valeurs gauche et droite dans l'objet. type de données, le résultat final renvoyé est "object"

---

instanceofinstanceof : utilisé pour détecter si une instance appartient à une certaine classe. méthode d'utilisation : instanceof class name< ; 🎜>

Limitations d'instanceof

1. Il ne peut pas être utilisé pour traiter les valeurs de type de base créées par des littéraux : pour les types de données de base, il existe une certaine différence entre les résultats créés par les littéraux. et les résultats créés par les instances. Au sens strict, d'une manière générale, seul le résultat créé par l'instance est la valeur du type de données d'objet standard, et c'est également une instance de la classe Number standard le résultat créé par le littéral ; méthode est la valeur du type de données de base, pas une instance stricte, mais due à JS. La souplesse de la méthode vous permet d'utiliser les méthodes fournies sur Number.prototype

 console.log(1 instanceof Number);//->控制台输出false
 console.log(new Number(1) instanceof Number);//-> 控制台输出true

instanceof As tant qu'il est sur la chaîne prototype de l'instance actuelle, les résultats que nous détectons sont tous vrais
Dans l'héritage de la chaîne prototype de la classe, le résultat final que nous avons détecté peut ne pas être correct

 function Fn() {
 }  
 var  ary = new Array;
 Fn.prototype = ary;//原型继承：让子类的原型等于父类的一个实例
 var  f =new Fn; // f->Fn.prototype->Array.prototype->Object.prototype
 console.log(f instanceof Array); //-> true

---

constructor : Constructor Cette méthode est très similaire à instanceofconstructor：构造函数

var obj = [];
console.log(obj.constructor === Array ); //->trueconsole.log(obj.constructor === RegExp); //->false//console还可以出来基本的数据类型var num = 1;
console.log(num.constructor === Number);//->true// constructor检测和instanceof一同，一般情况下是检测不了的var  reg = /^$/;
console.log(reg.constructor === RegExp);//-> trueconsole.log(reg.constructor === RegExp);//-> false

Limitations

: Nous pouvons réécrire le prototype de la classe, et pendant le processus de réécriture, il est très probable que le constructeur précédent soit couvert, donc les résultats détectés sont inexacts pour les types de données spéciaux nuls et non définis, leurs classes sont Nulles et non définies ; mais le navigateur protège ces deux classes et ne nous permet pas d'y accéder. Utilisation

function Fn() {}  
Fn.prototype = new Array;var  f =new Fn;
console.log(f.constructor);//-> Array

---

Cette méthode est la méthode la plus longue et la plus précise de notre projet Object.prototype.toString.call(). Récupérez d'abord la méthode toString sur le prototype Object, laissez la méthode s'exécuter et changez le pointeur du mot clé this dans la méthode
Avant de comprendre cette méthode, comprenons d'abord
cette méthode
toString
 : Littéralement, elle est convertie en chaîne, mais certaines méthodes toString ne sont pas seulement converties en chaînes ; pour les prototypes Number, String, Boolean, Array, RegExp, Date et Function, les méthodes toString sont ① Convertir les données actuelles. tapez dans un type chaîne (leur fonction n'est utilisée que pour convertir en chaîne) ; mais la méthode toString sur le prototype Object est différente de celles-ci, ② Sa fonction est de renvoyer les détails de la classe à laquelle le corps d'exécution de la méthode actuelle (cela dans la méthode) appartient à l'information. toString
第一中类型转成字符串

        //Number.prototype.toString方法是转化为字符串  
        console.log((1).toString()); //->这里的toString是Number.prototype.toString用法是转成字符串-> '1'
        console.log((1).__proto__.__proto__.toString());//[object Object]
        console.log((128).toString(2/8/10));//把数字转化为二进制、八进制、十进制

Object原型上的

Après comparaison, la précision de notre quatrième méthode est la plus élevée, elle est donc souvent utilisée dans nos projets. Vous comprenez !!!

 ({name:'编程'}).toString();
 console.log(obj.toString());//-> toString中的this是Obj，返回的是obj所属类的信息->[Object Object]第一个Object代表当前实例是对象数据类型的(这个是固定死的)，第二个Object代表的是obj所属的类是ObjectMath.toString();//->toString中的this是Math，返回的是Math所属类的信息 ->  [Object Math]console.log(Object.prototype.toString.call([]));                //->[object Array]console.log(Object.prototype.toString.call(/^$/));               //->[object Array]console.log(({}).toString.call(new  Date));                      //->[object Date]console.log(Object.prototype.toString.call(1));                  //->[object Number]console.log(Object.prototype.toString.call('编程'));             //->[object String]console.log(Object.prototype.toString.call(null));               //->[object Null]console.log(Object.prototype.toString.call(undefined));          //->[object Undefined]console.log(Object.prototype.toString.call(function () {}));     //->[object Function]

Recommandations associées :

Explication détaillée de plusieurs façons de détecter les types de données dans le résumé javaScript

Plusieurs façons de déterminer le type de données en js

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!