javascript - diferencias - ¿Cuál es la diferencia entre ''let'' y ''const'' ECMAScript 6?

difference between let var and const in javascript

Question

Me pregunto cuál es la diferencia entre let y const en ECMAScript 6. Ambas tienen un ámbito de bloque, como ejemplo en el siguiente código:

const PI = 3.14;
console.log(PI);
PI = 3;
console.log(PI);
const PI = 4;
console.log(PI);
var PI = 5;
console.log(PI);

En ECMAScript 5 la salida será:

3.14
3.14
3.14
3.14

Pero en ECMAScript 6 será:

3.14
3
4
5

Me pregunto por qué ECMAScript 6 permite el cambio de valor de const, la pregunta es ¿por qué deberíamos usar ''const'' ahora? podemos usar ''dejar'' en su lugar?

Nota : jsbin se puede usar para probar, elegir JavaScript para ejecutar el código de ECMAScript 5 y Traceur para ejecutarlo con las capacidades de ECMAScript 6.

Answer 1

dejar

• Use el alcance del bloque en la programación.
• para cada bloque, creemos su propio ámbito nuevo al que no puede acceder fuera de ese bloque.
• el valor se puede cambiar tantas veces como lo desee.

• let es extremadamente útil para la gran mayoría del código. Puede mejorar enormemente la legibilidad del código y disminuir la posibilidad de un error de programación.

  let abc = 0;
  if(true)
  abc = 5 //fine
  if(true){
  let def = 5
  }
  console.log(def)

const

• Te permite ser inmutable con las variables.

• const es una buena práctica tanto para la legibilidad como para el mantenimiento y evita el uso de literales mágicos, por ejemplo

  // Low readability
  if (x > 10) {
  }
  //Better!
  const maxRows = 10;
  if (x > maxRows) {
  }

• las declaraciones de const deben inicializarse

   const foo; // ERROR: const declarations must be initialized

• Un const es un bloque de ámbito como el que vimos con let: +

const foo = 123;
if (true) {
const foo = 456; // Allowed as its a new variable limited to this `if` block
}

Answer 2

Aquí hay algunas notas que tomé que me ayudaron en este tema. También comparando const y let a var .

Aquí hay información sobre var :

// Var
// 1. var is hoisted to the top of the function, regardless of block
// 2. var can be defined as last line and will be hoisted to top of code block
// 3. for undefined var //output error is ''undefined'' and code continues executing
// 4. trying to execute function with undefined variable
// Example: // log(myName); // output: ReferenceError: myName is not defined and code stops executing

Aquí hay información sobre let and const :

// Let and Const
// 1. use `const` to declare variables which won''t change
// 2. `const` is used to initialize-once, read-only thereafter
// 3. use `let` to declare variables which will change
// 4. `let` or `const` are scoped to the "block", not the function
// 5. trying to change value of const and then console.logging result will give error
// const ANSWER = 42;
// ANSWER = 3.14159;
// console.log(ANSWER);
// Error statement will be "TypeError: Assignment to constant variable." and code will stop executing
// 6. `let` won''t allow reference before definition
// function letTest2 () {
// log(b);
// let b = 3;}
// Error statement will be "ReferenceError: b is not defined." and code will stop executing

Answer 3

La diferencia entre let y const es que una vez que vincula un valor / objeto a una variable usando const , no puede reasignar a esa variable. Ejemplo:

const something = {};
something = 10; // Error.
let somethingElse = {};
somethingElse = 1000; // This is fine.

Tenga en cuenta que const no hace que algo sea inmutable.

const myArr = [];
myArr.push(10); // Works fine.

Probablemente, la mejor manera de hacer que un objeto (superficialmente) sea inmutable en este momento es usar Object.freeze() en él.

Answer 4

Lo que estás viendo es solo un error de implementación. De acuerdo con la wiki de especificaciones de ES6 en const , const es:

Un formulario de inicialización de una vez, de solo lectura a partir de entonces es útil y tiene un precedente en las implementaciones existentes, en forma de declaraciones const.

Está destinado a ser de solo lectura, tal como es actualmente. La implementación ES6 de const en Traceur y Continuum tiene fallas (probablemente solo se le pasó por alto)

Aquí hay un problema de Github con respecto a Traceur que no implementa const

Answer 5

dejar y const

Las variables declaradas con let y const eliminan el problema específico de izar porque tienen un alcance al bloque, no a la función.

Si se declara una variable usando let o const dentro de un bloque de código (denotado con llaves {}), entonces la variable queda atrapada en lo que se conoce como la zona muerta temporal hasta que se procesa la declaración de la variable. Este comportamiento impide que se acceda a las variables solo hasta después de haber sido declaradas.

Reglas para usar let y const

let y const también tienen otras propiedades interesantes.

• Las variables declaradas con let se pueden reasignar, pero no se pueden volver a declarar en el mismo ámbito.
• Las variables declaradas con const deben asignar a un valor inicial, pero no se pueden volver a declarar en el mismo ámbito y no se pueden reasignar.

Casos de uso

La gran pregunta es cuándo deberías usar let y const ? La regla general es la siguiente:

• use let cuando planee reasignar nuevos valores a una variable, y
• use const cuando no planea reasignar nuevos valores a una variable.

Como const es la forma más estricta de declarar una variable, se sugiere que siempre declare las variables con const porque hará que su código sea más fácil de razonar, ya que sabe que los identificadores no cambiarán a lo largo de la vida útil de su programa. Si encuentra que necesita actualizar una variable o cambiarla, vuelva atrás y cambie de const a let .