Что делает оператор в javascript

Логические операторы

Здесь мы рассмотрим первые пять, операторы ?? и ??= будут в следующей статье.

Несмотря на своё название, данные операторы могут применяться к значениям любых типов. Полученные результаты также могут иметь различный тип.

Давайте рассмотрим их подробнее.

|| (ИЛИ)

Оператор «ИЛИ» выглядит как двойной символ вертикальной черты:

result = a || b;

Традиционно в программировании ИЛИ предназначено только для манипулирования булевыми значениями: в случае, если какой-либо из аргументов true , он вернёт true , в противоположной ситуации возвращается false .

В JavaScript, как мы увидим далее, этот оператор работает несколько иным образом. Но давайте сперва посмотрим, что происходит с булевыми значениями.

Существует всего четыре возможные логические комбинации:

alert( true || true ); // true alert( false || true ); // true alert( true || false ); // true alert( false || false ); // false

Как мы можем наблюдать, результат операций всегда равен true , за исключением случая, когда оба аргумента false .

Если значение не логического типа, то оно к нему приводится в целях вычислений.

Например, число 1 будет воспринято как true , а 0 – как false :

if (1 || 0) < // работает как if( true || false ) alert( 'истинно!' ); >

Обычно оператор || используется в if для проверки истинности любого из заданных условий.

let hour = 9; if (hour < 10 || hour >18)

Можно передать и больше условий:

let hour = 12; let isWeekend = true; if (hour < 10 || hour >18 || isWeekend) < alert( 'Офис закрыт.' ); // это выходной >

ИЛИ «||» находит первое истинное значение

Описанная выше логика соответствует традиционной. Теперь давайте поработаем с «дополнительными» возможностями JavaScript.

Расширенный алгоритм работает следующим образом.

При выполнении ИЛИ || с несколькими значениями:

result = value1 || value2 || value3;

Оператор || выполняет следующие действия:

• Вычисляет операнды слева направо.
• Каждый операнд конвертирует в логическое значение. Если результат true , останавливается и возвращает исходное значение этого операнда.
• Если все операнды являются ложными ( false ), возвращает последний из них.

Значение возвращается в исходном виде, без преобразования.

Другими словами, цепочка ИЛИ || возвращает первое истинное значение или последнее, если такое значение не найдено.

alert( 1 || 0 ); // 1 (1 - истинное значение) alert( true || 'какая-то строка' ); // true alert( null || 1 ); // 1 (первое истинное значение) alert( null || 0 || 1 ); // 1 (первое истинное значение) alert( undefined || null || 0 ); // 0 (поскольку все ложно, возвращается последнее значение)

Это делает возможным более интересное применение оператора по сравнению с «чистым, традиционным, только булевым ИЛИ».

Получение первого истинного значения из списка переменных или выражений. Например, у нас есть переменные firstName , lastName и nickName , все они необязательные (т.е. они могут быть неопределенными или иметь ложные значения). Давайте воспользуемся оператором ИЛИ || , чтобы выбрать ту переменную, в которой есть данные, и показать её (или «Аноним», если ни в одной переменной данных нет):

let firstName = ""; let lastName = ""; let nickName = "Суперкодер"; alert( firstName || lastName || nickName || "Аноним"); // Суперкодер

Базовые операторы, математика

Многие операторы знакомы нам ещё со школы: сложение + , умножение * , вычитание — и так далее.

В этой главе мы начнём с простых операторов, а потом сконцентрируемся на специфических для JavaScript аспектах, которые не проходят в школьном курсе арифметики.

Термины: «унарный», «бинарный», «операнд»

Прежде, чем мы двинемся дальше, давайте разберёмся с терминологией.

• Операнд – то, к чему применяется оператор. Например, в умножении 5 * 2 есть два операнда: левый операнд равен 5 , а правый операнд равен 2 . Иногда их называют «аргументами» вместо «операндов».
• Унарным называется оператор, который применяется к одному операнду. Например, оператор унарный минус «-» меняет знак числа на противоположный:

let x = 1; x = -x; alert( x ); // -1, применили унарный минус

let x = 1, y = 3; alert( y - x ); // 2, бинарный минус вычитает значения

Математика

Поддерживаются следующие математические операторы:

• Сложение + ,
• Вычитание — ,
• Умножение * ,
• Деление / ,
• Взятие остатка от деления % ,
• Возведение в степень ** .

Первые четыре оператора очевидны, а про % и ** стоит сказать несколько слов.

Взятие остатка %

Оператор взятия остатка % , несмотря на обозначение, никакого отношения к процентам не имеет.

Результат a % b – это остаток от целочисленного деления a на b .

alert( 5 % 2 ); // 1, остаток от деления 5 на 2 alert( 8 % 3 ); // 2, остаток от деления 8 на 3 alert( 8 % 4 ); // 0, остаток от деления 8 на 4

Возведение в степень **

Оператор возведения в степень a ** b возводит a в степень b .

В школьной математике мы записываем это как a b .

alert( 2 ** 2 ); // 2² = 4 alert( 2 ** 3 ); // 2³ = 8 alert( 2 ** 4 ); // 2⁴ = 16

Математически, оператор работает и для нецелых чисел. Например, квадратный корень является возведением в степень ½:

alert( 4 ** (1/2) ); // 2 (степень 1/2 эквивалентна взятию квадратного корня)

Сложение строк при помощи бинарного +

Давайте рассмотрим специальные возможности операторов JavaScript, которые выходят за рамки школьной арифметики.

Обычно при помощи плюса ‘+’ складывают числа.

Но если бинарный оператор ‘+’ применить к строкам, то он их объединяет в одну:

let s = "моя" + "строка"; alert(s); // моястрока

Обратите внимание, если хотя бы один операнд является строкой, то второй будет также преобразован в строку.

alert( '1' + 2 ); // "12" alert( 2 + '1' ); // "21"

Как видите, не важно, первый или второй операнд является строкой.

Вот пример посложнее:

alert(2 + 2 + '1' ); // будет "41", а не "221"

Здесь операторы работают один за другим. Первый + складывает два числа и возвращает 4 , затем следующий + объединяет результат со строкой, производя действие 4 + ‘1’ = ’41’ .

Сложение и преобразование строк — это особенность бинарного плюса + . Другие арифметические операторы работают только с числами и всегда преобразуют операнды в числа.

Например, вычитание и деление:

alert( 6 - '2' ); // 4, '2' приводится к числу alert( '6' / '2' ); // 3, оба операнда приводятся к числам

Приведение к числу, унарный +

Плюс + существует в двух формах: бинарной, которую мы использовали выше, и унарной.

Унарный, то есть применённый к одному значению, плюс + ничего не делает с числами. Но если операнд не число, унарный плюс преобразует его в число.

// Не влияет на числа let x = 1; alert( +x ); // 1 let y = -2; alert( +y ); // -2 // Преобразует не числа в числа alert( +true ); // 1 alert( +"" ); // 0

На самом деле это то же самое, что и Number(. ) , только короче.

Необходимость преобразовывать строки в числа возникает очень часто. Например, обычно значения полей HTML-формы — это строки. А что, если их нужно, к примеру, сложить?

Бинарный плюс сложит их как строки:

let apples = "2"; let oranges = "3"; alert( apples + oranges ); // "23", так как бинарный плюс объединяет строки

Поэтому используем унарный плюс, чтобы преобразовать к числу:

let apples = "2"; let oranges = "3"; // оба операнда предварительно преобразованы в числа alert( +apples + +oranges ); // 5 // более длинный вариант // alert( Number(apples) + Number(oranges) ); // 5

С точки зрения математики, такое изобилие плюсов выглядит странным. Но с точки зрения программиста тут нет ничего особенного: сначала выполнятся унарные плюсы, которые приведут строки к числам, а затем бинарный ‘+’ их сложит.

Почему унарные плюсы выполнились до бинарного сложения? Как мы сейчас увидим, дело в их приоритете.

Приоритет операторов

В том случае, если в выражении есть несколько операторов – порядок их выполнения определяется приоритетом, или, другими словами, существует определённый порядок выполнения операторов.

Из школы мы знаем, что умножение в выражении 1 + 2 * 2 выполнится раньше сложения. Это как раз и есть «приоритет». Говорят, что умножение имеет более высокий приоритет, чем сложение.

Скобки важнее, чем приоритет, так что, если мы не удовлетворены порядком по умолчанию, мы можем использовать их, чтобы изменить приоритет. Например, написать (1 + 2) * 2 .

В JavaScript много операторов. Каждый оператор имеет соответствующий номер приоритета. Тот, у кого это число больше, – выполнится раньше. Если приоритет одинаковый, то порядок выполнения – слева направо.

Отрывок из таблицы приоритетов (нет необходимости всё запоминать, обратите внимание, что приоритет унарных операторов выше, чем соответствующих бинарных):

Приоритет	Название	Обозначение
…	…	…
15	унарный плюс	+
15	унарный минус	—
14	возведение в степень	**
13	умножение	*
13	деление	/
12	сложение	+
12	вычитание	—
…	…	…
2	присваивание	=
…	…	…

Так как «унарный плюс» имеет приоритет 15 , который выше, чем 12 у «сложения» (бинарный плюс), то в выражении «+apples + +oranges» сначала выполнятся унарные плюсы, а затем сложение.

Присваивание

Давайте отметим, что в таблице приоритетов также есть оператор присваивания = . У него один из самых низких приоритетов: 2 .

Именно поэтому, когда переменной что-либо присваивают, например, x = 2 * 2 + 1 , то сначала выполнится арифметика, а уже затем произойдёт присваивание = с сохранением результата в x .

let x = 2 * 2 + 1; alert( x ); // 5

Присваивание = возвращает значение

Тот факт, что = является оператором, а не «магической» конструкцией языка, имеет интересные последствия.

Большинство операторов в JavaScript возвращают значение. Для некоторых это очевидно, например сложение + или умножение * . Но и оператор присваивания не является исключением.

Вызов x = value записывает value в x и возвращает его.

Благодаря этому присваивание можно использовать как часть более сложного выражения:

let a = 1; let b = 2; let c = 3 - (a = b + 1); alert( a ); // 3 alert( c ); // 0

В примере выше результатом (a = b + 1) будет значение, которое присваивается переменной a (то есть 3 ). Потом оно используется для дальнейших вычислений.

Забавное применение присваивания, не так ли? Нам нужно понимать, как это работает, потому что иногда это можно увидеть в JavaScript-библиотеках.

Однако писать самим в таком стиле не рекомендуется. Такие трюки не сделают ваш код более понятным или читабельным.

Присваивание по цепочке

Рассмотрим ещё одну интересную возможность: цепочку присваиваний.

let a, b, c; a = b = c = 2 + 2; alert( a ); // 4 alert( b ); // 4 alert( c ); // 4

Такое присваивание работает справа налево. Сначала вычисляется самое правое выражение 2 + 2 , и затем результат присваивается переменным слева: c , b и a . В конце у всех переменных будет одно значение.

Опять-таки, чтобы код читался легче, лучше разделять подобные конструкции на несколько строчек:

c = 2 + 2; b = c; a = c;

Польза от такого стиля особенно ощущается при быстром просмотре кода.

Сокращённая арифметика с присваиванием

Часто нужно применить оператор к переменной и сохранить результат в ней же.

let n = 2; n = n + 5; n = n * 2;

Эту запись можно укоротить при помощи совмещённых операторов += и *= :

let n = 2; n += 5; // теперь n = 7 (работает как n = n + 5) n *= 2; // теперь n = 14 (работает как n = n * 2) alert( n ); // 14

Подобные краткие формы записи существуют для всех арифметических и побитовых операторов: /= , -= , **= и так далее.

Вызов с присваиванием имеет в точности такой же приоритет, как обычное присваивание, то есть выполнится после большинства других операций:

