Quels sont les types de données couramment utilisés en JavaScript ?

Les types de données couramment utilisés en JavaScript sont : 1. le type nul, qui représente une valeur nulle et définit un pointeur d'objet nul ; 2. le type non défini, qui représente une valeur non définie ; 4. le type numérique ; type ; 5 , type booléen ; 6. type d'objet ;

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

Types de données couramment utilisés en JavaScript

数据类型	说明
null	空值，表示非对象
undefined	未定义的值，表示未赋值的初始化值
number	数字，数学运算的值
string	字符串，表示信息流
boolean	布尔值，逻辑运算的值
object	对象，表示复合结构的数据集
Array	数组，包含已编码的值的有序集合。

1 Null

Le type Null n'a qu'une seule valeur, qui est nul. Il représente une valeur nulle et définit un pointeur d'objet nul.

Utilisez l'opérateur typeof pour détecter les valeurs nulles et renvoyer un objet, indiquant qu'il appartient au type d'objet, mais JavaScript le classe comme un type de valeur spécial.

Définissez la valeur d'initialisation de la variable sur null et vous pouvez définir un objet vide de rechange, qui est une valeur d'objet spéciale ou un non-objet. Par exemple, si vous détectez qu'un objet est vide, vous pouvez l'initialiser.

if (men == null){
    men = {
        //初始化men
    }
}

2. Type non défini

undéfini est la seule valeur du type non défini, qui représente une valeur non définie. Lorsqu'une variable est déclarée sans valeur attribuée ou qu'une propriété est définie sans jeu de valeurs, la valeur par défaut n'est pas définie.

Exemple 1

undefined est dérivé de null et undefined représentent des valeurs vides lorsqu'elles sont converties en valeurs booléennes, ce sont toutes deux de fausses valeurs et peuvent être égales.

console.log(null == undefined);  //返回 true

null et undefined sont deux types différents et peuvent être détectés à l'aide de l'opérateur d'égalité (==) ou de l'opérateur typeof.

console.log(null === undefined);  //false
console.log(typeof null);  //返回"object"
console.log(typeof undefined);  //返回"undefined"

Exemple 2

Pour vérifier si une variable est initialisée, vous pouvez utiliser undefined pour la détecter rapidement.

var a; //声明变量
console.log(a);  //返回变量默认值为 undefined
(a == undefined) && (a = 0);  //检测变量是否初始化，否则为其赋值
console.log(a);  //返回初始值 0

Vous pouvez également utiliser l'opérateur typeof pour détecter si le type d'une variable n'est pas défini.

(typeof a == "undefined") && (a = 0);  //检测变量是否初始化，否则为其赋值

3. Type booléen

Le type booléen (Boolean) ne contient que deux valeurs fixes : vrai et faux. Parmi eux, vrai représente « vrai » et faux représente « faux ».

En JavaScript, les six valeurs spéciales indéfinies, null, "", 0, NaN et false sont fausses lorsqu'elles sont converties en valeurs booléennes, appelées fausses valeurs. Tout type de données autre que false est vrai lorsqu'il est converti en valeur booléenne.

Exemple

Utilisez la fonction Boolean() pour forcer une valeur à une valeur booléenne.

console.log(Boolean(0));  //返回 false
console.log(Boolean(NaN)); //返回 false
console.log(Boolean(null)); //返回 false
console.log(Boolean("")); //返回 false
console.log(Boolean(undefined)); //返回 false

4. Nombre :

Ce type de représentation a deux formes, la première est un nombre entier et la seconde est un nombre à virgule flottante. Entier : peut être représenté par des valeurs littérales décimales, octales et hexadécimales. Nombre à virgule flottante : la valeur doit contenir un point décimal et il doit y avoir un chiffre après le point décimal.

5. String :

Le type String est utilisé pour représenter une séquence de caractères composée de zéro ou plusieurs caractères Unicode de 16 bits, c'est-à-dire une chaîne. Quant à savoir s'il faut utiliser des guillemets simples ou doubles, il n'y a toujours pas de différence en js. Pensez à venir à deux.

6. Objet :

Le type de données Objet, appelé objet, est une collection de données et de fonctions (fonctions). Il peut être créé à l'aide de l'opérateur new suivi du nom du type d'objet à créer. Peut également être créé en utilisant la notation littérale. Ajoutez une propriété avec un nom différent (n'importe quelle chaîne, y compris la chaîne vide).

7. Tableau

Les tableaux JavaScript sont écrits entre crochets. Les éléments du tableau sont séparés par des virgules.

Le code suivant déclare (crée) un tableau nommé cars avec trois éléments (marques de voitures) :

var cars = ["Porsche", "Volvo", "BMW"];

L'index du tableau est de base zéro, ce qui signifie que le premier élément est [ 0], le deuxième élément est [1], et ainsi de suite.

Les tableaux dans ECMAScript sont assez différents des tableaux dans d'autres langages :

• Chaque élément d'un tableau ECMAScript peut enregistrer n'importe quel type de données ;

• La taille du tableau ECMAScript peut être ajustée dynamiquement et des éléments peuvent être ajoutés ou supprimés du tableau

[Recommandations associées : Tutoriel d'apprentissage Javascript 】

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!