¿Cuánto debo usar 'let' vs 'const' en ES6?

Mi respuesta aquí no es específica de javascript.

Como regla general en cualquier idioma que me permita hacerlo de una manera casi fácil, diría que siempre use const / final / readonly / como se llame en su idioma siempre que sea posible. La razón es simple, es mucho más fácil razonar sobre el código cuando está totalmente claro qué puede cambiar y qué no. Y además de esto, en muchos idiomas puede obtener soporte de herramientas que le indican que está haciendo algo mal cuando asigna accidentalmente una variable que ha declarado constante.

Volver y cambiar una constante a un let es muy simple. Y el ir por constante te hace pensar dos veces antes de hacerlo. Y esto es en muchos casos algo bueno.

¿Cuántos errores has visto que implican cambios inesperados en las variables? Me imagino mucho. Sé que la mayoría de los errores que veo implican cambios de estado inesperados. ¡No podrás deshacerte de todos estos errores utilizando generosamente const, pero sí eliminarás muchos de ellos!

Además, muchos lenguajes funcionales tienen variables inmutables donde todas las variables son constantes de forma predeterminada. Mira a Erlang por ejemplo, o F #. La codificación sin asignación funciona perfectamente en estos idiomas y es una de las muchas razones por las que las personas aman la programación funcional. Hay mucho que aprender de estos idiomas sobre la gestión del estado para poder ser un mejor programador.

¡Y todo comienza siendo extremadamente liberal con const! ;) Son solo dos caracteres más para escribir en comparación con let, así que adelante, ¡ const todas las cosas!

Tenga cuidado, porque las claves de objeto const son mutables.

Desde aquí: enlace

  

las claves de objeto no están protegidas

considera este ejemplo:

const colors = {red: "#f00"}; 
console.log(colors); // { "red": "#f00" }

colors.red = "#00f";
colors.green = "#0f0";
console.log(colors); // { "red": "#00f", "green": "#0f0" }

Lo mismo para matrices:

const numbers = [1, 2, 3];
console.log(numbers); // [ 1, 2, 3 ]

numbers.push(4);
console.log(numbers); // [ 1, 2, 3, 4 ]

No lo he decidido totalmente por mí mismo, pero estoy considerando usar const para todos los no-array / no-objetos y usar let para los objetos / arrays.

No te preocupes por eso. const es una adición increíble a JavaScript, y le recomendaría que lo use en todos los lugares en los que tenga sentido. Hace un código más robusto.

Cuando se trata de objetos, const protegerá su variable de la reasignación, pero si necesita objetos inmutables, necesitará el método Object.freeze , consulte a continuación.

const immutableOject = Object.freeze({immutableProperty: 'foo'});

const protegerá solo de la reasignación, y el método freeze protegerá todas las propiedades inmediatas. Si necesita que todas las propiedades anidadas también sean inmutables, entonces necesitará recursivamente freeze them.

En mi ES6 const no se trata de inmutabilidad publicación, explico lo que const significa exactamente de acuerdo con la especificación.

Basado en esos hechos objetivos, aquí está mi preferencia personal:

  

[...] tiene sentido usar let y const de la siguiente manera en tu código ES6:

     

• usa const por defecto
  
• solo use let si es necesario volver a vincular (es decir, cualquier forma de reasignación)
  
• ( var no debe usarse en ES6)
  

Por más subjetivo que sea, es un hecho que esto coincide más con la intención de la especificación.

Las personas que usan let por defecto por lo general tratan las variables const como constantes (¡que no son necesariamente, por diseño!). A cada uno lo suyo, pero prefiero usar las cosas para el propósito previsto, y no para el significado que las personas le asignan debido a un malentendido.

Usar const solo para constantes es como usar el elemento HTML <aside> elemento solo para contenido de la barra lateral.

Mi enfoque personal, pensado para ayudar a la legibilidad y comprensión del código:

let es solo para variables de corta duración, definidas en una sola línea y no cambiadas después. Generalmente aquellas variables que están ahí solo para disminuir la cantidad de escritura. Por ejemplo:

for (let key in something) {
  /* we could use 'something[key]' for this entire block,
     but it would be too much letters and not good for the
     fingers or the eyes, so we use a radically temporary variable
  */
  let value = something[key]
  ...
}

const para todos los nombres que se sabe que son constantes en todo el módulo. No incluye valores constantes localmente. El value en el ejemplo anterior, por ejemplo, es constante en su alcance y podría declararse con const , pero ya que hay muchas iteraciones y para cada una hay un valor con el mismo nombre , "valor", que podría engañar al lector para que piense que value es siempre el mismo. Los módulos y las funciones son el mejor ejemplo de const variables:

const PouchDB = require('pouchdb')
const instantiateDB = function () {}
const codes = {
  23: 'atc',
  43: 'qwx',
  77: 'oxi'
}

var para todo lo que puede o no ser variable. Los nombres que pueden confundir a las personas que leen el código, incluso si son constantes localmente y no son adecuados para let (es decir, no se completan en una declaración directa simple) se aplican para ser declarados con var . Por ejemplo:

var output = '\n'
lines.forEach(line => {
  output += '  '
  output += line.trim()
  output += '\n'
})
output += '\n---'

for (let parent in parents) {
  var definitions = {}
  definitions.name = getName(parent)
  definitions.config = {}
  definitions.parent = parent
}

Comentarios adicionales y posibles actualizaciones futuras aquí .

JavaScript es un poco especial porque las variables pueden ser funciones, pero considere en C #, Java u otro lenguaje de estilo C similar:

const public void DoSomething()

El const es impar, y eso se debe a que las declaraciones de métodos en estos idiomas no pueden cambiar, una vez que se compilan en otra cosa, eso es lo que hacen, sin importar qué (ignorando algunos hacks horribles que puedan existir).

¿Por qué debería ser diferente JavaScript? Por lo tanto, no está compilado, pero eso no significa que debamos deshacernos de la seguridad que pueden proporcionar los compiladores. El uso de la palabra clave const nos da más seguridad, lo que seguramente llevará a aplicaciones más robustas.