Explication détaillée des types de données JavaScript et de leur conversion

Le contenu de cet article est une explication détaillée des types de données JavaScript et de leur conversion. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Introduction

Chaque valeur du langage JavaScript appartient à un certain type de données. Il existe sept types de données en JavaScript :

1. Nombre (nombre) : entiers et décimaux (tels que 1 et 3,14).

2. Chaîne : texte (comme Hello World).

3. Booléen : Deux valeurs spéciales qui représentent l'authenticité, à savoir vrai (vrai) et faux (faux).

4. indéfini : signifie "indéfini" ou n'existe pas.

5. null : Indique une valeur nulle, c'est-à-dire que la valeur ici est vide.

6. Objet : Une collection de diverses valeurs.

7. Symbole

Parmi eux, Symbol est un nouveau type de données de base dans ES6. Cet article ne présente que les six premiers types.

2. Explication détaillée des types de données

1. Valeur numérique (nombre) :

1.1 Entiers et nombres à virgule flottante

Dans JavaScript, tous les nombres sont stockés sous forme de nombres à virgule flottante de 64 bits, même des nombres entiers.

1 === 1.0 // true

1.2 Précision

Dans la norme internationale IEEE 754, les 64 chiffres binaires des nombres à virgule flottante JavaScript, en commençant par l'extrême gauche, le premier bit de signe détermine la valeur positive d'un nombre Négatif (0 est un nombre positif, 1 est un nombre négatif), la partie exposant de 2 à 12 chiffres détermine la taille de la valeur et la partie décimale de 13 à 64 détermine la précision de la valeur.
1.3 La base des valeurs numériques

JavaScript fournit quatre méthodes de représentation de base pour les entiers : décimal, hexadécimal, octal et binaire.

• Décimale : valeur numérique sans début de 0.

• Octal : Une valeur avec le préfixe 0o ou 0O.

• Hexadécimal : une valeur avec un préfixe de 0x ou 0X.

• Binaire : Une valeur avec le préfixe 0b ou 0B.

1.4 NaN

NaN signifie Pas un nombre, ce qui se produit principalement lorsqu'il y a une erreur lors de l'analyse d'une chaîne en nombre, telle que :

618 - 'x' // NaN

NaN不等于任何值，包括它本身。：

NaN === NaN // false

2. Chaîne :

est citée par '' ou "". Si elle ne contient aucun contenu, c'est une chaîne vide d'une longueur de 0. . Celle qui contient des espaces est appelée chaîne d'espace, d'une longueur de 1, et les deux sont différentes.

2.1 Chaîne multiligne

Si la chaîne est divisée en plusieurs lignes, vous pouvez utiliser une barre oblique inverse à la fin de chaque ligne, sinon une erreur sera signalée. En plus d'utiliser des barres obliques inverses, vous pouvez également utiliser l'opérateur de concaténation (+) pour concaténer plusieurs chaînes d'une seule ligne. Les résultats des deux méthodes sont cohérents. Il est recommandé d'utiliser l'opérateur de concaténation (+).

var longString = 'Long \
long \
long \
string';

longString
// "Long long long string"

var longString = 'Long '
  + 'long '
  + 'long '
  + 'string';

longString
// "Long long long string"

ES6 ajoute des backticks (`) pour écrire des chaînes multilignes, et la longueur de cette chaîne multiligne inclura la longueur du retour chariot.

2.2 Échapper

Backslash () a une signification particulière dans la chaîne et est utilisé pour représenter certains caractères spéciaux, il est donc également appelé caractère d'échappement. Les caractères spéciaux qui doivent souvent être échappés avec des barres obliques inverses sont :

• 0 : null (u0000)

• n : caractère de nouvelle ligne (u000A)

• r : Touche Entrée (u000D)

• t : Caractère de tabulation (u0009)

• ' : guillemet simple (u0027)

•  : guillemet double (u0022)

   : barre oblique inverse (u005C)

longueur 2,3 attribut

L'attribut length renvoie la longueur de la chaîne. Cet attribut est déterminé par la chaîne elle-même et ne peut pas être modifié par affectation

var s = 'mamamoo';
s.length // 7
s.length = 5;
s.length // 7

3. ):

La valeur booléenne n'a que deux valeurs : "true" et "false". "True" est représenté par le mot-clé true, et "false" est représenté par le mot-clé false. si JavaScript. On s'attend à ce qu'une certaine position soit une valeur booléenne, et la valeur existante à cette position sera automatiquement convertie en une valeur booléenne. Les règles de conversion sont au nombre de six sauf non défini, nul, faux, 0, NaN, "" ou '' (chaîne vide). La valeur est convertie en faux et les autres valeurs sont considérées comme vraies 4. indéfini et nul :

Nul et indéfini peuvent signifier "aucun". ". Les significations sont très similaires. La différence entre les deux est :

null est un objet qui représente "vide" et vaut 0 lorsqu'il est converti en valeur numérique ; undefined est un objet cela représente "pas de définition ici" La valeur d'origine est NaN lorsqu'elle est convertie en valeur numérique

• Si la variable n'a pas de valeur, elle renvoie undefined Il est recommandé d'utiliser null lors de l'attribution. une valeur ; il est recommandé d'utiliser undefined lorsqu'il y a un non-objet mais que vous ne souhaitez pas encore attribuer de valeur >
5.1 Méthode de génération

• Un objet est simplement un ensemble de "clés-". paires de valeurs", qui est une collection de données composites non ordonnées. La méthode de génération

  est utilisée. Les accolades enveloppent la paire clé-valeur et l'attribuent à la variable. La paire clé-valeur est séparée par une virgule avant ":" et la valeur de la clé après ":" : > 5.2 Nom de la clé et valeur de la clé
.

对象的所有键名都是字符串，要加引号，不加也会自动转为字符串。如果键名不符合标识名的条件（比如第一个字符为数字，或者含有空格或运算符），且也不是数字，则必须加上引号，否则会报错。而键值是什么类型就用该类型的格式。

5.3 属性

对象的每一个键名又称为“属性”（property），它的“键值”可以是任何数据类型。

属性的读取

读取对象的属性，有两种方法，一种是使用点运算符，还有一种是使用方括号运算符。

var obj = {
  p: 'Hello World'
};

obj.p // "Hello World"
obj['p'] // "Hello World",[]内''一定要加

属性的删除delete(无value无key)

var obj = { p: 1 };
Object.keys(obj) // ["p"]

delete obj.p // true
obj.p // undefined
Object.keys(obj) // []

属性的查看Object.keys

var obj = {
  key1: 1,
  key2: 2
};

Object.keys(obj);
// ['key1', 'key2']

属性是否存在：in

in运算符用于检查对象是否包含某个属性（注意，检查的是键名，不是键值），如果包含就返回true，否则返回false。

属性的遍历：for...in 循环

var obj = {a: 1, b: 2, c: 3};

for (var i in obj) {
  console.log('键名：', i);
  console.log('键值：', obj[i]);
}
// 键名： a
// 键值： 1
// 键名： b
// 键值： 2
// 键名： c
// 键值： 3

三、如何知道变量类型？

使用type of可得变量的数据类型，如：

var t = 619;
type of t;//"number"

特别注意的是：

• 当数据类型为null时，用type of打出的数据类型却是'object'。

• 当定义了一个函数时，用type of打出的数据类型却是'function'。

四、数据类型的转换

4.1 转为string

• 使用toString()

var t = 619;
t.toString();//"619"

null没有toString这个API，不能使用toString，会报错

var n = null;
n.toString;
//Uncaught TypeError: Cannot read property 'toString' of null

undefined也会报错

var n = undefined;
n.toString();
//Uncaught TypeError: Cannot read property 'toString' of undefined

object使用toString会得到"[object Object]"。

var object = {name:"po"};
object.toString()
//"[object Object]"

• 通过与空字符串相加(+"")也能转化为字符串类型，且null、undefined也适用。

• 使用window.String()

window.String(null)//"null"

为什么1 + '1' = '11'?
这是因为当两个不同数据类型相加时，会优先选择转化为字符串，所以1 + '1'相当于1.toString() + '1'，于是结果为两个字符串1相加，即字符串11。

4.2 转为布尔

使用Boolean()

Boolean(0)//false
Boolean('')//false
Boolean(' ')//true

使用!!

!! ''//false
!! ' '//true

五个falsy值：0、NaN、空字符串、null、undefined

4.3 转为Number

使用Number()

Number('1')//1

使用parseInt()

//第二位参数要写，是表示进制

使用parseFloat()

parseFloat('1.23')//1.23

使用 -0

'1'-0//1

使用 +

+ null//0

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!