Combien de types de données primitifs y a-t-il dans es6

Il existe 6 types de données primitifs : 1. Le type Null, qui représente une valeur "vide", c'est-à-dire qu'il n'y a pas de valeur ; 2. Le type non défini, qui représente un type indéfini ; nombres flottants, etc.) 4. Type de chaîne, un morceau de texte entouré de guillemets simples ou doubles ; 5. Type de symbole, etc.

L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.

Il existe 9 types de données dans es6, qui peuvent être divisés en deux catégories :

• Types de données primitifs (6 types) : Chaîne, Nombre, Booléen, Null, Non défini, Symbole ;

• Types de données de référence ( 3 types) : Objet, Tableau, Fonction.

Parlons des 6 types de données primitifs.

1, Type Null

Null est un type de données spécial avec une seule valeur, qui représente une valeur "nulle", c'est-à-dire qu'il n'y a aucune valeur, rien, et est utilisé pour définir un pointeur d'objet nul.

Utilisez l'opérateur typeof pour vérifier le type de Null. Vous constaterez que le type de Null est Object

var a = null;
console.log(typeof a);

Cela signifie que Null utilise en fait une valeur spéciale appartenant à Object. Ainsi, en attribuant la variable à Null, nous créons un objet vide.

2. Type non défini

Undéfini est également un type de données spécial avec une seule valeur, ce qui signifie indéfini. Lorsque nous déclarons une variable mais n'attribuons pas de valeur à la variable, la valeur par défaut de la variable est Indéfinie. Par exemple :

var num;
console.log(num);  // 输出 undefined

Lorsque vous utilisez l'opérateur typeof pour afficher les types de variables non attribués, vous constaterez que leurs types ne sont pas non plus définis. Pour les variables non déclarées, utilisez l'opérateur typeof pour vérifier leurs types et vous constaterez que les variables non déclarées sont également indéfinies. L'exemple de code est le suivant :

var message;
console.log(typeof message);  // 输出 undefined
console.log(typeof str);     // 输出 undefined

Explication : Les similitudes et les différences entre null et non défini :

Sameness. : les deux sont identiques Le type de données de la valeur ; les deux renvoient false lorsqu'ils participent au jugement ; les deux n'ont pas de méthode

Différences :

(a), null est un objet, tandis que undefined n'est pas un objet ; ), null est un mot-clé, undefined n'est pas un mot-clé ;

(c), null vaut 0 lorsqu'il est converti en nombre, et undefined est NaN lorsqu'il est converti en nombre

(d), le type de null renvoie « objet » ; , typeof undefined renvoie 'undefined ';

alert(null == undefined) ;//true

Le type numérique (Number) est utilisé pour définir des valeurs numériques. JavaScript ne fait pas de distinction entre les entiers et les décimales (nombres à virgule flottante) et est représenté par. le type Number uniformément, comme le montre l'exemple suivant :

var num1 = 123;     // 整数
var num2 = 3.14;    // 浮点数

Remarque : Les valeurs qui peuvent être définies par le type Number ne sont pas illimitées. Le type Number en JavaScript ne peut représenter que des valeurs comprises entre -(253 - 1. ) et (253 -1).

Pour certains nombres très grands ou très petits, ils peuvent également être représentés par une notation scientifique (exponentielle), comme le montre l'exemple suivant :

var y=123e5;      // 123 乘以 10 的 5 次方，即 12300000
var z=123e-5;     // 123 乘以 10 的 -5 次方，即 0.00123

De plus, il existe des valeurs spéciales dans le type Nombre, à savoir Infini , - Infini et NaN, où

Infini : utilisé pour représenter une valeur d'infini positif, fait généralement référence à un nombre supérieur à 1.7976931348623157e+308 ;
-Infini : utilisé pour représenter une valeur d'infini négatif, fait généralement référence à un nombre inférieur à 5e-324 Nombre ;
NaN : Pas une valeur numérique (abréviation de Not a Number), utilisée pour représenter des structures d'opérations mathématiques invalides ou non définies, telles que 0 divisé par 0.
Conseils : Si le résultat d'un certain calcul dépasse la plage de valeurs du type Nombre en JavaScript, le nombre sera automatiquement converti à l'infini, les nombres positifs étant l'infini et les nombres négatifs étant -l'infini.

alert（NaN == NaN） // false;Mais NaN est un type de données, ce qui signifie que la valeur de retour du type de NaN est « numéro » ;

Pour les deux fonctionnalités ci-dessus, ECMAScript fournit une fonction isNaN(); peut être converti est un nombre et la valeur de retour est une valeur booléenne.

La chaîne vide convertie en nombre est 0 ;

Pour convertir une valeur en type numérique, vous pouvez utiliser Number();

Lors de la définition d'une chaîne, si la chaîne contient des guillemets, vous pouvez utiliser des barres obliques inverses pour échapper les guillemets dans la chaîne, ou choisir des guillemets différents pour définir la chaîne, comme indiqué dans l'exemple suivant :

var str = "Let's have a cup of coffee.";  // 双引号中包含单引号
var str = 'He said "Hello" and left.';    // 单引号中包含双引号
var str = 'We\'ll never give up.';        // 使用反斜杠转义字符串中的单引号

Type booléen

var a = true;   // 定义一个布尔值 true
var b = false;  // 定义一个布尔值 false
var c = 2 > 1;  // 表达式 2 > 1 成立，其结果为“真（true）”，所以 c 的值为布尔类型的 true
var d = 2 < 1;  // 表达式 2 < 1 不成立，其结果为“假（false）”，所以 c 的值为布尔类型的 false

Normalement, seules ces six situations deviendront fausses : chaîne vide, null, non défini, 0, -0 ; , NaN

Comment convertir un tableau en valeur booléenne peut utiliser deux méthodes : Boolean(), !!()

6 Type de symbole

.

var str = "123";
var sym1 = Symbol(str);
var sym2 = Symbol(str);
console.log(sym1);          // 输出 Symbol(123)
console.log(sym2);          // 输出 Symbol(123)
console.log(sym1 == sym2);  // 输出 false ：虽然 sym1 与 sym2 看起来是相同的，但实际上它们并不一样，根据 Symbol 类型的特点，sym1 和 sym2 都是独一无二的

【相关推荐：javascript视频教程、web前端】

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!