web-dev-qa-db-fra.com

Le mot clé 'const' ne rend pas la valeur immuable. Qu'est-ce que ça veut dire?

Il y a la définition const dans Exploring ES6 du Dr. Axel Rauschmayer:

const fonctionne comme let, mais la variable que vous déclarez doit être immédiatement initialisé, avec une valeur impossible à modifier ensuite. […]

const bar = 123;
bar = 456;  // TypeError: `bar` is read-only

et puis il écrit

Pitfall: const ne rend pas la valeur immuable

const signifie seulement qu'une variable a toujours la même valeur, mais cela ne signifie pas que la valeur elle-même est ou devient immuable.

Je suis un peu confus avec ce piège. Quelqu'un peut-il clairement définir la const avec ce piège?

javascriptecmascript-6const
83
Mukund Kumar

MDN résume bien:

La déclaration const crée une référence en lecture seule à une valeur. Cela ne signifie pas que la valeur qu'il détient est immuable, mais simplement que l'identificateur de variable ne peut pas être réaffecté. Par exemple, si le contenu est un objet, cela signifie que l’objet lui-même peut toujours être modifié.

Plus succinctement: const crée une liaison immuable. 

En d'autres termes: const, comme var, vous donne un bloc de mémoire modifiable dans lequel vous stockez quelque chose. Cependant, const impose de continuer à faire référence à ce même bloc de mémoire - vous ne pouvez pas réaffecter la variable à un bloc de mémoire différent, car la référence à la variable est constante.

Pour que quelque chose soit vraiment constant et immuable après l'avoir déclaré, vous devez utiliser quelque chose comme Object.freeze(). Cependant, c'est peu profond et ne fonctionne que sur des paires clé/valeur. Geler un objet entier demande un peu plus d'effort. Le faire de manière répétée de manière performante est encore plus difficile. Si vous en avez vraiment besoin, je vous conseillerais de regarder quelque chose comme Immutable.js

95
Mike Post

Lorsque vous créez quelque chose const en JavaScript, vous ne pouvez pas réaffecter la variable elle-même pour référencer autre chose. Cependant, la variable peut toujours faire référence à un objet mutable.

const x = {a: 123};

// This is not allowed.  This would reassign `x` itself to refer to a
// different object.
x = {b: 456};

// This, however, is allowed.  This would mutate the object `x` refers to,
// but `x` itself hasn't been reassigned to refer to something else.
x.a = 456;

Dans le cas de primitives telles que des chaînes et des nombres, const est plus simple à comprendre, car vous ne modifiez pas les valeurs mais affectez une nouvelle valeur à la variable.

147
Candy Gumdrop

Reliure

Les déclarations const et let déterminent si les rapprochements (ou réaffectations) entre identificateurs et valeurs sont autorisés:

const x = "initial value";
let y = "initial value";

// rebinding/reassignment

try { x = "reassignment" } catch(e) { console.log(x) } // fails

y = "reassignment"; // succeeds
console.log(y);

Immutabilité

L’immuabilité est contrôlée au niveau du type. Object est un type mutable, alors que String est un type immuable:

const o = {mutable: true};
const x = "immutable";

// mutations

o.foo = true; // succeeds
x[0] = "I"; // fails

console.log(o); // {mutable: true, foo: true}
console.log(x); // immutable

14
user6445533

const signifie: vous ne pouvez pas modifier la valeur initialement attribuée.

Premièrement, définissez ce qu'est un valeur en js. La valeur peut être: booléens, chaînes, nombres, objets, fonctions et valeurs indéfinies.

J'aime: les gens vous appellent avec votre nom, ça ne change pas. Cependant, vous changez de vêtements. La liaison entre les personnes et vous est votre nom. Le reste peut changer. Désolé pour l'exemple étrange.

Alors, laissez-moi vous donner quelques exemples:

// boolean
const isItOn = true;
isItOn = false;           // error

// number
const counter = 0;
counter++;                // error

// string
const name = 'edison';
name = 'tesla';           // error

// objects
const fullname = {
  name: 'albert',
  lastname: 'einstein'
};

fullname = {              // error
  name: 'werner',
  lastname: 'heisenberg'
};

// NOW LOOK AT THIS:
//
// works because, you didn't change the "value" of fullname
// you changed the value inside of it!
fullname.name = 'hermann';

const increase = aNumber => ++aNumber;
increase = aNumber => aNumber + 1;      // error

// NOW LOOK AT THIS:
//
// no error because now you're not changing the value
// which is the decrease function itself. function is a
// value too.
let anotherNumber = 3;
const decrease = () => --anotherNumber;

anotherNumber = 10;             // no error
decrease();                     // outputs 9

const chaos = undefined;
chaos = 'let there be light'    // error

const weird = NaN;
weird = 0                       // error

Comme vous pouvez le constater, sauf si vous ne modifiez pas la valeur attribuée à "premier" par un const, aucune erreur. Chaque fois que vous essayez de remplacer la première valeur attribuée par un autre paramètre, vous vous fâchez et cela donne une erreur.

C'est donc la deuxième chose que vous savez peut-être en utilisant const. Qui est, il devrait être initialisé à une valeur sur sa déclaration ou il sera fâché.

const Orphan;                    // error
const rich = 0;                  // no error
1
Inanc Gumus

ES6/ES2015const mot-clé:

Le mot clé const est utilisé pour déclarer une variable de périmètre de bloc (comme pour déclarer avec let). La différence entre déclarer une variable avec const et let est la suivante:

  1. Une variable déclarée const ne peut pas être réaffectée .
  2. Une variable déclarée avec const doit être assignée quand déclarée . Ceci est une conséquence logique du point précédent car une variable déclarée avec const ne peut pas être réaffectée, c'est pourquoi nous devons l'affecter exactement une fois lorsque nous déclarons la variable .

Exemple:

// we declare variable myVariable
let myVariable;

// first assignment
myVariable = 'First assingment';
// additional assignment
myVariable = 'Second assignment';

// we have to declare AND initialize the variable at the same time
const myConstant = 3.14;

// This will throw an error
myConstant = 12;

Dans l'exemple ci-dessus, nous pouvons observer ce qui suit:

  1. La variable myVariable déclarée avec let peut d'abord être déclarée puis assignée.
  2. La variable myConstant déclarée avec const doit être déclarée et affectée en même temps.
  3. Lorsque nous essayons de réaffecter la variable myConstant, nous obtenons l'erreur suivante:

Uncaught TypeError: Affectation à une variable constante

Avertissement: la variable affectée avec const est toujours modifiable:

Une variable déclarée avec const ne peut tout simplement pas être réaffectée, elle est toujours modifiable . Être modifiable signifie que la structure de données (objet, tableau, carte, etc.) affectée à la variable const peut toujours être modifiée (c'est-à-dire mutée). Des exemples de mutation sont:

  1. Ajouter/supprimer/modifier une propriété d'un objet
  2. Modification de la valeur d'un tableau à un index de tableau spécifique

Si vous voulez vraiment qu'un objet ne soit pas mutable, vous devrez utiliser quelque chose comme Object.freeze(). C'est une méthode qui gèle un objet. Un objet gelé ne peut plus être modifié et aucune nouvelle propriété ne peut être ajoutée.

Exemple:

const obj = {prop1: 1};

obj.prop1 = 2;
obj.prop2 = 2;

console.log(obj);

// We freeze the object here
Object.freeze(obj);

obj.prop1 = 5;
delete obj.prop2;

// The object was frozen and thus not mutated
console.log(obj);

0
Willem van der Veen