что такое констант в javascript
Переменные: let и const
Материал на этой странице устарел, поэтому скрыт из оглавления сайта.
У объявлений переменной через let есть три основных отличия от var :
Область видимости переменной let – блок <. >.
Например, переменная через var :
То же самое с let будет работать по-другому:
Заметим, что если объявление let apples в первой строке (*) удалить, то в последнем alert будет ошибка: переменная не определена:
Это потому что переменная let всегда видна именно в том блоке, где объявлена, и не более.
Переменная let видна только после объявления.
Как мы помним, переменные var существуют и до объявления. Они равны undefined :
С переменными let всё проще. До объявления их вообще нет.
Такой доступ приведёт к ошибке:
Заметим также, что переменные let нельзя повторно объявлять. То есть, такой код выведет ошибку:
При использовании в цикле, для каждой итерации создаётся своя переменная.
Переменная var – одна на все итерации цикла и видна даже после цикла:
С переменной let – всё по-другому.
Это позволяет легко решить классическую проблему с замыканиями, описанную в задаче Армия функций.
А выше объявление let i создаёт для каждого повторения блока в цикле свою переменную, которую функция и получает из замыкания в последних строках.
const
Объявление const задаёт константу, то есть переменную, которую нельзя менять:
Заметим, что если в константу присвоен объект, то от изменения защищена сама константа, но не свойства внутри неё:
То же самое верно, если константе присвоен массив или другое объектное значение.
Большинство переменных – константы в другом смысле: они не меняются после присвоения. Но при разных запусках функции это значение может быть разным. Для таких переменных можно использовать const и обычные строчные буквы в имени.
Итого
JavaScript: Переменные и константы
Переменные
Когда в программе необходимо сохранить значение, чтобы использовать его позже, это значение присваивается переменной. Переменная – это просто символьное имя для значения, которое обеспечивает возможность получить значение по имени, то есть, когда в программе указывается имя переменной вместо неё подставляется значение.
Переменная получила своё название благодаря тому, что её значение может быть изменено по ходу выполнения программы.
Константы
Константа – это просто символьное имя для значения. Константа даёт возможность обратиться к значению по имени, это означает, что, когда в программе указывается имя константы, вместо неё подставляется значение. Константы используются для хранения данных, которые не должны изменяться во время выполнения программы.
После того как константа создана, попытка переопределить её на переменную или попытка присвоить существующей константе значение вызовет ошибку.
Зачем нужны переменные и константы
Переменные и константы помогают сделать программный код понятнее. Рассмотрим небольшой пример:
Имеющиеся здесь числа могут означать что угодно. Чтобы стало понятно, что именно здесь суммируется, значение 2.42 можно присвоить переменной (или константе) candyPrice (цена конфет), а 4.33 – переменной (или константе) oilPrice (цена масла):
Теперь вместо того, чтобы вспоминать, что эти значения означают, можно увидеть, что в сценарии складывается цена конфет с ценой масла.
Также, переменные и константы помогают экономить время при отладке сценария. Вместо того, чтобы везде использовать один и тот же литерал, его можно присвоить в начале сценария переменной (или константе), и далее в остальном коде сценария вместо литерала использовать переменную (или константу). Если позднее будет принято решение об изменении значения, то вносить изменения в коде придётся не в нескольких местах, а только в одном месте – там, где переменной (или константе) присваивалось значение.
Область видимости констант
К константам применяются те же правила, что и к переменным, объявленным с помощью ключевого слова let :
Константы и ссылочные типы
Когда константе присваивается значение ссылочного типа, то неизменяемой становится ссылка на значение, а само значение остаётся доступным для изменений:
Когда использовать var, let и const в Javascript [перевод статьи Tyler’а McGinnis]
Привет, Хабр! Представляю вашему вниманию перевод статьи «var vs let vs const in JavaScript» автора Tyler McGinnis.
В этой статье вы узнаете 2 новых способа для создания переменных в Javascript (ES6), let и const. На протяжении этой статьи мы рассмотрим разницу между var, let и const, а также смежные темы такие как: “область видимости функции против блочной области видимости“, “поднятие” переменных и иммутабельность.
Если вы предпочитаете видео, посмотрите это (оригинал на английском):
ES2015 (или ES6) представил нам 2 новых способа для создания переменных, let и const. Но прежде чем мы углубимся в различия между var, let и const, имеются некоторые темы, которые вам следует узнать в первую очередь. Это объявление переменных и их инициализация, область видимости (особая область видимости функции) и “поднятие”.
Объявление и инициализация переменных
Объявление переменной вводит новый идентификатор.
Выше мы создаем новый идентификатор который мы назвали “declaration”. В Javascript, при создании, переменные инициализируются со значением undefined. Это означает, что если мы попробуем вывести нашу переменную declaration, мы получим undefined.
И так, мы вывели переменную declaration и мы получили undefined.
По сравнению с объявлением переменной, инициализация переменной это когда вы в первый раз устанавливаете значение этой переменной.
И так, здесь мы инициализировали переменную declaration записывая в неё строку.
Это приводит нас к следующему понятию, область видимости.
Область видимости
“Если объявление переменной происходит внутри объявления функции, переменная определяется в локальной области видимости этой функции…”
Это означает, что если вы создадите переменную при помощи var, областью видимости этой переменной будет функция в которой она была создана и будет доступна только внутри этой функции или любой другой вложенной функции.
Выше мы попытались получить доступ к переменной снаружи функции, в которой она была объявлена. Так как областью видимости переменной date является функция getDate, она доступна только внутри этой функции или в любой другой функции вложенной в getDate(как показано ниже).
Теперь давайте взглянем на более продвинутый пример. Скажем, у нас есть массив prices и нам требуется функция, которая принимает этот массив, а так же переменную discount, и возвращает нам новый массив цен со скидками. Конечная цель может выглядеть примерно так:
И реализация может выглядеть примерно так:
Выглядит достаточно просто, но какое это отношение имеет к области видимости блока? Взгляните на данный цикл for. Доступны ли переменные объявленные внутри него за его пределами? Оказывается доступны.
Если JavaScript это единственный язык программирования который вы знаете, вы можете особо и не задумываться об этом. Однако, если вы пришли в JavaScript из другого языка программирования, в частности языка программирования, который блокирует область видимости, вы, вероятно, немного обеспокоены тем что здесь происходит.
Оно не сломано, просто работает немного странно. На самом деле нет никаких причин иметь доступ к i, discountPrice и finalPrice за пределами цикла for. Это не приносит нам никакой пользы и может даже принести нам вред в некоторых ситуациях. Однако, так как переменные объявлены при помощи var, они входят в область видимости функции и вы можете получить к ним доступ.
Теперь мы обсудили объявление и инициализацию переменных, а так же области видимости, ещё одна вещь с которой нам нужно разобраться, прежде чем мы погрузимся в разбор различий между let и const, это “поднятие”.
“Поднятие”
Помните, ранее было сказано “В Javascript, при создании, переменные инициализируются со значением undefined “. Оказывается это и означает “поднятие”. Интерпретатор JavaScript назначает объявленным переменным значение undefined во время фазы называемой “Создание”.
Для более подробного изучения фазы Создания, “Поднятия” и областей видимости прочтите данную статью: “The Ultimate Guide to Hoisting, Scopes, and Closures in JavaScript”.
Давайте взглянем на предыдущий пример и увидим как “поднятие” влияет на него.
Обратите внимание, всем объявленным переменным было присвоено значение undefined. Вот почему если вы попытаетесь получить доступ к одной из них, до того как она на самом деле будет объявлена, вы просто получите undefined.
Теперь вы знаете все что нужно о var, теперь давайте наконец-то поговорим о главной цели, из-за которой мы здесь: в чем разница между var, let и const?
var, let или const
Для начала, давайте сравним var и let. Ключевое отличие между var и let это то, что let помимо глобальной области видимости и области видимости функции позволяет определять переменные в области видимости блока. Это означает, что переменная созданная при помощи ключевого слова let доступна внутри “блока”, где она была создана, также и внутри вложенных блоков. Когда я сказал “блок”, я имел в виду что-либо окруженное фигурными скобками <>, например цикл for или оператор if.
И так, давайте вернемся к нашей функции discountPrices в последний раз.
Вспомните, что мы вправе вывести i, discountPrice, и finalPrice за пределами цикла for, так как они были объявлены при помощи var, а переменные объявленные при помощи ключевого слова var ограничены областью видимости функции. Но что же произойдет теперь, если мы изменим var на let и попробуем запустить наш код?
Мы получили ReferenceError: i is not defined. Что говорит нам о том, что переменная, объявленная при помощи let, ограничена областью видимости блока, а не функции. Попытайтесь обратиться к i (или discountedPrice или finalPrice) за пределами “блока”, где они были объявлены, и это выдаст нам ошибку обращения, как мы только что увидели.
Следующие различие связано с “поднятием”. Ранее мы сказали, что определение “поднятия” это: “Интерпретатор JavaScript назначает объявленным переменным значение undefined во время фазы называемой “Создание”». Мы так же увидели это в действии при помощи вызова переменной до её объявления (вы получили undefined).
Я не могу вспомнить ни одного случая использования, когда вы на самом деле хотели бы получить доступ к переменной до её объявления. Кажется, что получить ReferenceError было бы лучше, чем получить undefined.
По факту, это и есть то что делает let. Если вы попытаетесь доступ к переменной до её объявление при помощи let, вместо получения undefined (как это было при объявлении при помощи var), вы получите ReferenceError.
let или const
Теперь вы понимаете разницу между var и let, что же о const? Оказывается, const почти такая же как и let. Однако есть одно отличие: если вы однажды присвоили значение используя const, вы не сможете его изменить на другое.
Вывод из того что выше — переменные, объявленные с помощью let могут быть перезаписаны, а переменные объявленные с помощью const не могут.
Отлично, теперь когда вы захотите, чтобы ваша переменная была неизменна вы можете объявить её при помощи const. Или не совсем. Просто потому что переменная была объявлена при помощи const не означает, что она неизменна, все что это значит, это то что она не может быть перезаписана. Ниже приведен хороший пример.
Заметьте, что изменения свойства объекта не является его перезаписью, так что даже если объект объявлен при помощи const, это не означает, что вы не можете изменить какие-либо из его свойств. Это только значит, что вы не можете перезаписать этот объект.
Теперь, наиболее важный вопрос, на который ещё не было ответа: что следует использовать var, let или const? Самое популярное мнение, и мнение которого придерживаюсь я, это использовать всегда const, пока вы не знаете будет ли переменная изменяться. Причина этого в том, что используя const вы даете понять себе и будущим разработчикам, которые должны прочитать ваш код, что эта переменная не должна изменяться. Если её потребуется изменить (например в цикле for), просто используйте let.
Между переменными, которые меняются и переменным которые не меняются, не так уж и много случаев осталось. Это значит, что вам больше никогда не придется использовать var.
Теперь непопулярное мнение, хотя оно все ещё имеет обоснование, это то что вы никогда не должны использовать const, несмотря на то что вы пытаетесь показать, что эта переменная неизменна, как мы видели выше, это не совсем так. Разработчики, которые придерживаются этого мнения всегда используют let пока нет переменных, которые на самом деле являются константами, такими как _LOCATION_ =….
Составим резюме выше сказанного, var ограничена областью видимости функции и если вы попытаетесь обратиться к такой переменной до её объявления вы получите undefined. const и let ограничены областью видимости блока и если вы попытаетесь обратиться к этим переменным до их объявления вы получите ReferenceError. И отличие между const и let это то, что значение, которое было присвоено const не может быть перезаписано, в отличие от let.
Первоначально данная статья была опубликована на tylermcginnis.com как часть курса Modern JavaScript
Спасибо за прочтение данного перевода, надеюсь вы познакомились для себя с чем-то новым и полезным. Буду рад увидеть обратную связь!
Переменные
JavaScript-приложению обычно нужно работать с информацией. Например:
Переменные используются для хранения этой информации.
Переменная
Переменная – это «именованное хранилище» для данных. Мы можем использовать переменные для хранения товаров, посетителей и других данных.
Приведённая ниже инструкция создаёт (другими словами: объявляет или определяет) переменную с именем «message»:
Теперь можно поместить в неё данные, используя оператор присваивания = :
Строка сохраняется в области памяти, связанной с переменной. Мы можем получить к ней доступ, используя имя переменной:
Для краткости можно совместить объявление переменной и запись данных в одну строку:
Мы также можем объявить несколько переменных в одной строке:
Такой способ может показаться короче, но мы не рекомендуем его. Для лучшей читаемости объявляйте каждую переменную на новой строке.
Многострочный вариант немного длиннее, но легче для чтения:
Некоторые люди также определяют несколько переменных в таком вот многострочном стиле:
…Или даже с запятой в начале строки:
В принципе, все эти варианты работают одинаково. Так что это вопрос личного вкуса и эстетики.
В старых скриптах вы также можете найти другое ключевое слово: var вместо let :
Аналогия из жизни
Мы легко поймём концепцию «переменной», если представим её в виде «коробки» для данных с уникальным названием на ней.
Например, переменную message можно представить как коробку с названием «message» и значением «Hello!» внутри:
Мы можем положить любое значение в коробку.
Мы также можем изменить его столько раз, сколько захотим:
При изменении значения старые данные удаляются из переменной:
Мы также можем объявить две переменные и скопировать данные из одной в другую.
Переменная может быть объявлена только один раз.
Повторное объявление той же переменной является ошибкой:
Примечательно, что существуют функциональные языки программирования, такие как Scala или Erlang, которые запрещают изменять значение переменной.
В таких языках однажды сохранённое «в коробку» значение остаётся там навсегда. Если нам нужно сохранить что-то другое, язык заставляет нас создать новую коробку (объявить новую переменную). Мы не можем использовать старую переменную.
Хотя на первый взгляд это может показаться немного странным, эти языки вполне подходят для серьёзной разработки. Более того, есть такая область, как параллельные вычисления, где это ограничение даёт определённые преимущества. Изучение такого языка (даже если вы не планируете использовать его в ближайшее время) рекомендуется для расширения кругозора.
Имена переменных
В JavaScript есть два ограничения, касающиеся имён переменных:
Примеры допустимых имён:
Самое интересное – знак доллара ‘$’ и подчёркивание ‘_’ также можно использовать в названиях. Это обычные символы, как и буквы, без какого-либо особого значения.
Эти имена являются допустимыми:
Примеры неправильных имён переменных:
Переменные с именами apple и AppLE – это две разные переменные.
Можно использовать любой язык, включая кириллицу или даже иероглифы, например:
Технически здесь нет ошибки, такие имена разрешены, но есть международная традиция использовать английский язык в именах переменных. Даже если мы пишем небольшой скрипт, у него может быть долгая жизнь впереди. Людям из других стран, возможно, придётся прочесть его не один раз.
Существует список зарезервированных слов, которые нельзя использовать в качестве имён переменных, потому что они используются самим языком.
Приведённый ниже код даёт синтаксическую ошибку:
Это плохая практика, которая приводит к ошибке в строгом режиме:
Константы
Чтобы объявить константную, то есть, неизменяемую переменную, используйте const вместо let :
Константы в верхнем регистре
Широко распространена практика использования констант в качестве псевдонимов для трудно запоминаемых значений, которые известны до начала исполнения скрипта.
Названия таких констант пишутся с использованием заглавных букв и подчёркивания.
Например, сделаем константы для различных цветов в «шестнадцатеричном формате»:
Когда мы должны использовать для констант заглавные буквы, а когда называть их нормально? Давайте разберёмся и с этим.
Название «константа» просто означает, что значение переменной никогда не меняется. Но есть константы, которые известны до выполнения (например, шестнадцатеричное значение для красного цвета), а есть константы, которые вычисляются во время выполнения сценария, но не изменяются после их первоначального назначения.
Значение pageLoadTime неизвестно до загрузки страницы, поэтому её имя записано обычными, а не прописными буквами. Но это всё ещё константа, потому что она не изменяется после назначения.
Другими словами, константы с именами, записанными заглавными буквами, используются только как псевдонимы для «жёстко закодированных» значений.
Придумывайте правильные имена
В разговоре о переменных необходимо упомянуть, что есть ещё одна чрезвычайно важная вещь.
Название переменной должно иметь ясный и понятный смысл, говорить о том, какие данные в ней хранятся.
Именование переменных – это один из самых важных и сложных навыков в программировании. Быстрый взгляд на имена переменных может показать, какой код был написан новичком, а какой – опытным разработчиком.
В реальном проекте большая часть времени тратится на изменение и расширение существующей кодовой базы, а не на написание чего-то совершенно нового с нуля. Когда мы возвращаемся к коду после какого-то промежутка времени, гораздо легче найти информацию, которая хорошо размечена. Или, другими словами, когда переменные имеют хорошие имена.
Пожалуйста, потратьте время на обдумывание правильного имени переменной перед её объявлением. Делайте так, и будете вознаграждены.
Несколько хороших правил:
Звучит просто? Действительно, это так, но на практике для создания описательных и кратких имён переменных зачастую требуется подумать. Действуйте.
И последняя заметка. Есть ленивые программисты, которые вместо объявления новых переменных повторно используют существующие.
В результате их переменные похожи на коробки, в которые люди бросают разные предметы, не меняя на них этикетки. Что сейчас находится внутри коробки? Кто знает? Нам необходимо подойти поближе и проверить.
Такие программисты немного экономят на объявлении переменных, но теряют в десять раз больше при отладке.
Дополнительная переменная – это добро, а не зло.
Современные JavaScript-минификаторы и браузеры оптимизируют код достаточно хорошо, поэтому он не создаёт проблем с производительностью. Использование разных переменных для разных значений может даже помочь движку оптимизировать ваш код.
Итого
Переменные должны быть названы таким образом, чтобы мы могли легко понять, что у них внутри.
Константы в JavaScript
Дата публикации: 2015-07-07
От автора: Пожалуй, это будет удивительным, но в JavaScript давно не хватало поддержки констант, т.е. зарегистрированных значений, которые не меняются в процессе выполнения всего вашего скрипта. За неимением каких-либо альтернатив, большинство констант объявлялось с помощью переменных.
Пример объявления константы с помощью переменной:
Это и опасно, и непрактично, поскольку позволяет в любой момент изменить значение переменной DAYSINWEEK в вашем скрипте. Разработчики придумали разнообразные способы, как выделить переменные, являющиеся, как бы, константами, от обычных переменных в JavaScript, начиная от именования переменных ТОЛЬКО ЗАГЛАВНЫМИ БУКВАМИ (лучшая традиция) и заканчивая решениями, о которых я расскажу позже. К счастью, в последней версии ECMAScript (спецификация, являющаяся стандартом) была представлена настоящая константа:
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
И вот теперь к DAYSINWEEK можно обращаться, как к переменной, но вам никогда не удастся изменить ее значение:
После того, как константа была объявлена (константы должны быть инициализированы с помощью ключевого слова const, а за ним должно идти имя константы, которое следует правилам именования переменных), ее имя будет зарезервировано: вы уже не сможете назвать переменную DAYSINWEEK и иметь константу с таким же именем, или наоборот.
Ключевое слово const имеет хорошую поддержку в современных браузерах: IE11 и Spartan, Firefox 31+, Opera 12+, Safari 5.1.7+, iOS 7 и выше, вместе с Chrome 36+. Однако, есть несколько важных оговорок:
В Chrome не поддерживается вывод ошибки при попытке перезаписать константу. Значение константы в любом случае не будет изменено, но неопытный разработчик может подумать, что новое значение было применено, поскольку не было выведено никакой ошибки.
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Константы не создают новую область видимости в Webkit. Т.е. константы могут быть видимыми за пределами текущей области видимости.
Firefox 35 и ниже позволяет вам «на лету» изменить значение const. Это исправлено в версии Firefox 36+.
Также следует отметить, что проблемы с Webkit возникают, только если не используется режим strict (о котором пойдет речь в одной из следующих статей).
Можно ли сейчас использовать ключевое слово const в реальных проектах?
Выбор, использовать ли ключевое слово const в вашем коде или нет, будет зависеть от нескольких факторов: важнее всего то, какими версиями браузеров пользуются посетители ваших сайтов, поскольку использование ключевого слова const будет считаться ошибкой в таких браузерах, как IE10. Если вы хотите использовать ключевое слово const в процессе разработки, но не готовы применять его в реальных проектах, то у вас есть несколько вариантов:
Вариант 1: использовать транспилер («транспилятор»)
Транспилеры (transpilers), как следует из названия, трансформируют ваш код во время его компиляции в другой язык: в данном случае из версии спецификации ES6 (в которой появилось ключевое слово const) в ES5. Это позволяет вам писать код на более новой версии языка, но в реальном проекте будет использоваться версия, которая совместима с более широким кругом браузеров. Эдди Озмани (Addy Osmani) составил замечательный список ECMAScript транспилеров.
Вариант 2: Определение константы в качестве свойства объекта
Это сделает значение доступным «только для чтения» (read-only), хотя этот вариант является не самым изящным: