typeof et instanceof sont tous deux utilisés pour déterminer les types de données, mais leurs scénarios d'utilisation sont différents et certains détails nécessitent une attention particulière. Découvrons-le ensuite, maîtrisons parfaitement ce point de connaissance et n'ayons plus peur des questions de l'intervieweur.
typeof est un opérateur unaire placé devant un opérande, qui peut être de n'importe quel type. Il renvoie une chaîne décrivant le type de l'opérande. Veuillez regarder le châtaignier :
const type = typeof 'Long Live China' // string;
type de 666 ; //numéro
type de vrai ; // booléen
type de non défini ; // non défini
type de symbole (); // symbole
type de 1n ; // bigint
typeof () => {}; // fonction
type de []; // objet
type de {} ; // objet
typeof new String('xxx'); // objet
typeof null; // object Comme le montrent les exemples ci-dessus, typeof ne peut déterminer avec précision que les types de données et les fonctions de base (les fonctions sont en fait des objets et n'appartiennent pas à un autre type de données, mais elles peuvent également être distinguées à l'aide de typeof) et ne peuvent pas être déterminé avec précision. Le type de données de référence (tous les objets de retour).
Une chose à noter est que l'appel typeof null renvoie object . En effet, la valeur spéciale null est considérée comme une référence à un objet null (également appelé pointeur d'objet null).
Si vous souhaitez déterminer avec précision le type de données de référence, vous pouvez utiliser instanceof .
L'opérateur instanceof est placé après un opérande et avant l'objet donné. Il renvoie une valeur booléenne indiquant si l'opérande est une instance de l'objet donné :
const result = [] instanceof Array // true;
const Personne = fonction() {};
const p = nouvelle personne ();
p instance de Personne ; // vrai
const message = new String('xxx');
message instanceof String ; // vraie typeof renverra le type de base d'un opérande, instanceof renvoie une valeur booléenne
instanceof peut déterminer avec précision le type de données de référence, mais ne peut pas déterminer correctement le type de données de base
typeof bien qu'il puisse déterminer le type de données de base ( sauf null), mais il est impossible de déterminer le type de données de référence (sauf fonction)
typeof et instanceof présentent tous deux certains inconvénients et ne peuvent pas répondre aux besoins de tous les scénarios. Si vous avez besoin de détecter universellement les types de données, vous pouvez utiliser Object.prototype.toString.call() :
Object.prototype.toString.call({});
Object.prototype.toString.call([]); // "[tableau d'objets]"
Object.prototype.toString.call(666); // "[Numéro d'objet]"
Object.prototype.toString.call('xxx'); // "[object String]" Notez que cette méthode renvoie une chaîne au format "[object Object]" .
Pour une utilisation plus pratique, nous pouvons encapsuler cette méthode :
function getType(value) {
let type = type de valeur ;
if (type !== 'object') { // S'il s'agit d'un type de données de base, renvoie directement return type;
}
// S'il s'agit d'un type de données de référence, un jugement plus approfondi est effectué et le résultat de retour régulier est return Object.prototype.toString.call(value).replace(/^[object (S+)]$/, ' 1$');
}
getType(123); // nombre
getType('xxx'); // chaîne
getType(() => {}); // fonction
getType([]); // Tableau
getType({}); // Objet
getType(null); // Null