Pourquoi utiliser Object.prototype.toString.call(obj) pour détecter le type d'objet ?

J'ai récemment fait quelques interviews js 25 questions d'entretien JavaScript essentielles*, dont la première est : Quels sont les inconvénients de l'utilisation de typeof bar === "object" pour détecter si « bar » est un objet ? Comment l'éviter ?

C'est une question très courante. Pouvez-vous utiliser typeof pour déterminer avec précision une variable objet La réponse est non. Le résultat de null est également un objet, et le résultat de est aussi un objet Parfois, ce dont nous avons besoin est un objet "pur". Comment l'éviter ? Une meilleure façon est : Array

console.log(Object.prototype.toString.call(obj) === "[object Object]");

L'utilisation de la méthode ci-dessus permet de bien distinguer différents types :

(les types d'objets personnalisés ne peuvent pas être distingués, les types personnalisés peuvent être distingués à l'aide d'instanceof)

console.log(Object.prototype.toString.call("jerry"));//[object String]
console.log(Object.prototype.toString.call(12));//[object Number]
console.log(Object.prototype.toString.call(true));//[object Boolean]
console.log(Object.prototype.toString.call(undefined));//[object Undefined]
console.log(Object.prototype.toString.call(null));//[object Null]
console.log(Object.prototype.toString.call({name: "jerry"}));//[object Object]
console.log(Object.prototype.toString.call(function(){}));//[object Function]
console.log(Object.prototype.toString.call([]));//[object Array]
console.log(Object.prototype.toString.call(new Date));//[object Date]
console.log(Object.prototype.toString.call(/\d/));//[object RegExp]
function Person(){};
console.log(Object.prototype.toString.call(new Person));//[object Object]

Pourquoi peut-on faire la différence comme ça ? J'ai donc jeté un œil à l'utilisation de la méthode toString : la méthode toString renvoie une chaîne qui reflète cet objet.

Alors pourquoi ne pas simplement utiliser obj.toString() ?

console.log("jerry".toString());//jerry
console.log((1).toString());//1
console.log([1,2].toString());//1,2
console.log(new Date().toString());//Wed Dec 21 2016 20:35:48 GMT+0800 (中国标准时间)
console.log(function(){}.toString());//function (){}
console.log(null.toString());//error
console.log(undefined.toString());//error

est également l'objet de détection obj appelant la méthode toString (pour l'utilisation de la méthode toString(), veuillez vous référer à l'explication détaillée de toString), le résultat de obj. toString() et

Le résultat de Object.prototype.toString.call(obj) est différent de Pourquoi est-ce ?

C'est parce que

toString est la méthode prototype d'Object, et , Arrayfunction et d'autres types, en tant qu'instances d'Object, remplacent tous toString Méthode. Lorsque différents types d'objets appellent la méthode toString, sur la base de la connaissance de la chaîne de prototypes, la méthode toString réécrite correspondante est appelée (le type de fonction renvoie une chaîne dont le contenu est le corps de la fonction , Le type Array renvoie une chaîne composée d'éléments...) et n'appelle pas la méthode prototype toString sur Object (renvoie le type spécifique de l'objet), utilisez donc obj.toString() ne peut pas obtenir son type d'objet et ne peut convertir obj qu'en un type de chaîne. Par conséquent, lorsque vous souhaitez obtenir le type spécifique d'un objet, vous devez appeler la méthode prototype toString sur Object ;

Nous pouvons le vérifier en supprimant la méthode toString du tableau et voir quel sera le résultat :

var arr=[1,2,3];console.log(Array.prototype.hasOwnProperty("toString"));//true
console.log(arr.toString());//1,2,3
delete Array.prototype.toString;//delete操作符可以删除实例属性
console.log(Array.prototype.hasOwnProperty("toString"));//false
console.log(arr.toString());//"[object Array]"

Après avoir supprimé la méthode toString de Array , de même, lorsque la méthode arr.toString() est utilisée, aucune méthode d'instance ne protège la méthode prototype Object. Par conséquent, le long de la chaîne de prototypes, arr appelle finalement la méthode toString de Object, renvoyant et

Object. prototype.toString.call(arr) même résultat.

Résumé : Ce qui précède représente l'intégralité du contenu de cet article, j'espère qu'il sera utile à l'étude de chacun. Pour plus de didacticiels connexes, veuillez visiter le

Tutoriel vidéo JavaScript !

Recommandations associées :

Tutoriel vidéo de formation sur le bien-être public php

Tutoriel graphique JavaScript

Manuel JavaScript en ligne

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!