Que sont les types de données et les variables JavaScript ? Comment convertir entre eux ?

Type de données

définit les types de données suivants en JavaScript :

Nombre

JavaScript ne fait pas de distinction entre les nombres entiers et les nombres à virgule flottante et est représenté par Nombre. Les types de nombres suivants sont légaux :

123; // 整数123
0.456; // 浮点数0.456
1.2345e3; // 科学计数法表示1.2345x1000，等同于1234.5
-99; // 负数
NaN; // NaN表示Not a Number，当无法计算结果时用NaN表示

Infini ; // Infini signifie infini. Lorsque la valeur dépasse la valeur maximale pouvant être représentée par le nombre JavaScript, elle est exprimée comme Infini
Puisque les ordinateurs utilisent le binaire, il est parfois plus pratique d'utiliser l'hexadécimal pour représenter les entiers. représenté par le préfixe 0x et 0-9, a-f, par exemple : 0xff00, 0xa5b4c3d2, etc. Ce sont exactement les mêmes que les valeurs exprimées en décimal.
Le nombre peut effectuer directement quatre opérations arithmétiques. Les règles sont cohérentes avec les mathématiques :

1 + 2; // 3
(1 + 2) * 5 / 2; // 7.5
2 / 0; // Infinity
0 / 0; // NaN
10 % 3; // 1
10.5 % 3; // 1.5

Notez que % est l'opération de reste.

Chaîne

Une chaîne est tout texte entouré de guillemets simples 'ou de guillemets doubles", tel que 'abc', "xyz "Et ainsi de suite. Veuillez noter que '' ou "" lui-même n'est qu'un moyen d'expression et ne fait pas partie de la chaîne. Par conséquent, la chaîne 'abc' n'a que 3 caractères a, b, c

Valeur booléenne

L'expression de la valeur booléenne est exactement la même que celle de l'algèbre booléenne. Une valeur booléenne n'a que deux valeurs : vraie et fausse, soit vraie soit fausse. true ou false directement. false représente une valeur booléenne, qui peut également être calculée via des opérations booléennes :

true; // 这是一个true值
false; // 这是一个false值
2 > 1; // 这是一个true值
2 >= 3; // 这是一个false值

&& est une opération ET seulement si. tout est vrai, le résultat de l'opération && est vrai :

true && true; // 这个&&语句计算结果为true
true && false; // 这个&&语句计算结果为false
false && true && false; // 这个&&语句计算结果为false

|| L'opération est une opération OU, tant que l'une d'elles est vraie , le résultat de l'opération || est vrai :

false || false; // 这个||语句计算结果为false
true || false; // 这个||语句计算结果为true
false || true || false; // 这个||语句计算结果为true

 ! faux et faux en vrai :

! true; // 结果为false
! false; // 结果为true
! (2 > 5); // 结果为true

Les valeurs booléennes sont souvent utilisées dans les jugements conditionnels, tels que :

var age = 15;
if (age >= 18) {
 alert('adult');
} else {
 alert('teenager');
}

Opérateur de comparaison

Lorsque nous comparons Nombre, nous pouvons obtenir une valeur booléenne grâce à l'opérateur de comparaison :

2 > 5; // false
5 >= 2; // true
7 == 7; // true

En fait, JavaScript permet de comparer tout type de données :

false == 0; // true
false === 0; // false

Payer spécial attention à l'opérateur d'égalité == lors de la conception des opérateurs de comparaison :

Le premier est la comparaison ==, qui convertira automatiquement le type de données avant de comparer. Plusieurs fois, vous obtiendrez des résultats très étranges. ;

Le deuxième est === À titre de comparaison, il ne convertira pas automatiquement le type de données. Si les types de données sont incohérents, il renverra false. S'ils sont cohérents, comparez à nouveau. faille dans JavaScript, n'utilisez pas == comparaison. Utilisez toujours === comparaison. Une autre exception est NaN, un nombre spécial qui n'est pas égal à toutes les autres valeurs, y compris lui-même :