let n = 2; n *= 3 + 5; alert( n ); // 16 (сначала выполнится правая часть, выражение идентично n *= 8)

Инкремент/декремент

Одной из наиболее частых числовых операций является увеличение или уменьшение на единицу.

Для этого существуют даже специальные операторы:

Инкремент ++ увеличивает переменную на 1:

let counter = 2; counter++; // работает как counter = counter + 1, просто запись короче alert( counter ); // 3

let counter = 2; counter--; // работает как counter = counter - 1, просто запись короче alert( counter ); // 1

Инкремент/декремент можно применить только к переменной. Попытка использовать его на значении, типа 5++, приведёт к ошибке.

Операторы ++ и — могут быть расположены не только после, но и до переменной.

• Когда оператор идёт после переменной — это «постфиксная форма»: counter++ .
• «Префиксная форма» — это когда оператор идёт перед переменной: ++counter .

Обе эти инструкции делают одно и то же: увеличивают counter на 1 .

Есть ли разница между ними? Да, но увидеть её мы сможем, только если будем использовать значение, которое возвращают ++/— .

Давайте проясним этот момент. Как мы знаем, все операторы возвращают значение. Операторы инкремента/декремента не исключение. Префиксная форма возвращает новое значение, в то время как постфиксная форма возвращает старое (до увеличения/уменьшения числа).

Чтобы увидеть разницу, вот небольшой пример:

let counter = 1; let a = ++counter; // (*) alert(a); // 2

В строке (*) префиксная форма ++counter увеличивает counter и возвращает новое значение 2 . Так что alert покажет 2 .

Теперь посмотрим на постфиксную форму:

let counter = 1; let a = counter++; // (*) меняем ++counter на counter++ alert(a); // 1

В строке (*) постфиксная форма counter++ также увеличивает counter , но возвращает старое значение (которое было до увеличения). Так что alert покажет 1 .

Если результат оператора не используется, а нужно только увеличить/уменьшить переменную, тогда без разницы, какую форму использовать:

let counter = 0; counter++; ++counter; alert( counter ); // 2, обе строки сделали одно и то же

Что делает оператор в javascript

В JavaScript оператор — это специальный символ, используемый для выполнения операций над операндами (значениями и переменными). Например,

2 + 3; // 5

Здесь + — оператор, выполняющий сложение, а 2 и 3 — операнды.

Типы операторов

Вот список различных операторов, которые можно изучить в этом материале:

• Операторы присваивания
• Арифметические операторы
• Операторы сравнения
• Логические операторы
• Побитовые операторы
• Строковые операторы
• Другие операторы

Операторы присваивания

Операторы присваивания используются для присвоения значений переменным. Например,

const x = 5;

Здесь оператор = используется для присвоения переменной x значения 5 .

Вот список часто используемых операторов присваивания:

Оператор	Название	Пример
=	Оператор присваивания	a = 7; // 7
+=	Сложение с присваиванием	a += 5; // a = a + 5
-=	Вычитание с присваиванием	a -= 2; // a = a — 2
*=	Умножение с присваиванием	a *= 3; // a = a * 3
/=	Деление с присваиванием	a /= 2; // a = a / 2
%=	Присваивание с остатком	a %= 2; // a = a % 2
**=	Присваивание степени	a **= 2; // a = a**2

Примечание: Часто используемым оператором присваивания является = .

Арифметические операторы

Арифметические операторы используются для выполнения арифметических вычислений. Например,

const number = 3 + 5; // 8

Здесь оператор + используется для сложения двух операндов.

Оператор	Название	Пример
+	Сложение	x + y
—	Вычитание	x — y
*	Умножение	x * y
/	Деление	x / y
%	Остаток от деления	x % y
++	Инкремент (увеличивает на 1)	++x or x++
—	Декремент ( уменьшает на 1)	—x or x—
**	Возведение в степень	x ** y

Пример 1: Арифметические операторы

