Vérification du type JavaScript et propriétés internes [[Class]]

Tous les objets contiennent une propriété interne [[Class]]

Nous ne pouvons pas accéder directement à cette propriété, mais nous pouvons y accéder via une méthode
Cette méthode est Object.prototype.toString.call(...)
C'est aussi un moyen plus fiable de vérifier le type (instanceof, constructeur, etc. ne sont pas fiables)

Par exemple, si nous vérifions un tableau

Object.prototype.toString.call([1,2,3]);

Impression de console"[object Array]"
Le "Array" ici appelle en fait l'attribut [[Class]] à l'intérieur de la fonction native Array()
Nous pouvons encapsuler une fonction qui détecte le type

function classOf(obj){
    return Object.prototype.toString.call(obj).slice(8,-1);
}

La fonction est très simple, appelez simplement la méthode toString sur le prototype Object et interceptez les informations qui nous sont utiles
On peut essayer cette fonction

console.log(classOf({'a':1}));
console.log(classOf([1,2,3]));
console.log(classOf(function a(){}));
console.log(classOf(/a/));
console.log(classOf(123));
console.log(classOf('abc'));
console.log(classOf(true));
console.log(classOf(Symbol()));
console.log(classOf(undefined));
console.log(classOf(null));

Impression console

Mais nous avons trouvé que non seulement les objets, mais aussi les valeurs de type de base chaîne, nombre et booléen peuvent être imprimés
C'est parce que JavaScript encapsule un objet encapsulant pour les valeurs de type de base
les transformant en objets, et il y a des attributs [[ Class]] sur String(), Number() et Boolean()
Bien que undefined et null n'aient pas de fonctions natives correspondantes Undefined() et Null(), il y a toujours des attributs internes renvoyés

Par cette fonction, nous pouvons déterminer avec précision le type
Nous pouvons même déterminer la liste des paramètres

function demo(){
    console.log(classOf(arguments));
}
demo();//"Arguments"

---

Retour à Object.prototype.toString.call(...) Pourquoi est-il si difficile de passer une chaîne pour déterminer le type
Nous pouvons voir ce qui se passe si nous appelons directement toString()

console.log({'a':1}.toString());
console.log([1,2,3].toString());
console.log(function a(){}.toString());
console.log(/a/.toString());
console.log(123..toString());
// 只写一个点会被当成小数点，所以再写一个点代表方法调用console.log('abc'.toString());
console.log(true.toString());
console.log(Symbol().toString());
// 基本类型调用方法，会自动封装为对象
// 不能使用undefined.toString()或null.toString()会报错，因为没有对应的封装对象

Nous pouvons voir que seuls les objets ordinaires sont renvoyés comme nous voulons Oui,
C'est parce que les objets ordinaires appellent directement la méthode toString sur le prototype supérieur Object
, tandis que les tableaux, les fonctions et ces objets d'emballage de base héritent de Object et
remplacent certaines méthodes
Lors de la recherche la méthode toString, la méthode sur la propre chaîne de prototype doit être trouvée en premier
Nous devons donc utiliser call pour appeler la méthode toString de d sur le prototype supérieur Object.prototype

Ce qui précède est le type JavaScript vérifiez et Le contenu de l'attribut interne [[Class]], veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe !