Explication détaillée du typeof et du jugement de type en javascript

Cet article vous propose principalement un article basé sur le typeof et le jugement de type en JavaScript (explication détaillée). L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur et jetons un œil. J'espère que cela pourra aider tout le monde.

typeof

ECMAScript a 5 types primitifs, à savoir Undefined, Null, Boolean, Number et String. Nous savons tous que vous pouvez utiliser l'opérateur typeof pour trouver le type d'une variable, mais pour les variables de type référence, il ne renverra qu'un objet, ce qui signifie que typeof ne peut identifier correctement que les variables de valeur de type de base.

var a = "abc";
console.log(typeof a); // "string"
var b = 123;
console.log(typeof b); // "number"
var c = true;
console.log(typeof c); // "boolean"
var d = null;
console.log(typeof d); // "object"
var f = undefined;
console.log(typeof f); // "undefined"
var g;
console.log(typeof g); // "undefined"

console.log(typeof x); // "undefined"

Vous pouvez vous demander pourquoi l'opérateur typeof renvoie "objet" pour les valeurs nulles. Il s'agissait en fait d'un bug dans l'implémentation originale de JavaScript qui a ensuite été adoptée par ECMAScript. Maintenant, null est considéré comme un espace réservé pour un objet, expliquant ainsi la contradiction, mais techniquement, c'est toujours une valeur primitive.

Le dernier est étrange, le type d'une variable x inexistante renvoie en fait "objet" au lieu de "indéfini".

Nous arrivons au code suivant :

var a = function() { };
console.log(typeof a); // "function"
var b = [1,2,3]; 
console.log(typeof b); // "object"
var c = { };
console.log(typeof c); // "object"

Renvoie "objet" pour les tableaux et les objets, donc un besoin commun dans notre développement quotidien est de savoir comment déterminer si une variable est une un tableau ou un objet.

Jugement de type

Le jugement de type détermine généralement s'il s'agit d'un tableau ou d'un objet vide. C'est la méthode de jugement que j'ai utilisée ou vue quotidiennement pour cette exigence

Jugez s'il s'agit d'un tableau

Il existe un tableau : var a = [1,2,3,4,5 ];

Méthode 1 :

toString.call(a); // "[object Array]" Méthode deux :

une instance de Array ; true méthode Trois :

a.constructor == Array; //true La première méthode est plus générale, qui est l'abréviation de Object.prototype.toString.call(a).

Les variables jugées par instanceof et constructeur doivent être déclarées sur la page actuelle. Par exemple, une page (page parent) a un cadre, le cadre fait référence à une page (page enfant) et une page enfant est déclarée. . a, et attribuez-le à une variable de la page parent. Lors du jugement de la variable, Array == object.constructor retournera false

var a = [1,2,3,4,5];
console.log(toString.call(a)); // "[object Array]"      
console.log(a instanceof Array); //true
console.log(a.constructor == Array); //true

Jugez s'il s'agit d'un objet vide

function isEmptyObject(e) { 
var t; for (t in e) return !1; return !0 } //trueisEmptyObject(obj);
//falseisEmptyObject({ "a":1, "b":2});

Introduction à l'utilisation de typeof en JavaScript

Exemples détaillés d'utilisation comparative de typeof et instanceof en JavaScript

Résumé de l'utilisation de typeof 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!