web-dev-qa-db-fra.com

Combien dois-je utiliser «let» vs «const» dans ES6?

J'ai écrit beaucoup de code ES6 pour io.js récemment. Il n'y a pas beaucoup de code dans la nature à apprendre, donc j'ai l'impression de définir mes propres conventions au fur et à mesure.

Ma question est de savoir quand utiliser const vs let.

J'ai appliqué cette règle: Si possible, utilisez const. N'utilisez let que si vous savez que sa valeur doit changer. (Vous pouvez toujours revenir en arrière et changer un const en let s'il s'avère plus tard que vous devez changer sa valeur.)

La raison principale de cette règle est qu'elle est facile à appliquer de manière cohérente. Il n'y a pas de zones grises.

Le fait est que lorsque j'applique cette règle, dans la pratique, 95% de mes déclarations sont const. Et cela me semble bizarre. J'utilise uniquement let pour des choses comme i dans une boucle for, ou occasionnellement pour des choses comme les totaux de Fibonacci accumulés (qui n'apparaissent pas beaucoup dans la vraie vie) . J'ai été surpris par cela - il s'avère que 95% des "variables" dans mon code ES5 à ce jour étaient des valeurs qui ne varient pas. Mais voir const partout dans mon code semble quelque peu faux.

Donc ma question est: est-ce OK d'utiliser autant de const? Dois-je vraiment faire des choses comme const foo = function () {...};?

Ou devrais-je réserver const pour ce genre de situations où vous codez en dur un littéral en haut d'un module - le type que vous faites en majuscules, comme const MARGIN_WIDTH = 410;?

javascriptes6
217
callum

Ma réponse ici n'est pas spécifique à javascript.

En règle générale dans n'importe quelle langue qui me permet de le faire de manière semi-facile, je dirais toujours utiliser const/final/readonly/quel que soit son nom dans votre langue autant que possible. La raison est simple, il est beaucoup plus facile de raisonner sur le code lorsqu'il est évident de savoir ce qui peut changer et ce qui ne peut pas changer. Et en plus de cela, dans de nombreuses langues, vous pouvez obtenir un support d'outil qui vous indique que vous faites quelque chose de mal lorsque vous attribuez accidentellement à une variable que vous avez déclarée const.

Revenir en arrière et changer un const en let est très simple. Et aller const par défaut vous fait réfléchir à deux fois avant de le faire. Et c'est dans de nombreux cas une bonne chose.

Combien de bogues avez-vous vu qui impliquaient des variables changeant de façon inattendue? Je devine beaucoup. Je sais que la majorité des bogues que je vois impliquent des changements d'état inattendus. Vous ne vous débarrasserez pas de tous ces bogues en utilisant généreusement const, mais vous vous en débarrasserez beaucoup!

De plus, de nombreux langages fonctionnels ont des variables immuables où toutes les variables sont const par défaut. Regardez Erlang par exemple, ou F #. Le codage sans affectation fonctionne parfaitement dans ces langages et est l'une des nombreuses raisons pour lesquelles les gens aiment la programmation fonctionnelle. Il y a beaucoup à apprendre de ces langages sur la gestion de l'état afin de devenir un meilleur programmeur.

Et tout commence par être extrêmement libéral avec const! ;) Il ne reste que deux caractères à écrire par rapport à let, alors allez-y et const toutes choses!

183
wasatz

Soyez prudent, car les clés d'objet const sont modifiables.

À partir d'ici: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

les clés d'objet ne sont pas protégées

considérez cet exemple:

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

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

Même chose pour les tableaux:

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

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

Je n'ai pas totalement décidé moi-même, mais j'envisage d'utiliser const pour tous les non-tableaux/non-objets et d'utiliser let pour les objets/tableaux.

57
lax4mike

Ne t'en fais pas. const est un ajout incroyable à JavaScript, et je vous recommande de l'utiliser à tous les endroits où cela a du sens. Cela rend le code plus robuste.

En ce qui concerne les objets, const protégera votre variable de la réaffectation, mais si vous avez besoin d'objets immuables, vous aurez besoin du Object.freeze méthode, voir ci-dessous.

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

const ne protégera que de la réaffectation et la méthode freeze protégera toutes les propriétés immédiates. Si vous avez également besoin que toutes les propriétés imbriquées soient immuables, vous devrez les récursivement freeze.

26
clean_coding

Dans mon ( ES6 const ne concerne pas l'immuabilité post, je expliquer ce que const signifie exactement selon la spécification.

Sur la base de ces faits objectifs, voici ma préférence personnelle:

[…] Il est logique d'utiliser let et const comme suit dans votre code ES6:

  • utilisez const par défaut
  • utilisez uniquement let si une nouvelle liaison (c'est-à-dire toute forme de réaffectation) est nécessaire
  • (var ne doit pas être utilisé dans ES6)

Aussi subjectif que cela puisse être, c'est un fait que cela correspond le mieux à l'intention de la spécification.

Les personnes qui utilisent let par défaut traitent généralement les variables const comme des constantes (ce qu'elles ne sont pas nécessairement, par conception!). À chacun, mais je préfère utiliser les choses pour leur destination, et non pas pour certaines choses inventées, ce que les gens leur attribuent en fonction d'un malentendu.

Utiliser const uniquement pour les constantes revient à utiliser le code HTML <aside> element uniquement pour le contenu de la barre latérale.

20
Mathias Bynens

Mon approche personnelle, pensée pour aider à la lisibilité et à la compréhension du code:

let ne concerne que les variables de courte durée, définies sur une seule ligne et non modifiées par la suite. Généralement, les variables qui ne sont là que pour diminuer la quantité de frappe. Par exemple:

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 pour tous noms connus pour être constants sur l'ensemble du module. Ne comprend pas les valeurs localement constantes. Le value dans l'exemple ci-dessus, par exemple, est de portée constante et pourrait être déclaré avec const, mais puisqu'il y a beaucoup d'itérations et pour chacun il y a une valeur avec le même nom , "valeur", qui pourrait inciter le lecteur à penser que value est toujours le même. Les modules et les fonctions sont le meilleur exemple de variables const:

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

var pour tout ce qui peut être variable ou non. Les noms qui peuvent dérouter les gens qui lisent le code, même s'ils sont constants localement et ne conviennent pas à let (c'est-à-dire qu'ils ne sont pas complétés dans une simple déclaration directe) demandent à être déclarés avec var. Par exemple:

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
}

Commentaires supplémentaires et mises à jour futures possibles ici .

4
fiatjaf

JavaScript est un peu spécial en ce que les variables peuvent être des fonctions et autres, mais considérez en C #, Java ou un autre langage de style C similaire:

const public void DoSomething()

Le const est étrange, et c'est parce que les déclarations de méthode dans ces langages ne peuvent pas changer, une fois qu'elles sont compilées dans quelque chose d'autre, c'est ce qu'elles font, quoi qu'il arrive (en ignorant quelques horribles hacks qui peuvent exister).

Pourquoi JavaScript devrait-il être différent? Il n'est donc pas compilé, mais cela ne signifie pas que nous devrions abandonner la sécurité que les compilateurs peuvent fournir. L'utilisation du mot clé const nous donne plus de sécurité, ce qui conduira sûrement à des applications plus robustes.

1
Joe