Quels sont les types de données spéciaux en JavaScript ?

En JavaScript, il existe 6 principaux types de données, dont chaîne, nombre, booléen, non défini, nul et objet. Ce qui suit est une introduction aux types de données spéciaux en JavaScript à travers cet article. Les amis qui en ont besoin peuvent s'y référer

En JavaScript, il existe 6 principaux types de données, dont chaîne, nombre, booléen, non défini, nul. et objet

1. Types spéciaux en JS : NaN

NaN signifie Pas un nombre, pas un nombre Alors, qu'est-ce que NaN exactement ? Pour JS, les nombres entiers et les nombres à virgule flottante sont collectivement appelés type nombre. De plus, le type nombre a également une valeur très spéciale, à savoir NaN, qui est utilisée pour indiquer s'il s'agit d'un état du type nombre, plutôt que d'un exact. valeur (donc, NaN n’est pas égal à lui-même).

Alors, dans quelles circonstances les valeurs NaN apparaissent-elles généralement ?

Généralement il y a deux situations :

(1) S'il y a des opérateurs tels que le signe moins (-), le signe de multiplication (*) ou le signe de division (/) dans une expression, JS The Le moteur essaiera de convertir les variables des deux côtés de l'opérateur en type numérique (utilisez Number(x) pour la conversion) avant le calcul. Si la conversion échoue, l'expression renverra NaN ; l'opérateur de signe plus (+) ne convertira pas le. variables des deux côtés. La variable est convertie en type numérique, car l'ordre d'exécution des expressions JS est de gauche à droite en fonction de la priorité de l'opérateur. sont de type nombre, la comparaison numérique sera effectuée, si l'une des variables est une chaîne, les deux côtés seront ajoutés sous forme de chaînes, telles que : 5+4+"6"="96"

<.>(2) Utilisez directement parseInt, parseFloat ou Number Lors de la conversion d'une valeur non numérique en nombre, l'expression renvoie NaN

"abc" - 3  // NaN
parseInt( "abc" ) // NaN
parseFloat( "abc" ) //NaN
Number( "abc" )  //NaN

Pour la valeur de nombre + caractère, le résultat de la conversion sera différent :

Number( "123abc" ); //NaN
parseInt( "123abc" ); //123
parseInt( "123abc45" ); //123
parseFloat( "123.45abc" ); //123.45

En effet, Number convertit la valeur entière, pas une partie de la valeur, et parseInt et parseFloat ne convertissent que la chaîne avant le premier caractère invalide.

Par conséquent, lorsqu'une chaîne ne peut pas être convertie avec succès par Number, parseInt, parseFloat, NaN est renvoyé, indiquant que la chaîne ne peut pas être reconnue comme un type numérique. Il s'agit d'un statut d'exception et non d'une valeur exacte.

Donc NaN != NaN , car c'est une exception et non une valeur exacte.

De plus, il existe une fonction liée à NaN, à savoir isNaN(). Sa fonction est de vérifier si une chaîne peut être convertie avec succès par Number(), c'est-à-dire de forcer la conversion de la chaîne entière. .

isNaN( "123" )  //false 能转换
isNaN( "abc" )  //true 不能转换
isNaN( "123abc" )  //true 部分可转换，但整体不能转换
isNaN( "123.45abc" ) //true 部分可转换，但整体不能转换

2. Il existe deux autres types spéciaux dans JS : undeinfed et null

undefined est l'un des 6 types de données dans JavaScript Un type qui n'a qu'une seule valeur, qui n'est pas définie. undefined signifie « non défini », c'est-à-dire que lorsqu'une variable est déclarée à l'aide de var mais qu'aucune valeur n'est attribuée, la valeur de la variable est indéfinie. Il y a deux raisons à cela :

(1) L'objet d'accès le fait. n'existe pas Attributs ou méthodes

(2) La variable est déclarée mais n'a jamais reçu de valeur

var v1,obj = {};
console.log(v1); //undefined
console.log(obj. get ); //undefined
typeof v1; // "undefined"
typeof v2; // "undefined"
typeof obj. get ; // "undefine"
typeof obj ; // "object"

La différence avec NaN est que bien qu'indéfini représente également un état de la variable, ceci. la valeur d'état est unique, c'est-à-dire que lorsqu'une variable est déclarée mais qu'aucune valeur ne lui est attribuée, son statut est indéfini, donc l'expression suivante est vraie :

var b;
b == undefined; //true

Après avoir compris undéfini, il sera beaucoup plus facile de comprendre null, null Le type n'a également qu'une seule valeur : null, ce qui signifie qu'une variable ne contient pas de données valides. Null signifie ici une valeur vide ou un objet vide. Pour être plus précis, une variable affectée à null ne stocke pas de valeur, de chaîne, de booléen, de tableau ou d'objet valide, etc. Cela peut être résolu en attribuant null à une variable. de la variable. Il n'y a qu'une seule raison pour null : c'est-à-dire attribuer explicitement null à une variable.

var p = null ;
console.log(p); //null
typeof p ; // "object"
typeof null ; // "object"

Comparons-le avec NaN. Null est également une valeur d'état certaine et unique Lorsqu'une variable se voit attribuer une valeur null, elle est égale à null, donc l'expression suivante est également vraie :

var obj = null ;
obj == null ; //true

De plus :

var  v1 = null;
var v2;
console.log(v1 + 1 ); // 1
console.log(v2 + 1 ); //NaN
var i = i +1;
var j = i+ 1;
console.log(i); // NaN
console.log(j ); //NaN
console.log(i == j ); //false

Ce qui précède est ce que j'ai compilé pour vous. J'espère qu'il vous sera utile à l'avenir.

Articles connexes :

Comment utiliser fs.rename dans node.js pour implémenter le renommage forcé

Utiliser npm pour créer une vue project (Tutoriel détaillé)

Y a-t-il une erreur lors de l'appel de fs.renameSync dans Node.js ?

Comment configurer l'environnement de développement React Native dans VSCode

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!