Types de données et variables

Type de données

Un ordinateur, comme son nom l'indique, est une machine capable d'effectuer des calculs mathématiques. Par conséquent, les programmes informatiques peuvent naturellement gérer diverses valeurs numériques. Cependant, les ordinateurs peuvent traiter bien plus que de simples valeurs numériques. Ils peuvent également traiter une variété de données telles que du texte, des graphiques, de l'audio, de la vidéo, des pages Web, etc. Différentes données nécessitent la définition de différents types de données. Les types de données suivants sont définis en JavaScript :

Nombre

JavaScript ne fait pas de distinction entre les nombres entiers et les nombres à virgule flottante et est uniformément représenté par Nombre. Les types de données suivants sont légaux. Types de nombres ：

123; // Entier 1230.456; // Nombre à virgule flottante 0.4561.2345e3; // La notation scientifique représente 1.2345x1000, ce qui équivaut à 1234.5-99; ne représente pas un nombre, lorsque le résultat ne peut pas être calculé, utilisez NaN pour représenter l'infini ; // L'infini représente l'infini lorsque la valeur dépasse la valeur maximale que le nombre JavaScript peut représenter, elle est représentée par Infinity

<🎜. > Étant donné que les ordinateurs utilisent le binaire, il est donc parfois plus pratique d'utiliser l'hexadécimal pour représenter les entiers. L'hexadécimal est représenté par le préfixe 0x et 0-9, a-f, par exemple : 0xff00, 0xa5b4c3d2, etc. valeurs représentées par 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.52 / 0; // Infinity0 / 0; // NaN10 % 3; // 110.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", etc. Veuillez noter , ' ' ou "" lui-même n'est qu'une représentation, 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<. 🎜>La représentation des valeurs booléennes et de l'algèbre booléenne est exactement la même. Une valeur booléenne n'a que deux valeurs : vrai et faux, soit vrai ou faux. Vous pouvez directement utiliser vrai ou faux pour représenter une valeur booléenne, ou vous pouvez utiliser Boolean L'opération est calculée :

true; // Ceci est une valeur vraie false; // Ceci est une valeur fausse 2 > 3; // Ceci est une valeur fausse

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

true && true; / Le résultat de cette instruction && est truetrue && false; // Cette instruction && est évaluée comme false false && true && false; // Cette instruction && est évaluée comme false

|| opération, tant que l'un d'eux est vrai, |Le résultat de l'opération est vrai :

false || instruction est évaluée à truefalse || true || false; // Cette instruction || est évaluée à true

! L'opération est une non-opération. C'est un opérateur unaire qui transforme vrai en faux et faux en vrai :

 ! true! (2 > 5); // Le résultat est vrai

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 l'on compare des nombres, nous pouvons obtenir une valeur booléenne grâce à l'opérateur de comparaison :

2 > 5; // false5 >= 2; // true7 == 7; // true

En fait, JavaScript permet de comparer n'importe quel type de données :

false == 0; // truefalse === 0; // false

Soyez spécial Notez l'opérateur d'égalité ==. Lorsque JavaScript a été conçu, il y avait deux opérateurs de comparaison :

Le premier est la comparaison ==, qui convertira automatiquement le type de données avant de comparer. Dans de nombreux cas, des résultats très étranges seront obtenus

< ; 🎜 >Le deuxième type est la comparaison ===, qui ne convertit pas automatiquement les types de données si les types de données sont incohérents, false est renvoyé. S'ils sont cohérents, comparez à nouveau.

En raison de ce défaut de conception dans JavaScript, n'utilisez pas de comparaisons == et tenez-vous-en toujours aux comparaisons ===.

Une autre exception est NaN. Ce nombre spécial n'est pas égal à toutes les autres valeurs, y compris lui-même :

NaN === NaN; // false

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

isNaN(NaN); // true

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

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

Ce n'est pas un défaut de conception en JavaScript. Les nombres à virgule flottante produisent des erreurs lors des opérations car les ordinateurs ne peuvent pas représenter avec précision des décimales infiniment récurrentes. Pour comparer si deux nombres à virgule flottante sont égaux, vous pouvez uniquement calculer la valeur absolue de leur différence pour voir si elle est inférieure à un certain seuil :

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

null et undefined

null représentent une valeur "vide", différente de 0 et du vide string'', 0 est une 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 veulent 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 :

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

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() :

new Array(1, 2, 3); // Tableau créé [1, 2, 3]

Cependant, par souci de lisibilité du code, il est fortement recommandé d'utiliser directement [] .

Les éléments d'un tableau sont accessibles par index. Veuillez noter que la valeur de départ de l'index est 0 :

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

Object

L'objet JavaScript est une collection non ordonnée de valeurs-clés, par exemple :

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

Les clés des objets JavaScript sont toutes de type chaîne et les valeurs peuvent être de n'importe quel type de données. L'objet personne ci-dessus définit un total de 6 paires clé-valeur, chacune étant également appelée attribut de l'objet. Par exemple, l'attribut nom de la personne est « Bob » et l'attribut code postal est nul.

Pour obtenir les attributs d'un objet, nous utilisons la variable objet. Nom de l'attribut :

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

Variables

Le concept de variables est fondamentalement le même que celui des variables d'équation en algèbre du premier cycle du secondaire, sauf que dans les programmes informatiques, les variables peuvent non seulement être des nombres, mais aussi peut être n'importe quel type de données.

Les variables sont représentées par un nom de variable en JavaScript. Le nom de la variable est une combinaison d'anglais majuscules et minuscules, de chiffres, $ et _, et ne peut pas commencer par un nombre. Les noms de variables ne peuvent pas être des mots-clés JavaScript, tels que if, while, etc. Pour déclarer une variable, utilisez l'instruction var, par exemple :

var a; // La variable a est déclarée et la valeur de a est indéfinievar $b = 1; // La variable $b est déclarée. et une valeur est assignée à $b , à ce moment la valeur de $b est 1var s_007 = '007'; // s_007 est une chaîne var Answer = true; // La réponse est une valeur booléenne truevar t = null; La valeur de t est nulle

Les noms de variables peuvent également être en chinois, mais ne vous causez pas de problèmes.

En JavaScript, utilisez le signe égal = pour attribuer une valeur à une variable. N'importe quel type de données peut être attribué à une variable. La même variable peut être affectée à plusieurs reprises, et il peut s'agir d'une variable de types différents. Cependant, il convient de noter qu'elle ne peut être déclarée qu'une seule fois avec var, par exemple :

.

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

Le type de cette variable elle-même n'est pas fixe. Le langage est appelé langage dynamique, et son homologue est un langage statique. Dans les langages statiques, le type de variable doit être spécifié lors de la définition d'une variable. Si le type ne correspond pas lors de l'attribution d'une valeur, une erreur sera signalée. Par exemple, Java est un langage statique, et l'instruction d'affectation est la suivante :

int a = 123 ; // a est une variable de type entier, et le type est déclaré avec int a = "ABC" ; // Erreur : Impossible d'attribuer une chaîne à un entier Type de variables

Par rapport aux langages statiques, les langages dynamiques sont plus flexibles pour cette raison.

Veuillez ne pas assimiler le signe égal de l'énoncé d'affectation au signe égal mathématique. Par exemple, le code suivant :

var x = 10;
x = x + 2;

Si vous comprenez mathématiquement x = x + 2, ce n'est pas vrai de toute façon. Dans le programme, l'instruction d'affectation calcule d'abord l'expression x + 2 sur le côté droit et obtient. le résultat 12. Ensuite, affectez-le à la variable x. Puisque la valeur précédente de x était 10, après réaffectation, la valeur de x devient 12.

mode strict

Au début de la conception JavaScript, afin de faciliter l'apprentissage des débutants, il n'était pas obligatoire d'utiliser var pour déclarer des variables. Cette erreur de conception a de lourdes conséquences : si une variable est utilisée sans déclaration var, alors la variable est automatiquement déclarée comme variable globale :

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

Dans différents fichiers JavaScript d'une même page, si aucune déclaration var n'est utilisée et les deux variables que j'utilise, les variables i s'influenceront mutuellement et produiront des résultats erronés difficiles à déboguer.

Une variable déclarée à l'aide de var n'est pas une variable globale. Sa portée est limitée au corps de la fonction dans laquelle la variable est déclarée (le concept de fonction sera expliqué plus loin. Les variables portant le même nom n'entrent pas en conflit). les uns avec les autres dans différents organes fonctionnels.

Afin de corriger ce grave défaut de conception de JavaScript, ECMA a introduit le mode strict dans les spécifications ultérieures. Le code JavaScript exécuté en mode strict est obligé de déclarer des variables via var. Si la variable est utilisée sans utiliser var, cela provoquera des erreurs d'exécution. .

La façon d'activer le mode strict est d'écrire dans la première ligne du code JavaScript :

'use strict';

Ceci est une chaîne, non prise en charge Les navigateurs en mode strict l'exécuteront sous forme d'instruction de chaîne, et les navigateurs prenant en charge le mode strict permettront au mode strict d'exécuter JavaScript.

Pour tester si votre navigateur peut supporter le mode strict :

'use strict';
// Si le navigateur supporte le mode strict,
// Le code suivant ReferenceError sera rapporté :

abc = 'Hello, world';
alert(abc);

rrree