let x = 5; let y = 3; // сложение console.log('x + y = ', x + y); // 8 // вычитание console.log('x - y = ', x - y); // 2 // умножение console.log('x * y = ', x * y); // 15 // деление console.log('x / y = ', x / y); // 1.6666666666666667 // остаток от деления console.log('x % y = ', x % y); // 2 // инкремент console.log('++x = ', ++x); // x теперь равен 6 console.log('x++ = ', x++); // выводит 6 затем увеличивается до 7 console.log('x = ', x); // 7 // декремент console.log('--x = ', --x); // x теперь равен 6 console.log('x-- = ', x--); // выводит 6 затем уменьшается до 5 console.log('x = ', x); // 5 // возведение в степень console.log('x ** y =', x ** y);

Операторы сравнения

Операторы сравнения сравнивают два значения и возвращают булево значение, либо true , либо false . Например,

const a = 3; const b = 2; console.log(a > b); // true

Здесь оператор сравнения > используется для сравнения того, больше ли a , чем b .

Оператор	Описание	Пример
==	Равно: возвращает true , если операнды равны	x == y
!=	Не равно: возвращает true , если операнды не равны.	x != y
===	Строгое равно: true , если операнды равны и имеют одинаковый тип	x === y
!==	Строгое не равно: true , если операнды равны, но разного типа или не равны вообще	x !== y
>	Больше чем: true , если левый операнд больше правого операнда	x > y
>=	Больше или равно: true , если левый операнд больше или равен правому операнду	x >= y
	Меньше чем: true , если левый операнд меньше правого операнда	x < y
	Меньше или равно: true , если левый операнд меньше или равен правому операнду	x

Пример 2: Операторы сравнения

// оператор равно console.log(2 == 2); // true console.log(2 == '2'); // true // оператор не равно console.log(3 != 2); // true console.log('привет' != 'Привет'); // true // строгий оператор равно console.log(2 === 2); // true console.log(2 === '2'); // false // строгий оператор не равно console.log(2 !== '2'); // true console.log(2 !== 2); // false

Операторы сравнения используются в принятии решений и циклах.

Побитовые операторы

Побитовые операторы выполняют операции над двоичными представлениями чисел.

Оператор	Описание
&	Побитовое И
\|	Побитовое ИЛИ
^	Побитовый XOR
~	Побитовое НЕ
	Левый сдвиг
>>	Правый сдвиг
>>>	Правый сдвиг с нулевым заполнением

Побитовые операторы редко используются в повседневном программировании.

Строковые операторы

В JavaScript также можно использовать оператор + для конкатенации (объединения) двух или более строк.

Пример: Строковые операторы

// оператор конкатенации console.log('привет' + 'мир'); let a = 'Purple'; a += ' School'; // a = a + ' School'; console.log(a);

Вывод в консоль:

приветмир Purple School

Примечание: Когда + используется со строками, он выполняет конкатенацию. Однако, когда + используется с числами, он выполняет сложение.

Другие операторы

Вот список других операторов, доступных в JavaScript:

Оператор	Описание	Пример
,	оценивает несколько операндов и возвращает значение последнего операнда.	let a = (1, 3 , 4); // 4
?:	возвращает значение в зависимости от условия	(5 > 3) ? ‘success’ : ‘error’; // «success»
delete	удаляет свойство объекта или элемент массива	delete x
typeof	возвращает строку, указывающую на тип данных	typeof 3; // «number»
void	отбрасывает возвращаемое значение выражения	void(x)
in	возвращает true , если указанное свойство есть в объекте	prop in object
instanceof	возвращает true , если указанный объект относится к указанному типу объектов	object instanceof object_type

Выражения и операторы

Эта глава описывает все операторы, выражения и ключевые слова языка JavaScript.

Выражения и операторы по категориям

Алфавитный список смотрите в боковой панели слева.

Первичные выражения

Базовые ключевые слова и общие выражения в JavaScript.

Ключевое слово this ссылается на контекст выполняемой функции.

Ключевое слово function определяет выражение функции.

Ключевое слово class определяет выражение класса.

