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

Question

Il y a la const définition dans l'Exploration ES6 par le Dr Axel Rauschmayer:

const fonctionne comme laisser, mais la variable à déclarer doit être immédiatement initialisé avec une valeur qui ne peut pas être changé par la suite. [...]

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

et puis il écrit

Piège: const ne fait pas la valeur immuable

const seulement signifie 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. Peut-on définir clairement l' const avec ce piège?

Answer 1

Lorsque vous créez quelque chose avec 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, il est plus simple de comprendre const , car vous ne modifiez pas les valeurs mais vous affectez une nouvelle valeur à la variable.

Answer 2

MDN , il résume bien:

La déclaration const crée en lecture seule référence à une valeur. Cela ne signifie pas la valeur qu'il détient est immuable, c'est juste que l'identifiant de variable ne peut pas être modifiée. Par exemple, dans le cas où le contenu est un objet, cela signifie que l'objet lui-même peut encore être modifié.

De façon plus succincte: const crée un immuable de liaison.

En d'autres termes: const, comme le var, vous donne une mutable partie de la mémoire dans laquelle vous voulez enregistrer quelque chose. Cependant, const dicte ce que vous devez garder en se référant à la même partie de la mémoire, vous ne pouvez pas réaffecter la variable à une autre partie de la mémoire, parce que la variable de référence est constante.

Pour vraiment faire quelque chose de constant et immuable, après que vous avez déclaré, vous devez utiliser quelque chose comme Object.freeze(). Cependant, c'est peu profonde et ne fonctionne que sur des paires clé/valeur. La congélation de la totalité d'un objet prend un peu plus d'effort. De le faire à plusieurs reprises dans un performantes moyen est encore plus difficile. Si vous avez vraiment besoin pour cela, je vous recommande de vérifier quelque chose comme Immutable.js

Answer 3

const signifie: vous ne pouvez pas changer de initialement affecté de la valeur.

Tout d'abord, définissons ce qu'est une valeur en js. La valeur peut être: Booléens, chaînes de caractères, nombres, les objets, les fonctions et les valeurs indéfinies.

Aime: les Gens vous appellent avec votre nom, c'est de ne pas changer. Cependant, vous changez de vêtements. La liaison entre le peuple et vous est votre nom. Le reste peut changer. Désolé pour le bizarre exemple.

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 voir, à moins que vous ne modifiez pas la "première"de la valeur attribuée à un const, pas d'erreur. Chaque fois que vous essayez de modifier la première valeur affectée à autre chose, il se met en colère, et il donne une erreur.

Donc, c'est la deuxième chose que vous savez peut-être lors de l'utilisation d' const. Qui est, il doit être initialisé à une valeur sur sa déclaration ou elle sera en colère.

const orphan;                    // error
const rich = 0;                  // no error

Answer 4

ES6/ES2015 const mot-clé:

L' const mot-clé est utilisé pour déclarer un bloc d'étendue variable (comme la déclaration de avec let). La différence entre la déclaration d'une variable avec const et let est le suivant:

1. Une variable déclarée à l' const ne peut pas être réaffectés.
2. Une variable déclarée avec const doit être attribué lors de l' déclaré. C'est une conséquence logique du point précédent, car une variable déclarée avec const ne peut pas être modifiée, c'est pourquoi nous devons l'attribuer qu'une seule fois lors de la déclaration de 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é et alors attribué.
2. La variable myConstant déclarée avec const doit être déclaré et affectés en même temps.
3. Quand nous essayons de les réaffecter la variable myConstant nous obtenons le message d'erreur suivant:

Uncaught TypeError: Affectation à une constante variable

Mise en garde: La variable est assignée const est encore mutable:

Une variable déclarée avec const juste ne peut pas être réaffecté, il est encore mutable. Étant mutable signifie que la structure de données (objet, tableau, carte, etc) qui a été attribué à l' const toujours variable peut être modifiée (c'est à dire muté). Exemples de mutation sont:

1. Ajout/suppression/modification d'une propriété d'un objet
2. La modification de la valeur d'un tableau à un indice de tableau

Si voulez vraiment un objet non mutable, vous devrez utiliser quelque chose comme Object.freeze(). C'est une méthode qui gèle un objet. Une gelée objet ne peut plus être changé et pas de nouvelles propriétés peuvent être ajoutées.

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);