Сколько я должен использовать 'let' против 'const' в ES6?

Недавно я написал много кода ES6 для io.js. В дикой природе не так уж много полезного, поэтому я чувствую, что по ходу дела определяю свои собственные соглашения.

Мой вопрос о том, когда использовать constпротив let.

Я применяю это правило: если возможно, используйте const. Используйте только letесли вы знаете, что его значение необходимо изменить. (Вы всегда можете вернуться и изменить a constна a, letесли позже выяснится, что вам нужно изменить его значение.)

Основная причина этого правила - его легко применять последовательно. Там нет серых зон.

Дело в том, что когда я применяю это правило, на практике это 95% моих заявлений const. И это выглядит странно для меня. Я использую только letдля таких вещей, как iв forцикле, или иногда для таких вещей, как накопленные итоги Фибоначчи (что не так уж и много в реальной жизни). Я был удивлен этим - оказывается, 95% «переменных» в моем коде ES5 на сегодняшний день были для значений, которые не меняются. Но, видя constвесь мой код, я чувствую что-то не так.

Итак, мой вопрос: нормально ли это использовать const? Должен ли я действительно делать такие вещи, как const foo = function () {...};?

Или я должен зарезервировать constдля тех ситуаций, когда вы жестко кодируете литерал в верхней части модуля - как вы делаете в полных заглавных буквах, как const MARGIN_WIDTH = 410;?

Мой ответ здесь не зависит от javascript.

Как правило, на любом языке, который позволяет мне делать это в полулегком виде, я бы сказал, всегда используйте const / final / readonly / независимо от того, как это называется в вашем языке, когда это возможно. Причина проста, гораздо проще рассуждать о коде, когда он абсолютно очевиден, что может измениться, а что нет. И в дополнение к этому, во многих языках вы можете получить поддержку инструментов, которая говорит вам, что вы делаете что-то неправильно, когда вы случайно назначаете переменную, которую вы объявили как const.

Вернуться назад и изменить const на let очень просто. И если по умолчанию использовать const, вам придется дважды подумать, прежде чем делать это. И это во многих случаях хорошо.

Сколько ошибок вы видели, что переменные неожиданно изменились? Я бы многое угадал. Я знаю, что большинство ошибок, которые я вижу, связано с неожиданными изменениями состояния. Вы не избавитесь от всех этих ошибок, свободно используя const, но вы избавитесь от многих из них!

Кроме того, многие функциональные языки имеют неизменяемые переменные, где все переменные по умолчанию постоянны. Посмотрите на Эрланга, например, или F #. Кодирование без присваивания прекрасно работает на этих языках и является одной из многих причин, почему люди любят функциональное программирование. Из этих языков можно многому научиться в управлении состоянием, чтобы стать лучшим программистом.

И все начинается с того, чтобы быть чрезвычайно либеральным с const! ;) Это всего лишь два символа, которые нужно написать, по сравнению с let, так что давай, и constвсе!

Будьте осторожны, потому что constключи объектов изменчивы.

Отсюда: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

ключи объекта не защищены

рассмотрим этот пример:

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

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

То же самое для массивов:

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

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

Я не решил полностью сам, но я рассматриваю использование constдля всех не массивов / не-объектов и использование letдля объектов / массивов.

Не беспокойся об этом. constэто удивительное дополнение к JavaScript, и я бы порекомендовал вам использовать его везде, где это имеет смысл. Это делает для более надежного кода.

Когда дело доходит до объектов, constзащитит вашу переменную от переназначения, но если вам нужны неизменяемые объекты, вам понадобится Object.freezeметод, см. Ниже.

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

constбудет защищать только от переназначения, а freezeметод будет защищать все непосредственные свойства. Если вам нужно, чтобы все вложенные свойства также были неизменяемыми, то вам нужно будет рекурсивно freezeих использовать.

В моем ES6 речь constидет не об неизменяемости поста, я объясняю, что constзначит именно по спецификации.

Исходя из этих объективных фактов, вот мое личное предпочтение:

[…] Имеет смысл использовать letи constв вашем коде ES6 следующее:

• использовать constпо умолчанию
• используйте только letесли требуется повторная привязка (т. е. любая форма переназначения)
• ( varне следует использовать в ES6)

Как бы субъективно это ни было, факт, что это наиболее точно соответствует цели спецификации.

Люди, которые используют letпо умолчанию, обычно рассматривают constпеременные как константы (а это не обязательно, по замыслу!). Каждому свое, но я предпочитаю использовать вещи по прямому назначению, а не для какого-то придуманного значения, которое люди присваивают ему по недоразумению.

Использование constтолько для констант похоже на использование элемента HTML<aside> только для содержимого боковой панели.

Мой личный подход, помогающий читаемости и пониманию кода:

letтолько для кратковременных переменных, определенных в одной строке и не изменяемых после. Как правило, те переменные, которые есть только для уменьшения количества набрав. Например:

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для всех имен, которые известны постоянными во всем модуле. Не включая локально постоянные значения. valueВ приведенном выше примере, например, постоянно в объеме и может быть объявлено с const, но так как есть много итераций и для каждого из них есть значение с таким же названием , «значение», которые могли бы обмануть читатель в мышлении valueвсегда тот же самый. Модули и функции являются лучшим примером constпеременных:

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

varза все, что может или не может быть переменной. Имена, которые могут запутать людей, читающих код, даже если они являются локальными константами и не подходят для let(т. Е. Они не заполнены в простой прямой декларации), применяются для объявления с помощью var. Например:

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
}

Дальнейшие комментарии и возможные будущие обновления здесь .

JavaScript немного особенный в том смысле, что переменные могут быть функциями и тому подобное, но рассмотрим в C #, Java или другом подобном языке стиля C:

const public void DoSomething()

Это constстранно, и это потому, что объявления методов в этих языках не могут измениться, как только они скомпилированы во что-то другое, это то, что они делают, несмотря ни на что (игнорируя некоторые ужасные хаки, которые могут существовать).

Почему JavaScript должен быть другим? Так что он не скомпилирован, но это не значит, что мы должны отбросить безопасность, которую могут обеспечить компиляторы. Использование constключевого слова дает нам больше безопасности, что, безусловно, приведет к более надежным приложениям.