Ключевое слово function* (со звёздочкой) определяет функцию-генератор.

Пауза или продолжение выполнения функции-генератора.

Делегирует выполнение другому генератору итерируемому объекту.

async function определяет выражение асинхронной функции.

Пауза и продолжение выполнения асинхронной функции и ожидание Promise (результата выполнения) с результатом разрешено/отклонено.

Синтаксис создания инициализатора/литерала массива.

Синтаксис создания инициализатора/литерала объекта

Синтаксис создания литерала регулярного выражения.

Левосторонние выражения

Значения слева являются назначением присваивания.

Операторы доступа к членам предоставляют доступ к свойству или методу объекта ( object.property и object[‘property’] ).

Оператор new создаёт экземпляр объекта с использованием конструктора.

Свойство new.target ссылается на конструктор или функцию, который был вызван через оператор new .

Ключевое слово super вызывает конструктор родительского класса.

Оператор распространения позволяет развернуть выражение в местах, где ожидается несколько аргументов (при вызове функций) или несколько элементов (при создании литералов массива).

Инкремент и декремент

Операторы постфиксного/префиксного инкремента и декремента.

Оператор постфиксного инкремента.

Оператор постфиксного декремента.

Оператор префиксного инкремента. (Значение переменной, сначала, увеличивается на 1, а затем используется в выражении)

Оператор префиксного декремента.

Унарные операторы

Унарные операции — это операции с одним операндом.

Оператор delete удаляет свойство из объекта.

Оператор void отбрасывает возвращаемое значение выражения.

Оператор typeof определяет тип переданного объекта.

Оператор унарного плюса преобразует свой операнд в тип Number .

Оператор унарного минуса преобразует свой операнд в тип Number , а затем меняет его знак.

Оператор побитового НЕ.

Оператор логического НЕ.

Арифметические операторы

Арифметические операторы своими операндами принимают числовые значения (литералы или переменные) и возвращают одно числовое значение.

Оператор взятия остатка от деления.

Оператор возведения в степень.

Реляционные операторы

Реляционные операторы (операторы отношения) сравнивают свои операнды и возвращают значение типа Boolean , зависящее от того, был ли результат сравнения истинным или ложным.

Оператор in определяет, содержит ли объект указанное свойство.

Оператор instanceof определяет, является ли объект экземпляром потомком Prototype (или экземпляром) другого объекта.

Оператор меньше или равно.

Оператор больше или равно.

Примечание: => это не оператор. Это нотация для Стрелочных функций.

Операторы равенства

Результат вычисления оператора равенства всегда имеет тип Boolean и значение, зависящее от того, был ли результат проверки истинным или ложным.

Оператор проверки на равенство.

Оператор проверки на неравенство.

Оператор проверки на идентичность.

Оператор проверки на неидентичность.

Операторы побитового сдвига

Операции для сдвига всех битов операнда.

Оператор побитового сдвига влево.

Оператор знакового побитового сдвига вправо.

Оператор беззнакового побитового сдвига вправо.

Бинарные побитовые операторы

Побитовые операторы трактуют свои операнды как набор из 32 битов (нулей и единиц) и возвращают стандартные числовые значения JavaScript.

Оператор побитового И.

Оператор побитового ИЛИ.

Оператор побитового ИСКЛЮЧАЮЩЕГО ИЛИ.

Бинарные логические операторы

Логические операторы обычно используются вместе с булевыми (логическими) значениями и в сочетании с ними они возвращают булево значение.

Оператор логического И.

Оператор логического ИЛИ.

Условный (тернарный) оператор

Условный оператор возвращает одно значение из двух данных в зависимости от логического значения условия.

Операторы присваивания

Операторы присваивания присваивают значение своему левому операнду, зависящее от значения их правого операнда.

Оператор присваивания с умножением.

Оператор присваивания с делением.

Оператор присваивания с взятием остатка от деления.

Оператор присваивания со сложением.

Оператор присваивания с вычитанием.

Оператор присваивания со сдвигом влево.

