¿Cuánto debería usar 'let' vs 'const' en ES6?

He estado escribiendo mucho código ES6 para io.js recientemente. No hay mucho código en la naturaleza para aprender, así que siento que estoy definiendo mis propias convenciones a medida que avanzo.

Mi pregunta es acerca de cuándo utilizar constvs let.

He estado aplicando esta regla: si es posible, úsala const. Úselo solo letsi sabe que su valor debe cambiar. (Siempre puede regresar y cambiar a consta a letsi luego resulta que necesita cambiar su valor).

La razón principal de esta regla es que es fácil de aplicar de manera consistente. No hay zonas grises.

La cuestión es que, cuando aplico esta regla, en la práctica lo son el 95% de mis declaraciones const. Y esto me parece raro. Solo lo uso letpara cosas como ien un forbucle, u ocasionalmente para cosas como los totales acumulados de Fibonacci (que no aparece mucho en la vida real). Me sorprendió esto: resulta que el 95% de las 'variables' en mi código ES5 hasta la fecha eran para valores que no varían. Pero ver consttodo mi código se siente mal de alguna manera.

Entonces mi pregunta es: ¿está bien usar consttanto? ¿Realmente debería estar haciendo cosas como const foo = function () {...};?

¿O debería reservar constpara ese tipo de situaciones en las que está codificando un literal en la parte superior de un módulo, como el que hace en mayúsculas const MARGIN_WIDTH = 410;?

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

Como regla general en cualquier idioma que me permita hacerlo de una manera semi 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 es obvio qué puede cambiar y qué no. Y además de esto, en muchos idiomas puede obtener soporte de herramientas que le indica que está haciendo algo mal cuando asigna de forma accidental a una variable que ha declarado como constante.

Volver atrás y cambiar una constante a una let es muy simple. Y seguir const por defecto te hace pensar dos veces antes de hacerlo. Y esto es en muchos casos algo bueno.

¿Cuántos errores has visto que implican que las variables cambien inesperadamente? Supongo que mucho. Sé que la mayoría de los errores que veo implican cambios de estado inesperados. No eliminarás todos estos errores usando liberalmente const, ¡pero eliminarás muchos de ellos!

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

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

Tenga cuidado, porque las constclaves de objeto son mutables.

Desde aquí: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

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 las matrices:

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

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

No me he decidido totalmente a mí mismo, pero estoy considerando usarlo constpara todos los objetos que no sean matrices / no y usarlos letpara objetos / matrices.

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

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

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

constprotegerá solo de la reasignación, y el freezemétodo protegerá todas las propiedades inmediatas. Si necesita que todas las propiedades anidadas también sean inmutables, deberá recurrirlas recursivamente freeze.

En mi ES6 constno se trata de la publicación de inmutabilidad , explico lo que constsignifica exactamente de acuerdo con las especificaciones.

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

[…] Tiene sentido usar lety constcomo sigue en su código ES6:

• usar constpor defecto
• solo se usa letsi se necesita volver a vincular (es decir, cualquier forma de reasignación)
• ( varno debe usarse en ES6)

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

Las personas que usan letpor defecto generalmente tratan las constvariables como constantes (¡lo cual no es necesariamente, por diseño!). A cada uno lo suyo, pero prefiero usar las cosas para su propósito previsto, y no para un significado inventado que las personas le asignan en base a un malentendido.

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

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

letes solo para variables de corta duración, definidas en una sola línea y no modificadas después. Generalmente aquellas variables que están ahí solo para disminuir la cantidad de tipeo. 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]
  ...
}

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

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

varpara 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 let(es decir, no se completan en una declaración directa simple), se solicitan 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 en el sentido de que las variables pueden ser funciones y demás, pero tenga en cuenta en C #, Java u otro lenguaje de estilo C similar:

const public void DoSomething()

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

¿Por qué debería ser JavaScript diferente? Por lo tanto, no se compila, pero eso no significa que debamos descartar la seguridad que los compiladores pueden proporcionar. El uso de la constpalabra clave nos brinda más seguridad, lo que seguramente conducirá a aplicaciones más robustas.