JavaScript => Déclarations et assignations

Syntaxe

var foo [= valeur [, foo2 [, foo3 ... [, fooN]]]];
let bar [= valeur [, bar2 [, foo3 ... [, barN]]]];
const baz = valeur [, baz2 = valeur2 [, ... [, bazN = valeurN]]];

Remarques

Voir également:

Réaffectation des constantes

Vous ne pouvez pas réaffecter des constantes.

const foo = "bar";
foo = "hello";

Impressions:

Uncaught TypeError: Assignment to constant.

Modification des constantes

Déclarer une variable const empêche uniquement que sa valeur soit remplacée par une nouvelle valeur. const ne met aucune restriction sur l'état interne d'un objet. L'exemple suivant montre que la valeur d'une propriété d'un objet const peut être modifiée et que même de nouvelles propriétés peuvent être ajoutées, car l'objet affecté à la person est modifié, mais pas remplacé .

const person = { 
    name: "John" 
};
console.log('The name of the person is', person.name);

person.name = "Steve";
console.log('The name of the person is', person.name);

person.surname = "Fox";
console.log('The name of the person is', person.name, 'and the surname is', person.surname);

Résultat:

The name of the person is John
The name of the person is Steve
The name of the person is Steve and the surname is Fox

Dans cet exemple, nous avons créé un objet constant appelé person et nous avons réaffecté la propriété person.name et créé une nouvelle propriété person.surname .

Déclaration et initialisation des constantes

Vous pouvez initialiser une constante à l'aide du mot clé const .

const foo = 100;
const bar = false;
const person = { name: "John" };
const fun = function () = { /* ... */ };
const arrowFun = () => /* ... */ ;

Important
Vous devez déclarer et initialiser une constante dans la même instruction.

Déclaration

Il existe quatre méthodes principales pour déclarer une variable en JavaScript: en utilisant les mots-clés var , let ou const , ou sans aucun mot-clé (déclaration "bare"). La méthode utilisée détermine la portée résultante de la variable ou la réaffectabilité dans le cas de const .

Le mot clé var crée une variable de portée de fonction.
Le mot let clé let crée une variable block-scope.
Le mot-clé const crée une variable d'étendue de bloc qui ne peut pas être réaffectée.
Une déclaration nue crée une variable globale.

var a = 'foo';    // Function-scope
let b = 'foo';    // Block-scope
const c = 'foo';  // Block-scope & immutable reference

N'oubliez pas que vous ne pouvez pas déclarer de constantes sans les initialiser simultanément.

const foo; // "Uncaught SyntaxError: Missing initializer in const declaration"

(Un exemple de déclaration de variable sans mot-clé n'est pas inclus ci-dessus pour des raisons techniques. Continuez à lire pour voir un exemple.)

Types de données

Les variables JavaScript peuvent contenir de nombreux types de données: nombres, chaînes, tableaux, objets, etc.:

// Number
var length = 16;

// String
var message = "Hello, World!"; 

// Array
var carNames = ['Chevrolet', 'Nissan', 'BMW']; 

// Object
var person = {
    firstName: "John",
    lastName: "Doe"
};

JavaScript a des types dynamiques. Cela signifie que la même variable peut être utilisée comme différents types:

var a;              // a is undefined
var a = 5;          // a is a Number
var a = "John";     // a is a String

Indéfini

La variable déclarée sans valeur aura la valeur undefined

var a;

console.log(a); // logs: undefined

Essayer de récupérer la valeur de variables non déclarées donne lieu à une erreur ReferenceError. Cependant, le type des variables non déclarées et unitialisées est "non défini":

var a;
console.log(typeof a === "undefined"); // logs: true
console.log(typeof variableDoesNotExist === "undefined"); // logs: true

Affectation

Pour attribuer une valeur à une variable précédemment déclarée, utilisez l'opérateur d'affectation =

a = 6;
b = "Foo";

Comme alternative à la déclaration et à l'affectation indépendantes, il est possible d'effectuer les deux étapes dans une seule déclaration:

var a = 6;
let b = "Foo";

C'est dans cette syntaxe que les variables globales peuvent être déclarées sans mot-clé; si l'on déclarait une variable nue sans assignation immédiatement après, l'interprète ne serait pas en mesure de différencier les déclarations globales a; des références aux variables a; .

c = 5;
c = "Now the value is a String.";
myNewGlobal;    // ReferenceError

Notez cependant que la syntaxe ci-dessus est généralement déconseillée et n'est pas conforme au mode strict. Cela évite le scénario dans lequel un programmeur supprime par inadvertance un mot-clé let ou var de son instruction, créant accidentellement une variable dans l'espace de noms global sans s'en rendre compte. Cela peut polluer l'espace de noms global et le conflit avec les bibliothèques et le bon fonctionnement d'un script. Par conséquent, les variables globales doivent être déclarées et initialisées à l'aide du mot-clé var dans le contexte de l'objet window, afin que l'intention soit explicitée.

De plus, les variables peuvent être déclarées plusieurs à la fois en séparant chaque déclaration (et l’affectation de valeur facultative) par une virgule. En utilisant cette syntaxe, les mots-clés var et let ne doivent être utilisés qu'une seule fois au début de chaque instruction.

globalA = "1", globalB = "2";
let x, y = 5;
var person = 'John Doe',
    foo,
    age = 14,
    date = new Date();

Notez dans l'extrait de code précédent que l'ordre dans lequel les expressions de déclaration et d'affectation apparaissent ( var a, b, c = 2, d; ) n'a pas d'importance. Vous pouvez librement mélanger les deux.

La déclaration de fonction crée également des variables.