Оператор присваивания со знаковым сдвигом вправо.

Оператор присваивания с беззнаковым сдвигом вправо.

Оператор присваивания с побитовым И.

Оператор присваивания с побитовым ИСКЛЮЧАЮЩИМ ИЛИ.

Оператор присваивания с побитовым ИЛИ.

Деструктурирующее присваивание позволяет вам присваивать свойства массива или объекта переменным с использованием синтаксиса, очень похожего на объявление литералов массива или объекта.

Оператор запятая

Оператор запятая позволяет вычислять несколько выражений в одном операторе и возвращает результат вычисления последнего выражения.

Нестандартные особенности

Ключевое слово function может быть использовано для определения устаревших функций-генераторов в одном выражении. Для того, чтобы сделать такую функцию, её тело должно содержать хотя бы одно выражение yield .

Синтаксис закрытого выражения для сокращённого написания простейших функций.

Упрощённый синтаксис создания массива.

Упрощённый синтаксис создания генератора.

Спецификации

Specification
ECMAScript Language Specification # sec-addition-operator-plus
ECMAScript Language Specification # sec-assignment-operators
ECMAScript Language Specification # sec-async-function-definitions
ECMAScript Language Specification # sec-async-generator-function-definitions
ECMAScript Language Specification # prod-BitwiseANDExpression
ECMAScript Language Specification # sec-bitwise-not-operator
ECMAScript Language Specification # prod-BitwiseORExpression
ECMAScript Language Specification # prod-BitwiseXORExpression
ECMAScript Language Specification # sec-class-definitions
ECMAScript Language Specification # sec-comma-operator
ECMAScript Language Specification # sec-conditional-operator
ECMAScript Language Specification # sec-postfix-decrement-operator
ECMAScript Language Specification # sec-delete-operator
ECMAScript Language Specification # sec-destructuring-assignment
ECMAScript Language Specification # sec-destructuring-binding-patterns
ECMAScript Language Specification # sec-multiplicative-operators
ECMAScript Language Specification # sec-equality-operators
ECMAScript Language Specification # sec-exp-operator
ECMAScript Language Specification # sec-function-definitions
ECMAScript Language Specification # sec-generator-function-definitions
ECMAScript Language Specification # sec-relational-operators
ECMAScript Language Specification # sec-grouping-operator
ECMAScript Language Specification # sec-import-calls
ECMAScript Language Specification # prod-ImportMeta
HTML Standard # hostgetimportmetaproperties
ECMAScript Language Specification # sec-postfix-increment-operator
ECMAScript Language Specification # sec-left-shift-operator
ECMAScript Language Specification # prod-LogicalANDExpression
ECMAScript Language Specification # sec-logical-not-operator
ECMAScript Language Specification # prod-LogicalORExpression
ECMAScript Language Specification # sec-new-operator
ECMAScript Language Specification # sec-built-in-function-objects
ECMAScript Language Specification # sec-null-value
ECMAScript Language Specification # prod-CoalesceExpression
ECMAScript Language Specification # sec-object-initializer
ECMAScript Language Specification # prod-OptionalExpression
ECMAScript Language Specification # sec-property-accessors
ECMAScript Language Specification # sec-signed-right-shift-operator
ECMAScript Language Specification # prod-SpreadElement
ECMAScript Language Specification # prod-ArgumentList
ECMAScript Language Specification # prod-PropertyDefinition
ECMAScript Language Specification # sec-subtraction-operator-minus
ECMAScript Language Specification # sec-super-keyword
ECMAScript Language Specification # sec-this-keyword
ECMAScript Language Specification # sec-typeof-operator
ECMAScript Language Specification # sec-unary-minus-operator
ECMAScript Language Specification # sec-unary-plus-operator
ECMAScript Language Specification # sec-unsigned-right-shift-operator
ECMAScript Language Specification # sec-void-operator
ECMAScript Language Specification # prod-YieldExpression
ECMAScript Language Specification # sec-generator-function-definitions-runtime-semantics-evaluation

Смотрите также