.

La seule façon de déterminer NaN est d'utiliser la fonction isNaN() :

NaN === NaN; // false

Enfin, faites attention aux comparaison d'égalité des nombres à virgule flottante :

isNaN(NaN); // true

Ce n'est pas un défaut de conception dans JavaScript. Les nombres à virgule flottante produiront des erreurs lors des opérations, car les ordinateurs ne peuvent pas être précis. représentent des décimales en boucle infinie. Pour comparer si deux nombres à virgule flottante sont égaux, ils ne peuvent calculer que la valeur absolue de leur différence, pour voir si elle est inférieure à un certain seuil :

1 / 3 === (1 - 2 / 3); // false

.

Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // true

null et indéfini

null représente un La valeur de "vide" est différente de 0 et la chaîne vide '' 0 est un. valeur numérique, '' représente une chaîne de longueur 0 et null représente "vide".
Dans d'autres langages, il existe également des représentations de null similaires à JavaScript. Par exemple, Java utilise également null, Swift utilise nil et Python utilise None. Cependant, en JavaScript, il existe également undefined, qui est similaire à null, qui signifie « indéfini ». Les concepteurs de JavaScript espèrent utiliser null pour représenter une valeur vide, et undefined pour représenter une valeur indéfinie. Les faits ont prouvé que cela ne sert à rien et la différence entre les deux n’a que peu d’importance. Dans la plupart des cas, nous devrions utiliser null. undefined n'est utile que pour déterminer si les paramètres de fonction sont transmis. Tableau
Un tableau est une collection organisée dans l'ordre, et chaque valeur de la collection est appelée un élément. Les tableaux JavaScript peuvent contenir n'importe quel type de données. Par exemple :

Le tableau ci-dessus contient 6 éléments. Les tableaux sont représentés par [] et les éléments sont séparés par ,.

Une autre façon de créer un tableau consiste à utiliser la fonction Array() :

[1, 2, 3.14, 'Hello', null, true];

Cependant, pour des raisons de lisibilité du code, il est fortement recommandé d'utiliser [] directement.

Les éléments d'un tableau sont accessibles par index. Notez que les index commencent à 0 :

new Array(1, 2, 3); // 创建了数组[1, 2, 3]

Object

var arr = [1, 2, 3.14, 'Hello', null, true];
arr[0]; // 返回索引为0的元素，即1
arr[5]; // 返回索引为5的元素，即true
arr[6]; // 索引超出了范围，返回undefined

JavaScript Un objet est un objet non ordonné ensemble de clés et de valeurs, par exemple :

var person = {
 name: 'Bob',
 age: 20,
 tags: ['js', 'web', 'mobile'],
 city: 'Beijing',
 hasCar: true,
 zipcode: null
};

JavaScript对象的键都是字符串类型，值可以是任意数据类型。上述person对象一共定义了6个键值对，其中每个键又称为对象的属性，例如，person的name属性为'Bob'，zipcode属性为null。
要获取一个对象的属性，我们用对象变量.属性名的方式：

person.name; // 'Bob'
person.zipcode; // null

变量

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。
变量在JavaScript中就是用一个变量名表示，变量名是大小写英文、数字、$和_的组合，且不能用数字开头。变量名也不能是JavaScript的关键字，如if、while等。申明一个变量用var语句，比如：

var a; // 申明了变量a，此时a的值为undefined
var $b = 1; // 申明了变量$b，同时给$b赋值，此时$b的值为1
var s_007 = '007'; // s_007是一个字符串
var Answer = true; // Answer是一个布尔值true
var t = null; // t的值是null

变量名也可以用中文，但是，请不要给自己找麻烦。
在JavaScript中，使用等号=对变量进行赋值。可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，但是要注意只能用var申明一次，例如：

var a = 123; // a的值是整数123
a = 'ABC'; // a变为字符串

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下：

int a = 123; // a是整数类型变量，类型用int申明
a = "ABC"; // 错误：不能把字符串赋给整型变量

