Sept types de valeurs et opérateur typeof en JavaScript

Je prévois de revoir JavaScript à partir des bases,

Au fait, j'aimerais partager et résumer ce que j'ai appris

---

Types intégrés

Types intégrés

• Il existe sept types dans les types intégrés JavaScript, dont six types de base et un type de référence

Type de base
• numéro (numéro)

• chaîne

• booléen

• non défini

• null (valeur vide)

symbole (symbole) [spécification ES6 nouvelle]
Référence type

objet (objet)

Remarque : tableau tableau et fonction fonction sont des objets spéciaux, c'est également à disons, ce sont des "sous-types" d'objets et sont également des valeurs de référence

Le type de base est un simple segment de données stocké dans la mémoire de la pile, et il y a un espace fixe dans la mémoireLe type de référence est stocké dans le tas Les objets en mémoire sont accessibles par référence. La mémoire de la pile stocke le pointeur vers l'objet (l'adresse d'accès de l'objet est stockée) La raison pour laquelle la pile est divisée en mémoire est parce qu'elle est liée au mécanisme de collecte des ordures du navigateur pour assurer le fonctionnement Il occupe la plus petite quantité de mémoirePeu importe si vous ne comprenez pas ce qui précède, tant que vous savez que le type de base est les données de pile et la référence type est des données de tas

.

typeof L'opérateur

peut également être considéré comme l'opérateur typeof L'opérateur opérateur fait référence à la même chose
Grâce à ce typeof, nous pouvons vérifier. le type de valeur

La chaîne de son type de retour (minuscule anglais), mais tous les types ne peuvent pas être identifiés

console.log(typeof 123);
// "number"console.log(typeof '123');
// "string"console.log(typeof true);
// "boolean"console.log(typeof undefined);
// "undefined"console.log(typeof Symbol());
// "symbol"console.log(typeof null);
// "object"  <-注意看这里console.log(typeof {demo: 123});
// "object"

Nous avons imprimé ces sept types sur la console et avons trouvé un problème
typeof null en fait, il a renvoyé "objet"
Hmm, comme nous nous y attendions. C'est différent
Il a été promis de renvoyer "null"
En fait, il s'agit d'un problème historique. Ce bug existe depuis plus de 20 ans (plus de 20 ans). moi)

Probablement pour toujours. Il ne sera pas réparé car cela implique trop de systèmes Web, et le coût de sa "réparation" est inimaginable

---

Mais nous pouvons juger le type de valeur nulle de cette façon

var foo = null;if(!foo && typeof foo === 'object'){    console.log('这是一个空值...');
}

car quel que soit l'objet, même un objet vide, il sera vrai une fois converti en valeur booléenne (j'en parlerai plus tard quand j'écrirai la conversion de type)

Vous pouvez donc juger null comme ça, mais je ne semble pas l'avoir utilisé

---

Retour En ce qui concerne le problème de typeof, nous avons également découvert un problème

console.log(typeof function(){});// "function"

typeof a un traitement spécial pour les fonctions , qui sont des citoyens de premier ordre en JavaScript - des objets exécutables
Donc, bien que les fonctions soient des objets, Mais l'opérateur typeof peut distinguer et renvoyer une "fonction"
Quant à la raison pour laquelle la fonction peut être appelée, c'est parce qu'elle a un attribut interne [[call]], c'est donc un "objet appelable". Nous en reparlerons plus tard
Oh, au fait, bien que les tableaux soient aussi des objets spéciaux, typeof ne les reconnaît pas
Si vous le souhaitez. pour distinguer les tableaux, vous pouvez lire ce que j'ai écrit sur la façon d'identifier les tableaux
Donc les types de valeurs de retour incluent ces chaînes

number, string, boolean, undefined , object, function, symbol

---

Maintenant que nous parlons de type de, il y a un autre petit point de connaissance

console.log(typeof NaN)// "number"

Il est aussi facile de faire des erreurs, il peut y avoir des questions d'entretien
Mais cela peut Ce n'est pas un bug Not a number NaN en anglaisNot a Number
'Not a number'
Cela signifie : un nombre qui n'est pas un nombre est un nombre
Ça n'a pas d'importance, ça n'a pas d'importance important

Maintenant, rappelez-vous simplement que NaN est de type numéro

---

Oh, au fait, je me suis soudainement souvenu typeof(a b)Bien que typeof puisse être utilisé de cette manière

Mais c'est n'est pas une fonction, pas une fonction, pas une fonction (les choses importantes sont dites trois fois)
est un opérateur unaire Rappelez-vous

l'utilisation ci-dessus est juste une vérification de type pour le résultat de l'opération d'opérande dans l'expression.

valeur et type

Ici, j'explique un tel problème
En JavaScript, les variables n'ont pas de types, seules les valeurs ont des types
L'opérateur typeof renvoie une chaîne du type de valeur détenue par la variable
Parce que nous sommes faibles Langage de type

Nous pouvons donc changer le type de valeur détenue par la variable

var foo = 123;console.log(typeof foo);
// "number"foo = true;console.log(typeof foo);
// "boolean"foo = 'abc';console.log(typeof foo);
// "string"

Bien que le type de valeur de la variable puisse être modifié, nous ne devons pas faire cela lorsque nous écrivons des projets
Nous pouvons ajouter des préfixes aux variables Ou ajouter des symboles spéciaux pour nous rappeler quel type de variable nous déclarons

Par exemple, retArr, bFlag, strLen et autres

type de non déclaré

Ce non déclaré est bien sûr la clé de la non-existence des mots
Mais pourquoi j'écris comme ça

Regardons une question<🎜>

console.log(foo);

我没定义foo就打印，于是

果不其然，浏览器蒙圈了
给大家翻译成中文：未捕获引用错误: foo没有定义
可能大家都不会去注意，其实这是很容易让人误会的
在这了 is not defined != is undefind
因为我连声明都没声明，怎么谈定义
所以如果浏览器报出is not declared或许更准确
我们暂且把这种连定义都没定义的变量看作“undeclared”变量
但是对于这种“undeclared”未定义的变量，typeof有特殊的安全防范机制

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

出乎意料的，它对于undeclared变量并没有报错，而是返回了“undefined”
虽然我们觉得它返回“undeclared”更容易理解一些（我们的要求太高了）
其实它没有报错就相当不错了
这种容错对于我们来说还是很有帮助的
比如说我们想知道全局空间有没有变量foo

if(foo){  //若不存在会报错
    //...}if(typeof foo !== 'undefined'){  //不存在也不会报错
    //...}if(window.foo){  //不存在同样不会报错
    //...}

最后一种通过window对象调用与undeclared变量不同
访问不存在的对象属性是不会报错的，而是返回undefined(是类型而不是字符串)
不过如果我们全局对象不是window的话，就不能使用这种方法了（比如，node.js）

总结

JavaScript内置类型:

• 基本类型（栈数据）：number、string、boolean、undefined、null、object、symbol（ES6规范新增）

• 引用类型（堆数据）：object

typeof操作符返回值：

• “number”

• “string”

• “boolean”

• “undefined”

• “object”

• “function”【sp】

• “symbol”

typeof null -> “object” 历史遗留bug

typeof NaN -> ‘number’ 注意

变量没有类型，其持有值有类型

typeof的容错机制可以用来检查undeclared（未声明）变量

 以上就是JavaScript中的七种值类型与typeof运算符的内容，更多相关内容请关注PHP中文网（www.php.cn）！