javascript - sirve - let en jquery

La palabra clave ''const'' no hace que el valor sea inmutable. Qué significa eso?

Question

Existe la definición constante en Exploring ES6 del Dr. Axel Rauschmayer:

const funciona como let, pero la variable que declares debe inicializarse inmediatamente, con un valor que no se puede cambiar después . [...]

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

y luego escribe

Peligro: const no hace que el valor sea inmutable

const solo significa que una variable siempre tiene el mismo valor, pero no significa que el valor en sí sea o se vuelva inmutable.

Estoy un poco confundido con esta trampa. ¿Alguien puede definir claramente la const con esta trampa?

Answer 1

const significa: no puede cambiar el valor asignado inicialmente.

Primero, defina qué es un valor en js. El valor puede ser: booleanos, cadenas, números, objetos, funciones y valores indefinidos.

Me gusta: la gente te llama con tu nombre, no está cambiando. Sin embargo, te cambias de ropa. El vínculo entre las personas y usted es su nombre. El resto puede cambiar. Perdón por el extraño ejemplo.

Entonces, déjame darte algunos ejemplos:

// 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

Como puede ver, a menos que no esté cambiando el "primer" valor asignado a una constante, no hay error. Cada vez que intenta cambiar el primer valor asignado a otra cosa, se enoja y da un error.

Entonces, esto es lo segundo que puede saber al usar const . Es decir, debe inicializarse a un valor en su declaración o se enojará.

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

Answer 2

Rebobinado

const declaraciones const y let controlan si se let los cambios (también conocidos como reasignaciones) entre identificadores y valores:

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

Inmutabilidad

La inmutabilidad se controla a nivel de tipo. Object es un tipo mutable, mientras que String es un tipo inmutable:

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

Answer 3

ES2015 clave const ES6 / ES2015 :

La palabra clave const se usa para declarar una variable de ámbito de bloque (como declarar con let ). La diferencia entre declarar una variable con const y let es la siguiente:

1. Una variable declarada const no se puede reasignar .
2. Una variable declarada con const debe asignarse cuando se declara . Esta es una consecuencia lógica del punto anterior porque una variable declarada con const no se puede reasignar, es por eso que tenemos que asignarla exactamente una vez cuando declaramos la variable .

Ejemplo:

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

En el ejemplo anterior podemos observar lo siguiente:

1. La variable myVariable declarada con let puede declararse primero y luego asignarse.
2. La variable myConstant declarada con const debe declararse y asignarse al mismo tiempo.
3. Cuando intentamos reasignar la variable myConstant obtenemos el siguiente error:

TypeError no capturado: asignación a variable constante

Advertencia: la variable asignada con const todavía es mutable:

Una variable declarada con const simplemente no se puede reasignar, todavía es mutable . Ser mutable significa que la estructura de datos (objeto, matriz, mapa, etc.) que se asignó a la variable const todavía se puede alterar (es decir, mutar). Ejemplos de mutación son:

1. Agregar / eliminar / alterar una propiedad de un objeto
2. Cambiar el valor de una matriz en un índice de matriz específico

Si realmente quiere que un objeto no sea mutable, deberá usar algo como Object.freeze() . Este es un método que congela un objeto. Un objeto congelado ya no se puede cambiar y no se pueden agregar nuevas propiedades.

Ejemplo:

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

Answer 4

Cuando haces algo const en JavaScript, no puedes reasignar la variable misma para hacer referencia a otra cosa. Sin embargo, la variable aún puede hacer referencia a un objeto 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;

En el caso de primitivas como cadenas y números, const es más fácil de entender, ya que no muta los valores, sino que asigna un nuevo valor a la variable.

Answer 5

MDN resume muy bien:

La declaración const crea una referencia de solo lectura a un valor. No significa que el valor que posee es inmutable, solo que el identificador de variable no se puede reasignar. Por ejemplo, en caso de que el contenido sea un objeto, esto significa que el objeto en sí puede ser alterado.

Más sucintamente: const crea una unión inmutable.

En otras palabras: const, como var, te da una porción mutable de memoria en la que estás almacenando algo. Sin embargo, const dicta que debe seguir refiriéndose a ese mismo fragmento de memoria: no puede reasignar la variable a un fragmento diferente de memoria, porque la referencia de la variable es constante.

Para hacer algo realmente constante e inmutable después de haberlo declarado, debe usar algo como Object.freeze() . Sin embargo, eso es superficial y solo funciona en pares clave / valor. Congelar un objeto completo requiere un poco más de esfuerzo. Hacerlo repetidamente de manera eficiente es aún más desafiante. Si realmente lo necesita, le recomiendo que consulte algo como Immutable.js