что такое литерал в javascript
Основы языка JavaScript.
Лексемы
Лексемы (tokens) — это наименьшие отдельные слова, фразы, символы, которые может распознать JavaScript. Во время интерпретации JavaScript-кода браузер разбивает сценарии на лексемы, игнорируя при этом комментарии и лишние пробелы. Лексемы подразделяются на четыре категории: идентификаторы, ключевые слова, литералы и операторы. Как и в любом компьютерном языке, существует множество способов подачи компьютеру различных директив за счет различной компоновки лексем. Синтаксис (syntax) языка — это набор правил и ограничений, используемый при комбинировании лексем.
Идентификаторы
Идентификаторы (identifiers) — суть ни что иное как имена переменных, методов и объектов. Они состоят из комбинации букв и цифр. Некоторые имена уже встроены в язык JavaScript и поэтому зарезервированы от использования. Независимо от ключевых слов, можно определять собственные, притом значащие идентификаторы. Разумеется, для этого существует несколько правил:
Ключевые слова и зарезервированные слова
Ключевые слова (keywords) — предварительно определенные идентификаторы, составляющие ядро языка программирования. В JavaScript они выполняют особые функции, например, объявление новых переменных, функций, принятие решений на основе текущего состояния компьютера или организация цикла внутри приложения.
Зарезервированные слова (reserved words) — это идентификаторы, которые не могут использоваться в качестве имен переменных, функций, объектов и методов как сейчас, так и в будущем.
Литералы
Литералы (literals) — это числа или строки, представляющие постоянные значения JavaScript. Это значения, которые не изменяются во время выполнения сценария.
Целочисленные литералы
Целочисленные литералы могут быть представлены в десятичном (десятичная система счисления), восьмеричном (восьмеричная система счисления) или шестнадцатеричном (шестнадцатеричная система счисления) формате. Целочисленный литерал в десятичном формате может содержать любую последовательность цифр, но не начинаться с 0. Ноль в начале целочисленного литерала определяет восьмеричный формат. В восьмеричной записи целочисленный литерал может включать последовательность цифр от 0 до 7. Для определения шестнадцатеричного формата числа перед литералом должно ставится Ох или ОХ. Шестнадцатеричные целочисленные литералы могут содержать цифры от 0 до 9 и буквы а — f или А — F. Рассмотрим несколько примеров:
Литералы с плавающей точкой
Литералы с плавающей точкой представляют десятичные числа с дробной частью. Их можно выражать в стандартном и экспоненциальном форматах. Экспоненциальный формат подразумевает использование е или Е для определения порядка числа. И десятеричное число, и показатель степени могут быть со знаком или без знаковыми (положительные и отрицательные):
Логические литералы
В JavaScript реализован логический тип данных, поэтому поддерживаются два литерала true и false, представляющие соответственно значения логической 1 и 0. Если вы новичок в области программирования, не отчаивайтесь — очень скоро вы поймете всю важность true и false. Ключевые слова true и false должны записываться строчными буквами. Таким образом, TRUE и FALSE прописными буквами остаются доступными для применения в качестве собственных идентификаторов. Однако, во избежание недоразумений, использовать их в таком контексте не рекомендуется.
Строковые литералы
Строковый литерал — это ноль и более символов, заключенных в двойные (“”) или одиночные (“) кавычки. Несмотря на то что JavaScript разрешает использовать оба типа кавычек, для строки лучше применять один и тот же тип кавычек как в начале, так и в конце. Рассмотрим примеры строковых литералов:
Операции
Операции (operators) — это символы или идентификаторы, которые представляют способ оценки или манипуляции комбинациями выражений. Наиболее используемой общей операцией является далеко не операция присваивания. В примере х=10 как собственно 10, так и переменная х — это выражения. Когда JavaScript встречает операцию присваивания между двумя выражениями, выполняются действия в соответствие с правилами оператора присваивания. В рассматриваемом случае значение выражения в правой части присваивается переменной в левой части. Наряду с арифметическими, JavaScript поддерживает 30 других операций.
Объекты
Как мы знаем из главы Типы данных, в JavaScript существует 8 типов данных. Семь из них называются «примитивными», так как содержат только одно значение (будь то строка, число или что-то другое).
Объекты же используются для хранения коллекций различных значений и более сложных сущностей. В JavaScript объекты используются очень часто, это одна из основ языка. Поэтому мы должны понять их, прежде чем углубляться куда-либо ещё.
Объект может быть создан с помощью фигурных скобок <…>с необязательным списком свойств. Свойство – это пара «ключ: значение», где ключ – это строка (также называемая «именем свойства»), а значение может быть чем угодно.
Мы можем представить объект в виде ящика с подписанными папками. Каждый элемент данных хранится в своей папке, на которой написан ключ. По ключу папку легко найти, удалить или добавить в неё что-либо.
Пустой объект («пустой ящик») можно создать, используя один из двух вариантов синтаксиса:
Обычно используют вариант с фигурными скобками <. >. Такое объявление называют литералом объекта или литеральной нотацией.
Литералы и свойства
При использовании литерального синтаксиса <. >мы сразу можем поместить в объект несколько свойств в виде пар «ключ: значение»:
В объекте user сейчас находятся два свойства:
Можно сказать, что наш объект user – это ящик с двумя папками, подписанными «name» и «age».
Мы можем в любой момент добавить в него новые папки, удалить папки или прочитать содержимое любой папки.
Для обращения к свойствам используется запись «через точку»:
Значение может быть любого типа. Давайте добавим свойство с логическим значением:
Для удаления свойства мы можем использовать оператор delete :
Имя свойства может состоять из нескольких слов, но тогда оно должно быть заключено в кавычки:
Последнее свойство объекта может заканчиваться запятой:
Это называется «висячая запятая». Такой подход упрощает добавление, удаление и перемещение свойств, так как все строки объекта становятся одинаковыми.
Есть ещё один способ сделать константами свойства объекта, который мы рассмотрим в главе Флаги и дескрипторы свойств.
Квадратные скобки
Для свойств, имена которых состоят из нескольких слов, доступ к значению «через точку» не работает:
Для таких случаев существует альтернативный способ доступа к свойствам через квадратные скобки. Такой способ сработает с любым именем свойства:
Сейчас всё в порядке. Обратите внимание, что строка в квадратных скобках заключена в кавычки (подойдёт любой тип кавычек).
Квадратные скобки также позволяют обратиться к свойству, имя которого может быть результатом выражения. Например, имя свойства может храниться в переменной:
Здесь переменная key может быть вычислена во время выполнения кода или зависеть от пользовательского ввода. После этого мы используем её для доступа к свойству. Это даёт нам большую гибкость.
Запись «через точку» такого не позволяет:
Вычисляемые свойства
Мы можем использовать квадратные скобки в литеральной нотации для создания вычисляемого свойства.
По сути, пример выше работает так же, как и следующий пример:
…Но первый пример выглядит лаконичнее.
Мы можем использовать и более сложные выражения в квадратных скобках:
Квадратные скобки дают намного больше возможностей, чем запись через точку. Они позволяют использовать любые имена свойств и переменные, хотя и требуют более громоздких конструкций кода.
Подведём итог: в большинстве случаев, когда имена свойств известны и просты, используется запись через точку. Если же нам нужно что-то более сложное, то мы используем квадратные скобки.
Свойство из переменной
В реальном коде часто нам необходимо использовать существующие переменные как значения для свойств с тем же именем.
В примере выше название свойств name и age совпадают с названиями переменных, которые мы подставляем в качестве значений этих свойств. Такой подход настолько распространён, что существуют специальные короткие свойства для упрощения этой записи.
Вместо name:name мы можем написать просто name :
Мы можем использовать как обычные свойства, так и короткие в одном и том же объекте:
Ограничения на имена свойств
Как мы уже знаем, имя переменной не может совпадать с зарезервированными словами, такими как «for», «let», «return» и т.д.
Но для свойств объекта такого ограничения нет:
Иными словами, нет никаких ограничений к именам свойств. Они могут быть в виде строк или символов (специальный тип для идентификаторов, который будет рассмотрен позже).
Все другие типы данных будут автоматически преобразованы к строке.
Например, если использовать число 0 в качестве ключа, то оно превратится в строку «0» :
Как мы видим, присвоение примитивного значения 5 игнорируется.
Мы более подробно исследуем особенности свойства __proto__ в следующих главах Прототипное наследование, а также предложим способы исправления такого поведения.
Проверка существования свойства, оператор «in»
В отличие от многих других языков, особенность JavaScript-объектов в том, что можно получить доступ к любому свойству. Даже если свойства не существует – ошибки не будет!
Также существует специальный оператор «in» для проверки существования свойства в объекте.
Обратите внимание, что слева от оператора in должно быть имя свойства. Обычно это строка в кавычках.
Если мы опускаем кавычки, это значит, что мы указываем переменную, в которой находится имя свойства. Например:
Это когда свойство существует, но содержит значение undefined :
В примере выше свойство obj.test технически существует в объекте. Оператор in сработал правильно.
Цикл «for…in»
К примеру, давайте выведем все свойства объекта user :
Обратите внимание, что все конструкции «for» позволяют нам объявлять переменную внутри цикла, как, например, let key здесь.
Упорядочение свойств объекта
Упорядочены ли свойства объекта? Другими словами, если мы будем в цикле перебирать все свойства объекта, получим ли мы их в том же порядке, в котором мы их добавляли? Можем ли мы на это рассчитывать?
Короткий ответ: свойства упорядочены особым образом: свойства с целочисленными ключами сортируются по возрастанию, остальные располагаются в порядке создания. Разберёмся подробнее.
В качестве примера рассмотрим объект с телефонными кодами:
Если мы делаем сайт для немецкой аудитории, то, вероятно, мы хотим, чтобы код 49 был первым.
Но если мы запустим код, мы увидим совершенно другую картину:
Термин «целочисленное свойство» означает строку, которая может быть преобразована в целое число и обратно без изменений.
То есть, «49» – это целочисленное имя свойства, потому что если его преобразовать в целое число, а затем обратно в строку, то оно не изменится. А вот свойства «+49» или «1.2» таковыми не являются:
…С другой стороны, если ключи не целочисленные, то они перебираются в порядке создания, например:
Таким образом, чтобы решить нашу проблему с телефонными кодами, мы можем схитрить, сделав коды не целочисленными свойствами. Добавления знака «+» перед каждым кодом будет достаточно.
Теперь код работает так, как мы задумывали.
Итого
Объекты – это ассоциативные массивы с рядом дополнительных возможностей.
Они хранят свойства (пары ключ-значение), где:
Чтобы получить доступ к свойству, мы можем использовать:
В JavaScript есть много других типов объектов:
Объекты в JavaScript очень мощные. Здесь мы только немного углубились в действительно огромную тему. Мы будем плотно работать с объектами и узнаем о них больше в следующих частях учебника.
Задачи
Привет, object
Напишите код, выполнив задание из каждого пункта отдельной строкой:
Грамматика и типы
В данной главе рассматриваются базовая грамматика, объявление переменных, типы данных и литералы.
Основы
JavaScript заимствует большую часть синтаксиса из Java, но также испытал влияние таких языков, как Awk, Perl и Python.
JavaScript чувствителен к регистру и использует кодировку символов Unicode. Например, слово Früh («рано» по-немецки) может использоваться в качестве имени переменной.
Но, переменная früh не то же самое что Früh потому что JavaScript чувствителен к регистру.
В JavaScript инструкции называются statements и разделяются точкой с запятой (;). Пробел (space), табуляция (tab) и перевод строки (newline) называются пробельными символами (whitespace). Исходный текст скриптов на JavaScript сканируется слева направо и конвертируется в последовательность входных элементов, являющихся токенами (tokens), управляющими символами, символами конца строки, комментариями или пробельными символами. ECMAScript также определяет некоторые ключевые слова и литералы и устанавливает правила для автоматической вставки точек с запятой (ASI), чтобы обозначить конец инструкций (statements). Однако, рекомендуется всегда ставить точку с запятой в конце каждой инструкции вручную, чтобы избежать побочных эффектов. Чтобы получить более подробную информацию, прочитайте Lexical Grammar.
Комментарии
Синтаксис комментариев является таким же, как и в C++ и во многих других языках:
Объявления
В JavaScript существует три вида объявлений:
var Объявляет переменную, инициализация переменной значением является необязательной. let Объявляет локальную переменную в области видимости блока, инициализация переменной значением является необязательной. const Объявляет именованную константу, доступную только для чтения.
Переменные
Вы можете использовать переменные как символические имена для значений в вашем приложении. Имена переменных называются identifiers и должны соответствовать определённым правилам.
Идентификатор в JavaScript должен начинаться с буквы, нижнего подчёркивания (_) или знака доллара ($); последующие символы могут также быть цифрами (0-9). Поскольку JavaScript чувствителен к регистру, буквы включают символы от «A» до «Z» (верхний регистр) и символы от «a» до «z» (нижний регистр).
Вы можете использовать в идентификаторах буквы ISO 8859-1 или Unicode, например, å или ü. Вы также можете использовать управляющие последовательности Unicode как символы в идентификаторах.
Объявление переменных
Вы можете объявить переменную тремя способами:
Присваивание значений
При попытке доступа к необъявленной переменной или переменной до её объявления будет выброшено исключение ReferenceError :
Значение null ведёт себя как 0 в числовом контексте и как false в логическом контексте:
Область видимости переменных
Когда вы объявляете переменную вне функции, то такая переменная называется глобальной переменной, т.к. доступна любому коду в текущем документе. Когда вы объявляете переменную внутри функции, то такая переменная называется локальной переменной, т.к. доступна только внутри данной функции.
Поднятие переменных
Другим необычным свойством переменных в JavaScript является то, что можно сослаться на переменную, которая объявляется позже, и не получить при этом исключения. Эта концепция известна как поднятие (hoisting) переменных; переменные в JavaScript поднимаются в самое начало функции или выражения. Однако, переменные, которые ещё не были инициализированы, возвратят значение undefined :
Приведённые выше примеры будут интерпретироваться так же, как:
Из-за поднятия переменных, все операторы var в функции следует размещать настолько близко к началу функции, насколько это возможно. Следование этому правилу улучшает ясность кода.
Поднятие функций
Для функций: только определения функций поднимаются наверх, но не функции, определённые через выражения.
Глобальные переменные
Константы
Нельзя изменить значение константы через присваивание или повторное объявление во время выполнения скрипта. Значение должно быть указано при инициализации.
Нельзя объявить константу с таким же именем, как у функции или переменной в одной области видимости. Следующие примеры выбросят исключение TypeError :
Однако, атрибуты объектов не защищены, так что следующее выражение выполнится без проблем
Структуры и типы данных
Типы данных
Последний стандарт ECMAScript определяет семь типов данных:
Хотя типов данных относительно немного, но они позволяют вам выполнять полезные функции в ваших приложениях. Объекты и функции являются другими фундаментальными элементами языка. Вы можете думать об объектах как об именованных контейнерах для значений и о функциях как о процедурах, которые ваше приложение может исполнять.
Преобразование типов данных
JavaScript — это динамически типизированный язык. Это означает, что вам не нужно указывать тип данных переменной, когда вы её объявляете, типы данных преобразуются автоматически по мере необходимости во время выполнения скрипта. Так, например, вы можете определить переменную следующим образом:
А позже вы можете присвоить этой переменной строковое значение, например:
Поскольку JavaScript является динамически типизированным, это присваивание не вызовет сообщения об ошибке.
В выражениях с другими операторами JavaScript не преобразует числовые значения в строковые. Например:
Преобразование строк в числа
В том случае, если значение, представляющее число, хранится в памяти как строка, можно использовать методы для преобразования строк в числа:
parseInt преобразует строку в целочисленное значение. Хорошей практикой является всегда указывать основание системы счисления (параметр radix ).
Альтернативным способом для получения числа из строки является использование оператора «унарный плюс»:
Литералы
Литералы используются для представления значений в JavaScript. Они являются фиксированными значениями, а не переменными. В данной секции рассматриваются следующие типы литералов:
Литерал массива
Литерал массива — это список из нуля или более выражений, каждое из которых представляет элемент массива, заключённый в квадратные скобки ( [] ). Когда вы создаёте массив, используя литерал массива, он инициализируется с помощью переданных значений, которые будут являться его элементами, длина массива будет равна числу переданных аргументов.
В следующем примере создаётся массив coffees с тремя элементам и длиной, равной трём:
Замечание : Обратите внимание на то, что литерал массива является инициализатором объекта. Чтобы получить более подробную информацию, прочитайте Использование инициализаторов объекта.
Если массив создаётся с помощью литерала в скрипте верхнего уровня, то JavaScript интерпретирует массив каждый раз, когда вычисляет выражение, содержащее литерал. Кроме того, литерал, используемый в функции, создаётся каждый раз, когда вызывается функция.
Лишние запятые в литералах array
Замечание : Лишние запятые могут вызывать ошибки в старых версиях браузеров, поэтому лучше избегать их использования.
В следующем примере длина массива равна четырём, элементы myList[0] и myList[2] имеют значение undefined :
Понимание поведения лишних запятых важно для понимания JavaScript как языка. Однако, когда будете писать свой собственный код, то имейте в виду, что явное объявление отсутствующих элементов как undefined улучшает ясность кода и лёгкость его поддержки.
Логические литералы
Литерал целого числа
Целые числа могут быть записаны в десятичной, шестнадцатеричной, восьмеричной и двоичной системах счисления.
Несколько примеров целочисленных литералов:
Литерал числа с плавающей точкой
Числа с плавающей точкой могут состоять из следующих частей:
Экспонента состоит из символа «e» или «E», за которым следует целое число, которое может иметь знак. Число с плавающей точкой должно состоять по крайней мере из одной цифры и либо десятичной точки, либо символа «e» (или «E»).
В более сжатой форме синтаксис выглядит следующим образом:
Литерал объекта
Литерал объекта — это список из нуля или более пар, состоящих из имён свойств и связанных с ними значений, заключённый в фигурные скобки ( <> ). Вам не следует использовать литерал объекта в начале выражения, т.к. это приведёт к ошибке или к поведению, которого вы не ожидаете, потому что символ «<" будет интерпретироваться как начало блока.
Кроме того, вы можете использовать числовой или строковой литералы в именах свойств или вкладывать один объект в другой. Например:
Обратите внимание на следующий пример:
RegExp литерал
Строковый литерал
Строковый литерал — это ноль или более символов, заключённых в двойные ( » ) или одинарные ( ‘ ) кавычки. Строка должна быть ограничена кавычками одного типа, т.е. либо обе одинарные, либо обе двойные. Например:
В ES2015 также доступны шаблоны строк. Шаблоны строк представляют собой синтаксический сахар для конструирования строк. Это похоже на возможности интерполяции строк в Perl, Python и других. Дополнительно, может быть добавлен тег, позволяющий настраивать конструирование строк, избегая атак внедрения и построения структур данных высокого уровня из содержимого строки.
Использование специальных символов в строках
Кроме обычных символов вы также можете включать специальные символы в строки.
В следующей таблице перечислены специальные символы, которые вы можете использовать.
| Символ | Значение |
|---|---|
| \b | Возврат (Backspace) |
| \f | Перевод или прогон страницы (Form feed) |
| \n | Перевод строки (New line) |
| \r | Возврат каретки (Carriage return) |
| \t | Табуляция (Tab) |
| \v | Вертикальная табуляция (Vertical tab) |
| \’ | Апостроф или одинарная кавычка |
| \» | Двойная кавычка |
| \\ | Обратная косая черта (Backslash) |
| \XXX | |
| \u | Символ в UTF-32BE. Например, \u <2F804>обозначает то же, что обычная запись \uD87E\uDC04. |
Экранирующие символы
Для символов, не перечисленных в вышеприведённой таблице, предваряющая обратная косая черта игнорируется. Такое использование не является рекомендованным (deprecated) и вам следует избегать его.
Вы можете вставить кавычку в строку, если поставите перед ней обратную косую черту. Это называется экранированием кавычек. Например:
Чтобы включить обратную косую черту в строку, перед ней нужно поставить ещё одну обратную косую черту. Например:
Вы также можете экранировать перевод строки. Обратная косая черта и перевод строки будут удалены из содержимого строки. Например:
Хотя JavaScript не поддерживает синтаксис «heredoc» (форматированный текст в одной строковой переменной), но вы можете эмулировать его, добавив перевод строки и обратную косую черту в конец каждой строки:
Дополнительная информация
Данная глава сфокусирована на базовом синтаксисе для объявлений и типов. Чтобы получить более подробную информацию о конструкциях JavaScript, прочитайте:
В следующей главе рассматриваются управляющие конструкции и обработка ошибок.
Новшества объектных литералов в JavaScript ES6
Материал, перевод которого мы представляем вашему вниманию, посвящён исследованию особенностей объектных литералов в JavaScript, в частности — новшеств, которые появились в свежих версиях стандарта ECMAScript.
JavaScript обладает мощной и удобной возможностью создания объектов с использованием объектных литералов. Стандарт ES2015 (ES6) упрощает работу с объектами при создании приложений для современных браузеров (кроме IE) и для платформы Node.js.
Основы
Создание объектов в некоторых языках может требовать больших затрат ресурсов, под которыми мы имеем в виду и рабочее время программиста, и вычислительные ресурсы систем. В частности, речь идёт о том, что, прежде чем создавать объекты, необходимо описывать классы (скажем, с помощью ключевого слова class ). В JavaScript объекты можно создавать очень быстро и просто, без необходимости выполнения каких-либо предварительных действий. Рассмотрим пример:
В программировании часто используются «одноразовые» объекты. Они хранят настройки и другие данные, они применяются в качестве параметров функций, в качестве значений, возвращаемых функциями, и в других ситуациях. Объектные литералы JavaScript в подобных случаях оказываются очень кстати, а ES6 расширяет их возможности.
Инициализация объектов из переменных
Свойства объектов часто создают из переменных, назначая им те же имена, которые уже назначены этим переменным. Например:
В ES6 больше не нужно повторять имена переменных:
Этот приём может оказаться полезным для возвращаемых объектов при использовании паттерна Revealing Module, который позволяет создавать пространства имён для различных фрагментов кода для того, чтобы избежать конфликтов имён. Например:
Возможно, вы видели как этот приём используется в ES6-модулях:
Сокращённый синтаксис объявления методов объектов
При объявлении методов объектов в ES5 необходимо использовать ключевое слово function :
Теперь, в ES6, так больше можно не делать. Здесь допустим следующий сокращённый способ объявления методов:
Надо отметить, что здесь нельзя использовать стрелочные функции ES6 ( => ), так как у методов должны быть имена. Однако стрелочные функции можно использовать если явно назначать имена методам (как в ES5). Например:
Динамические ключи
В ES5 нельзя было использовать переменные в качестве имён ключей, хотя ключ, имя которого задаётся переменной, можно было добавить после создания объекта. Например:
В ES6 ключи можно назначать динамически, помещая выражение, определяющее имя, в квадратные скобки ( [] ). Например:
Для создания ключа можно использовать любое выражение:
Динамические ключи можно использовать и для методов, и для свойств:
Другой вопрос — надо ли создавать свойства и методы с динамически генерируемыми именами. Читабельность кода, в котором используется этот приём, может ухудшиться. Возможно, если вы сталкиваетесь с ситуациями, в которых динамические имена кажутся уместными, лучше будет подумать о применении для создания объектов фабричных функций или классов.
Деструктурирование
Деструктурирование — это извлечение свойств объектов и назначение их переменным. Часто в ходе разработки приложений необходимо извлечь значение свойства объекта и записать его в переменную. В ES5 нужно было описывать это следующим образом, пользуясь командами доступа к свойствам:
ES6 поддерживает деструктурирование. Можно создать переменную с тем же именем, которое носит соответствующее свойство объекта, и сделать следующее:
Переменные, в которые попадают значения свойств объекта, могут, на самом деле, иметь любые имена, но в том случае, если они отличаются от имён свойств, необходимо пользоваться конструкцией < propertyName: newVariable >:
Объекты, обладающие сложной структурой, в которые вложены массивы и другие объекты, тоже можно использовать в операциях деструктурирующего присваивания:
Поначалу всё это может показаться сложным, однако, с этим не так уж и тяжело разобраться, главное — помнить следующее:
Эта конструкция нормально воспринимается системой при объявлении переменных:
Если же переменные уже объявлены, надо заключать выражение в круглые скобки:
В результате, занимаясь деструктурированием, следует внимательно относиться к коду и не смешивать объявленные и необъявленные переменные.
Деструктурирование — это приём, который может пригодиться во многих ситуациях.
Параметры функций по умолчанию
Если функция нуждается в длинном списке аргументов, обычно проще передать ей один объект с параметрами. Например:
В ES5 было необходимо разбирать объекты с параметрами для того, чтобы, в том случае, если в таких объектах нет того, чего нужно, назначить соответствующим параметрам значения по умолчанию:
В ES6 любым параметрам можно назначать значения по умолчанию:
Затем можно воспользоваться деструктурированием для извлечения из объекта значений, и, при необходимости, для назначения значений по умолчанию:
Тут стоит отметить, что подобный код, возможно, будет сложнее читать, чем более традиционный, хотя это — вопрос личных пристрастий программиста.
Разбор объектов, возвращаемых функциями
Функции могут возвращать лишь одно значение, но это значение может быть объектом с сотней свойств или методов. В ES5 необходимо было сначала получить возвращаемый объект, а уже после этого можно было извлекать из него значения:
Деструктурирование упрощает этот процесс. Теперь всё это можно сделать без необходимости сохранения объекта в отдельной переменной и последующего его разбора:
Синтаксис оставшихся параметров и оператор расширения ES2018 (ES9)
=В ES2015 синтаксис оставшихся параметров и оператор расширения (и тот и другой выглядят как три точки, … ) применялись лишь при работе с массивами. В ES2018 похожий функционал можно использовать и для работы с объектами:
Похожий подход можно использовать и для передачи неких значений в функцию:
Обратите внимание на то, что в подобных ситуациях можно использовать лишь одно выражение с тремя точками, в конце списка. Кроме того, для объектов, вложенных в другие объекты, это не работает.
Оператор расширения можно использовать внутри объектов:
Синтаксис оставшихся параметров и оператор расширения пока пользуются не слишком широкой поддержкой. В настоящий момент ими, без дополнительных усилий, можно пользоваться в браузерах Chrome и Firefox, и при разработке для платформы Node.js версии 8.6 и выше.
Итоги
Объектные литералы всегда были полезной возможностью JavaScript. Новшества, появляющиеся в JavaScript начиная со стандарта ES2015, не несут в себе фундаментальных изменений, но они экономят время программиста и помогают писать более чистый и лаконичный код.
Уважаемые читатели! Какими способами создания JS-объектов вы пользуетесь чаще всего?