Сколько я должен использовать 'let' vs 'const' в ES6?
Недавно я писал много кода ES6 для io.js. В дикой природе не так много кода, поэтому я чувствую, что я определяю свои собственные соглашения, когда я иду.
Мой вопрос о том, когда следует использовать const
vs let
.
Я применяю это правило: если возможно, используйте const
. Используйте let
, если вы знаете, что его значение необходимо изменить. (Вы всегда можете вернуться и изменить const
на let
, если позже выяснится, что вам нужно изменить его значение.)
Основная причина этого правила заключается в том, что его легко применять последовательно. Серных областей нет.
Дело в том, что когда я применяю это правило, на практике 95% моих объявлений являются const
. И это выглядит странно для меня. Я использую let
для таких вещей, как i
в цикле для
, или иногда для таких вещей, как накопленные итоговые значения Фибоначчи (которые не появляются много в реальной жизни). Я был удивлен этим - получается, что 95% «переменных» в моем коде ES5 на сегодняшний день были для значений, которые не меняются. Но, увидев const
по всему моему коду, вы как-то ошибаетесь.
Итак, мой вопрос: хорошо ли это использовать const
? Должен ли я действительно делать такие вещи, как const foo = function () {...};
?
Или я должен зарезервировать const
для тех ситуаций, где вы жестко кодируете литерал в верхней части модуля - вид, который вы делаете в полном размере, например const MARGIN_WIDTH = 410;
?
6 ответов
Мой ответ здесь не зависит от javascript.
Как правило, на любом языке, который позволяет мне сделать это полулегким способом, я бы всегда говорил, что всегда используйте const /final /readonly /независимо от того, что он вызывается на вашем языке, когда это возможно. Причина проста, гораздо проще рассуждать о коде, когда он мертв, что может измениться и что не может измениться. Кроме того, на многих языках вы можете получить поддержку инструмента, которая говорит вам, что вы делаете что-то неправильно, когда вы случайно назначаете переменную, которую вы объявили как const.
Возвращение назад и изменение константы на пуск мертво просто. И переход const по умолчанию заставляет вас дважды подумать, прежде чем делать это. И во многих случаях это хорошо.
Сколько ошибок вы заметили, когда переменные менялись неожиданно? Я бы догадался. Я знаю, что большинство ошибок, которые я вижу, связаны с неожиданными изменениями состояния. Вы не избавитесь от всех этих ошибок, просто используя const, но вы избавитесь от многих из них!
Кроме того, многие функциональные языки имеют неизменяемые переменные, где по умолчанию все переменные const. Посмотрите, например, на Erlang или F #. Кодирование без назначения отлично работает на этих языках и является одной из многих причин, по которым люди любят функциональное программирование. Существует много возможностей учиться на этих языках об управлении состоянием, чтобы стать лучшим программистом.
И все начинается с того, чтобы быть чрезвычайно либеральным со const! ;) Это всего лишь два символа для записи по сравнению с let, поэтому продолжайте и const
все вещи!
Будьте осторожны, поскольку ключи объекта const
изменяемы.
Отсюда: https://developer.mozilla.org/en- США /документы /Web /JavaScript /Справка /Заявления /Const
ключи объекта не защищены
рассмотрим этот пример:
const colors = {red: "# f00"};
console.log (цвет); //{"red": "# f00"}
colors.red = "# 00f";
colors.green = "# 0f0";
console.log (цвет); //{"red": "# 00f", "green": "# 0f0"}
То же самое для массивов:
const numbers = [1, 2, 3];
console.log (номера); //[1, 2, 3]
numbers.push (4);
console.log (номера); //[1, 2, 3, 4]
Я не решил полностью сам, но я рассматриваю использование const
для всех не-массивов /не-объектов и использовать let
для объектов /массивов.
Не беспокойтесь об этом. const
- замечательное дополнение к JavaScript, и я бы рекомендовал вам использовать его во всех местах, где это имеет смысл. Он обеспечивает более надежный код.
Когда дело доходит до объектов, const
защитит вашу переменную от переназначения, но если вам нужны неизменные объекты, вам понадобится метод Object.freeze
, см. ниже.
const immutableOject = Object.freeze ({immutableProperty: 'foo'});
const
будет защищать только от переназначения, а метод freeze
защитит все неотложные свойства. Если вам нужно, чтобы все вложенные свойства также были неизменяемыми, вам потребуется рекурсивно заморозить
их.
В моем ES6 const
не относится к неизменяемости , я объясню, что означает const
в соответствии со спецификацией.
Основываясь на этих объективных фактах, вот мои личные предпочтения:
[â € |] имеет смысл использовать
let
иconst
в коде ES6:
- использовать
const
по умолчанию- используйте
let
, если требуется пересортировка (т. е. любая форма переназначения)- (
var
не должен использоваться в ES6)
Субъективно, как это может быть, это факт, что это наиболее близко соответствует намерению спекуляции.
Люди, которые по умолчанию используют let
, обычно рассматривают переменные const
как константы (которые они не обязательно, по дизайну!). Каждому свое, но я предпочитаю использовать вещи по их прямому назначению, а не для определенного значения, которое люди назначают ему на основе недоразумений.
Использование const
только для констант похоже на HTML <aside>
только для содержимого боковой панели.
Мой личный подход, подумал о том, чтобы помочь читать и понимать код:
let
предназначен только для короткоживущих переменных, определенных в одной строке и не изменяющихся после. Обычно те переменные, которые есть только для уменьшения количества ввода. Например:
для (пусть ключ в чем-то) {
/* мы могли бы использовать `something [key]` для всего этого блока,
но это было бы слишком много писем и не было бы хорошо для
пальцами или глазами, поэтому мы используем радикально временную переменную
* /
let value = something [key]
...
}
const
для всех имен , которые, как известно, являются постоянными во всем модуле. Не включая локально постоянные значения. Значение в приведенном выше примере, например, является постоянным в своей области и может быть объявлено с помощью
const
, но поскольку существует много итераций, и для каждого из них есть значение с такое же имя , "значение", которое может обмануть читателя в мысли value
всегда одинаково. Модули и функции являются лучшим примером переменных const
:
const PouchDB = require ('pouchdb')
const instantiateDB = function () {}
const-коды = {
23: 'atc',
43: «qwx»,
77: 'oxi'
}
var
для всего, что может быть или не быть переменным. Имена, которые могут смущать людей, читающих код, даже если они являются постоянными локально и не подходят для let
(т. Е. Они не заполняются в простом прямом объявлении) применяются для объявления с помощью вар
. Например:
var output = '\ n'
lines.forEach (line => {
output + = ''
output + = line.trim ()
output + = '\ n'
})
output + = '\ n ---'
для (пусть родитель в родителях) {
определения var = {}
определения.name = getName (родительский)
definitions.config = {}
definition.parent = parent
}
Дальнейшие комментарии и возможные будущие обновления здесь .
JavaScript является немного особенным в том, что переменные могут быть функциями и такими, но учитывать в C #, Java или другом подобном языке стиля C:
const public void DoSomething ()
const
является нечетным, и это потому, что объявления методов на этих языках не могут измениться, как только они скомпилированы во что-то еще, что они делают, независимо от того, что (игнорируя некоторые ужасные хаки, которые может существовать).
Почему JavaScript должен быть другим? Поэтому он не компилируется, но это не значит, что мы должны отбросить безопасность, которую могут предоставить компиляторы. Использование ключевого слова const
дает нам больше безопасности, что, несомненно, приведет к созданию более надежных приложений.