ES6, который действительно нужен: let, const, arrow functions и шаблонные строки
Текст написан с позиции апреля 2015 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Вокруг ES6 уже накопилось достаточно шума, чтобы у многих разработчиков появилась вполне понятная реакция: «опять новый JavaScript, опять всё переучивать, опять конференции, статьи и восторги про будущее». И в этом скепсисе нет ничего удивительного. Фронтенд и без того живёт в режиме постоянного движения, где вчерашние практики ещё не успели устареть, а новые уже подаются как обязательные. На таком фоне разговоры про ES6 легко воспринимаются как ещё одна волна моды, которая звучит громче, чем реально помогает в повседневной работе.
Но если отодвинуть в сторону общий шум, становится видно важное: не весь ES6 одинаково нужен прямо сейчас, и не все его возможности одинаково полезны для реального кода. Это, пожалуй, главное, что стоит себе объяснить заранее. Не нужно пытаться проглотить весь новый стандарт целиком, запомнить каждую новую конструкцию и срочно переписать полпроекта только потому, что язык вот-вот получит большое обновление. Намного разумнее посмотреть на те части ES6, которые действительно меняют повседневный JavaScript уже сегодня. И если выбирать самый практический набор, то в первую очередь речь идёт о let, const, arrow functions и шаблонных строках.
Почему именно они? Потому что это не экзотика, не синтаксические украшения ради красоты и не возможности, которые пригодятся только в специально устроенных архитектурах. Это инструменты, которые влияют на обычный код буквально каждый день: на объявление переменных, на написание функций, на работу с контекстом и на сборку строк. То есть на те места, где JavaScript-разработчик проводит огромное количество времени. Именно поэтому освоение этих возможностей даёт не ощущение «я прикоснулся к будущему», а гораздо более полезное чувство: код становится чище, предсказуемее и менее раздражающим.
Зафиксируем сразу важную мысль, к которой мы ещё вернёмся: ценность этого набора не в новизне как таковой, а в том, что он убирает целый класс старых бытовых неудобств. Это не революция, а взросление языка на уровне самой базовой выразительности. И смотреть на него лучше именно с этой стороны.
Не «ещё один способ объявить переменную», а исправление старого поведения var
Начать стоит с let. На первый взгляд может показаться, что это просто ещё один способ объявлять переменные, не более. И вот тут многие совершают типичную ошибку: воспринимают let как косметическую замену var. Мол, можно объявлять так, можно иначе, какая разница. На деле разница есть, и она не декоративная. JavaScript слишком долго жил с особенностями var, к которым все вроде привыкли, но которые постоянно становились источником путаницы. Поднятие объявлений, отсутствие блочной области видимости, странные ситуации в циклах и замыканиях — всё это давно воспринималось как «ну да, такая специфика языка». Привыкнуть можно, но это не значит, что так удобно.
Именно здесь let ощущается как давно назревшее улучшение. Его главная практическая сила в том, что он ведёт себя ближе к тому, как большинство разработчиков и так интуитивно думают о переменных внутри блока. Если переменная объявлена в условии, цикле или отдельном блоке, хочется верить, что она там же и живёт, а не протекает наружу по правилам, которые надо держать в голове отдельно. let делает эту интуицию более честной. Он не избавляет код от необходимости думать, но убирает целый класс случайных проблем, которые раньше рождались не из-за сложности задачи, а из-за старых особенностей самого синтаксиса.
Особенно заметна польза let в циклах и замыканиях. Сколько уже было ситуаций, когда код выглядит почти правильно, но из-за поведения var внутри цикла результат оказывается не тем, которого ожидал разработчик. Приходилось городить дополнительные функции, обёртки и обходные трюки только для того, чтобы переменная жила в нужной области видимости. Такие решения давно стали привычными, но именно это и плохо: язык заставлял тратить умственные усилия не на задачу, а на борьбу с собственными историческими особенностями. let не делает JavaScript волшебно простым, зато избавляет от части этих искусственных препятствий.
const — это не запрет, а способ выразить намерение
Сразу рядом с let идёт const, и вот вокруг него путаницы ещё больше. Частая реакция выглядит так: «то есть это как константа, которую нельзя менять? А что делать, если значение всё-таки должно меняться?» Этот вопрос снова показывает, что разработчики часто смотрят на новую конструкцию как на неудобное ограничение, а не как на средство яснее выразить намерение. const полезен не потому, что он запрещает что-то ради дисциплины как таковой, а потому, что позволяет коду говорить честнее. Если переменная не должна быть переназначена, лучше прямо об этом сообщить. Это не занудство, а способ уменьшить количество случайных изменений и сделать намерения автора видимыми без комментариев.
В реальной работе const помогает даже сильнее, чем может показаться. В JavaScript слишком легко переиспользовать переменную, изменить её значение позже по ходу функции, потерять исходный смысл и получить код, где одно и то же имя начинает значить разные вещи в разных местах. Когда же значение изначально объявлено через const, у читателя кода появляется очень важная гарантия: ссылка не будет переназначена. Это снижает когнитивную нагрузку. Не нужно постоянно держать в голове вопрос, не поменялось ли это значение где-то ниже. И даже если речь идёт не о глубокой архитектуре, а о простой функции или обработчике, такая ясность очень помогает.
Здесь важно не свалиться в другую крайность. Вокруг const уже хватает недоразумений. Например, не все сразу понимают, что он не делает объект полностью неизменяемым, а лишь запрещает переназначение самой переменной. Из-за этого возникают как завышенные ожидания, так и преждевременное разочарование. Но даже с этой оговоркой const остаётся очень полезной практической вещью. Он дисциплинирует не ценой тяжеловесности, а ценой одного честного вопроса: действительно ли это значение должно меняться? И во множестве случаев ответ оказывается отрицательным.
Вообще, связка let и const — это, пожалуй, один из самых заметных признаков того, что JavaScript взрослеет не только большими идеями, но и на уровне базовой повседневной выразительности. Раньше разработчик был вынужден использовать var почти для всего, а дальше уже самостоятельно помнить, где ему нужна осторожность, где стоит мысленно считать переменную блочной, а где не стоит. Теперь язык начинает лучше поддерживать саму идею намерения в коде. Это важнее, чем кажется, потому что хороший код — это не только работающий код, но и код, который легче читать, обсуждать и поддерживать.
Главная ценность arrow functions — не краткость, а лексический this
Теперь перейдём к arrow functions. Наверное, это одна из самых заметных новинок ES6 хотя бы потому, что она сразу бросается в глаза. Новый синтаксис короткий, непривычный, местами даже выглядит как не-JavaScript для тех, кто долго писал на классическом function. Из-за этого вокруг стрелочных функций быстро сложились два лагеря. Одни воспринимают их как удобный и современный способ писать функции короче. Другие раздражаются и считают, что это просто синтаксический трюк ради модности. Но если смотреть на них практично, то стрелочные функции полезны не только краткостью.
Да, лаконичность важна. Когда код часто использует небольшие колбэки, функции для map, filter, обработчики или локальные преобразования, возможность записывать их компактнее действительно делает код легче для чтения. Особенно там, где раньше приходилось ради простой операции писать многословную конструкцию с function, return и фигурными скобками. Arrow functions убирают часть визуального шума, и это уже немало. Но ещё важнее другое: у стрелочных функций иной характер работы с this, и именно здесь лежит их настоящая практическая сила.
Контекст this — одна из тех тем JavaScript, о которые разработчики спотыкаются снова и снова. Особенно неприятно это проявляется в колбэках, методах, обработчиках и вложенных функциях, где контекст внезапно перестаёт быть тем, на который рассчитывали. Отсюда весь этот привычный набор приёмов: var self = this, bind, ручные обходы и постоянная осторожность. Для опытного разработчика такие вещи давно стали частью ремесла, но это не значит, что они удобны. Это значит лишь, что с ними научились жить.
Стрелочные функции интересны тем, что снимают часть этой боли естественным образом. У них нет собственного this в том же смысле, в каком он есть у обычной функции; они лексически захватывают контекст окружающего кода. Для повседневной разработки это означает очень важное облегчение: во многих случаях можно перестать писать дополнительные трюки только ради сохранения правильного this. Особенно в React-коде, колбэках и небольших функциональных преобразованиях это ощущается как серьёзное улучшение. Не потому, что разработчик внезапно перестал понимать this, а потому, что язык наконец перестаёт подбрасывать ловушки там, где можно было обойтись без них.
Где обычная function всё ещё уместнее стрелочной
И тут важно не перепутать удобный инструмент с универсальным правилом. Не каждая функция обязана стать стрелочной. Есть случаи, где обычная function по-прежнему уместна и нужна, особенно если важен собственный контекст вызова или поведение, привязанное к более традиционной модели функций. Методы объектов, где this должен указывать на сам объект, или функции, которым нужен доступ к arguments, — это как раз те места, где стрелочная запись скорее навредит, чем поможет.
Но именно в качестве повседневного инструмента для небольших функций и колбэков arrow functions выглядят очень убедительно. Они сокращают код, уменьшают шум и делают часть распространённых сценариев заметно менее болезненными. Ценность здесь не в том, чтобы заменить весь синтаксис функций разом, а в том, чтобы получить лёгкий и предсказуемый способ для тех ситуаций, где он действительно к месту.
Шаблонные строки убирают мелкую, но постоянную боль конкатенации
Наконец, шаблонные строки — вещь, которая может показаться мелочью, пока не посмотришь на количество кода, где они реально экономят силы. На фоне крупных разговоров об архитектуре, модулях и новых способах организации приложений работа со строками кажется почти слишком скромной темой. Но в JavaScript именно из таких «мелочей» часто и складывается общий уровень раздражения. Сколько раз приходилось собирать строки через плюс, следить за кавычками, пробелами, переносами, подстановкой переменных, экранированием и читабельностью длинного выражения? Это никогда не было самой большой проблемой языка, но почти всегда оставалось одним из самых неприятных бытовых неудобств.
Шаблонные строки хороши именно тем, что убирают эту мелкую, но постоянную боль. Возможность вставлять значения прямо внутрь строки делает код не только короче, но и понятнее. Вместо цепочки конкатенаций получается запись, гораздо более близкая к тому, как разработчик думает о конечном результате. Это особенно удобно в сообщениях, генерации HTML-фрагментов, логировании, построении URL и вообще в любом коде, где строка должна зависеть от нескольких переменных сразу. Там, где раньше выражение приходилось читать как набор склеек, теперь оно читается как цельная строка с понятными вставками.
Ещё одно достоинство шаблонных строк — многострочность. Это не выглядит революцией мирового масштаба, но для повседневной работы штука очень приятная. Там, где раньше приходилось либо склеивать строки вручную, либо придумывать менее удобные формы записи, теперь можно сохранить структуру текста намного естественнее. Особенно это заметно в шаблонах, сообщениях об ошибках, кусках разметки и другом коде, где читаемость текста сама по себе важна.
Почему этот набор ценен раньше остального ES6
Тут стоит приземлить тему до конкретики. ES6 — это не только набор будущих возможностей, но и момент, когда JavaScript начинает заметно улучшаться в своём повседневном лице. Да, вокруг нового стандарта уже много разговоров о классах, модулях, деструктуризации, генераторах, промисах и других вещах, и у каждой из них есть своё место. Но let, const, arrow functions и шаблонные строки важны по-своему: они не требуют ждать особого архитектурного повода. Они начинают помогать там, где код пишется прямо сегодня.
При этом стоит сохранять здравый взгляд. Внедрение ES6 — это пока ещё не история «написал и забыл». Поддержка в средах выполнения всё ещё неравномерна, вокруг транспиляции и инструментов идёт активное движение, многие команды только присматриваются к новому синтаксису и решают, насколько рано его брать в работу. Это значит, что разговор об ES6 неизбежно связан не только с языком как таковым, но и с практикой сборки проекта: без транспилятора часть синтаксиса просто не запустится в браузерах, которые сейчас стоят у пользователей. И именно поэтому особенно важно не пытаться внедрять всё подряд ради моды. Если уж входить в ES6, то лучше начинать с того, что приносит немедленную и понятную пользу.
А польза здесь действительно немедленная. let и const делают объявление переменных честнее и безопаснее. Arrow functions делают небольшой функциональный код легче и убирают часть старой боли вокруг this. Шаблонные строки делают работу со строками чище и понятнее. Все эти возможности не требуют менять философию проекта целиком, но ощутимо улучшают качество повседневного JavaScript. Это редкий случай, когда новизна приходит не ради лозунгов, а ради удобства.
Ещё один важный момент: эти возможности хорошо работают вместе как сигнал общего сдвига. JavaScript постепенно уходит от образа языка, в котором разработчик вынужден постоянно помнить об исторических странностях и обходных трюках, и движется к более выразительному, предсказуемому стилю. Не идеальному, конечно, и не лишённому старых особенностей, но гораздо более пригодному для большого и долгоживущего кода. Именно поэтому интерес к ES6 — это не просто охота за новым синтаксисом, а реакция на реальную потребность писать на JavaScript менее утомительно.
Итог
Самая вредная реакция на разговоры про ES6 — услышать «выходит большой новый стандарт» и решить, что теперь надо срочно переписывать проект на всё сразу. Гораздо разумнее зайти с другого конца. Не пытайтесь полюбить ES6 целиком; возьмите те части, которые уже сегодня делают код лучше без лишней драмы. Если в проекте появятся let и const, станет меньше случайной путаницы с переменными. Если начнёте осознанно использовать arrow functions, уменьшится часть шума и боли вокруг колбэков. Если перейдёте на шаблонные строки, многие повседневные выражения станут просто приятнее для чтения. А дальше уже можно спокойно разбираться, что ещё из ES6 действительно нужно именно вашему коду, а что пока можно оставить в стороне.
Хороший переход на новый JavaScript — это не момент, когда команда восхищённо кричит «теперь у нас всё на ES6». Это момент, когда код становится понятнее, а разработчики тратят меньше сил на борьбу с языком и больше — на решение задачи.
Если сформулировать совсем прямо: не учите ES6 как новый язык — внедрите let, const, arrow functions и шаблонные строки как четыре повседневных инструмента, которые окупаются сразу и без архитектурного повода, а всё остальное берите по мере реальной потребности.