Explication détaillée des 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. J'espère que cela pourra aider tout le monde.

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) Utiliser 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 un nombre + valeur de caractère, le résultat de la conversion sera La différence :

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, parseInt et parseFloat ne convertit que la première chaîne de caractères 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 en JS : undeinfed et null

indéfini font partie des 6 types de données en 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) Les variables sont déclarées mais jamais attribuées

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 undefined représente également Un état d'une variable, mais cette 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 état n'est pas défini, donc l'expression suivante est vraie :

var b;
b == undefined; //true

Après avoir compris undefined, il sera beaucoup plus facile de comprendre null Le type null 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"

Toujours par rapport à NaN, null est également une valeur d'état certaine et unique. Lorsqu'une variable se voit attribuer une valeur null, elle est alors égale. à null est égal, donc les expressions suivantes sont également vraies :

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

Recommandations associées :

Auto-apprentissage PHP no00010 type de données spécial valeur nulle

Introduction détaillée aux données de base types dans le développement JS

À propos de la différence entre les types de données de base et les types de données de référence dans 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!