和静态语言相比，动态语言更灵活，就是这个原因。
请不要把赋值语句的等号等同于数学的等号。比如下面的代码：

var x = 10;
x = x + 2;

如果从数学上理解x = x + 2那无论如何是不成立的，在程序中，赋值语句先计算右侧的表达式x + 2，得到结果12，再赋给变量x。由于x之前的值是10，重新赋值后，x的值变成12。

strict模式

JavaScript在设计之初，为了方便初学者学习，并不强制要求用var申明变量。这个设计错误带来了严重的后果：如果一个变量没有通过var申明就被使用，那么该变量就自动被申明为全局变量：

i = 10; // i现在是全局变量

在同一个页面的不同的JavaScript文件中，如果都不用var申明，恰好都使用了变量i，将造成变量i互相影响，产生难以调试的错误结果。

使用var申明的变量则不是全局变量，它的范围被限制在该变量被申明的函数体内（函数的概念将稍后讲解），同名变量在不同的函数体内互不冲突。

为了修补JavaScript这一严重设计缺陷，ECMA在后续规范中推出了strict模式，在strict模式下运行的JavaScript代码，强制通过var申明变量，未使用var申明变量就使用的，将导致运行错误。

启用strict模式的方法是在JavaScript代码的第一行写上：

'use strict';

这是一个字符串，不支持strict模式的浏览器会把它当做一个字符串语句执行，支持strict模式的浏览器将开启strict模式运行JavaScript。

来测试一下你窗体顶端

'use strict';
// 如果浏览器支持strict模式，
// 下面的代码将报ReferenceError错误:

数据类型如何转换：

1. Convertir en nombre xxx*1.0
Convertir en chaîne xxx+""
2. Extrayez un autre type de valeur d'une valeur et terminez la conversion.
. Extrayez l'entier de la chaîne : parseInt();
Exemple : le résultat de parseInt("123zhang") est 123
. Extrayez le nombre à virgule flottante de la chaîne : parseFloat(); >Exemple : Le résultat de parseFloat("0.55zhang") est 0,55
Exécutez un morceau de code javascript représenté par une chaîne : eval();
Exemple : le résultat de zhang=eval("1+1). ") est zhang=2
. Convertir en chaîne : toString();
Exemple : le résultat de zhang=eval("1+1") est zhang=2
3. Convertissez la valeur entière de d'un type à un autre Trois types de données (appelés conversion de type de données de base),
Trois méthodes de conversion de type de données de base :
Convertir en type de caractère : String(); 678"
. Convertir en type numérique : Number(); Exemple : Le résultat de Number("678") est 678
. Convertir en type booléen : Boolean(); Exemple : Le résultat de Boolean("aaa ") est vrai

Lors de l'utilisation de ces méthodes, si nécessaire, essayez de juger et de gérer les exceptions dans l'exécution des paramètres et des méthodes.
Comme on le voit dans le document de référence, voici un résumé de l'efficacité d'exécution :
Sous IE, la première méthode est la plus rapide, la seconde est la deuxième et la troisième est la pire, mais la différence n'est que 100 000 fois, la différence n'est que de dizaines de centaines de millisecondes.
Sous FF, les premier et deuxième types sont fondamentalement équivalents, et le troisième type est le plus lent.
La différence de vitesse est fondamentalement négligeable. Parce que la différence est très petite.
Cependant, de par la simplicité du code, la première méthode est évidemment simple à écrire et facile à lire,
et il n'y aura aucun problème si la deuxième méthode signale une erreur car un objet n'a pas de méthode toString . En plus, il a toujours été le plus rapide.
Donc, j'ai l'habitude d'utiliser la première méthode pour terminer la conversion du type de données
Cependant, par exemple, si vous avez besoin de "123456abcd" pour extraire les nombres qu'il contient, alors vous devez naturellement utiliser des fonctions telles que parsetInt et parseFloat .
Mais veuillez noter que parfois le résultat de la conversion est NaN, etc., vous devez donc juger.

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!