diff options
Diffstat (limited to 'files/ru/web/javascript/guide/expressions_and_operators')
| -rw-r--r-- | files/ru/web/javascript/guide/expressions_and_operators/index.html | 937 |
1 files changed, 937 insertions, 0 deletions
diff --git a/files/ru/web/javascript/guide/expressions_and_operators/index.html b/files/ru/web/javascript/guide/expressions_and_operators/index.html new file mode 100644 index 0000000000..dea3cef0d6 --- /dev/null +++ b/files/ru/web/javascript/guide/expressions_and_operators/index.html @@ -0,0 +1,937 @@ +--- +title: Выражения и операторы +slug: Web/JavaScript/Guide/Expressions_and_Operators +tags: + - Beginner + - Expressions + - Guide + - Operators + - Начинающий +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<p>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Functions", "Web/JavaScript/Guide/Numbers_and_dates")}}</p> + +<p class="summary">Эта глава описывает выражения и операторы языка JavaScript, такие как операторы присваивания, сравнения, арифметические, битовые, логические, строчные, и различные специальные операторы.</p> + +<ul> +</ul> + +<p>Полный и детальный список операторов и выражений также доступен в этом <a href="/ru/docs/Web/JavaScript/Reference/Operators">руководстве</a>.</p> + +<h2 id="Операторы">Операторы</h2> + +<p>В JavaScript есть следующие типы операторов. Данный подраздел описывает каждый тип и содержит информацию об их приоритетах друг над другом.</p> + +<ul> + <li>{{ web.link("#Операторы_присваивания", "Операторы присваивания") }}</li> + <li>{{ web.link("#Операторы_сравнения", "Операторы сравнения") }}</li> + <li>{{ web.link("#Арифметические_операторы", "Арифметические операторы") }}</li> + <li>{{ web.link("#Бинарные_операторы", "Бинарные операторы") }}</li> + <li>{{ web.link("#Логические_операторы", "Логические операторы") }}</li> + <li>{{ web.link("#Строковые_операторы", "Строковые операторы") }}</li> + <li>{{ web.link("#Условный_(тернарный)_оператор", "Условный (тернарный) оператор")}}</li> + <li>{{ web.link("#Оператор_запятая", "Оператор запятая")}}</li> + <li>{{ web.link("#Унарные_операторы", "Унарные операторы")}}</li> + <li>{{ web.link("#Операторы_отношения", "Операторы отношения")}}</li> + <li>{{ web.link("#Приоритет_операторов", "Приоритет операторов")}}</li> +</ul> + +<p>JavaScript поддерживает бинарные и унарные операторы, а также ещё один специальный тернарный оператор - условный оператор. Бинарная операция использует два операнда, один перед оператором и другой за ним:</p> + +<pre class="syntaxbox"><em>operand1</em> <em>operator</em> <em>operand2</em> +</pre> + +<p>Например: <code>3+4</code> или <code>x*y</code>.</p> + +<p>В свою очередь унарная операция использует один операнд, перед или после оператора:</p> + +<pre class="syntaxbox"><em>operator</em> <em>operand</em> +</pre> + +<p>или</p> + +<pre class="syntaxbox"><em>operand</em> <em>operator</em> +</pre> + +<p>Например: <code>x++</code> или <code>++x</code>.</p> + +<h3 id="Операторы_присваивания">Операторы присваивания</h3> + +<p>В результате операции присваивания операнду слева от <a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">оператора присваивания</a> (знак "=") устанавливается значение , которое берётся из правого операнда. Основным оператором присваивания является =, он присваивает значение правого операнда операнду, находящемуся слева. Таким образом, выражение x = y означает, что x присваивается значение y.</p> + +<p>Существуют также составные операторы присваивания, которые используются для сокращенного представления операций, описанных в следующей таблице:</p> + +<table class="standard-table"> + <caption>Список операторов присваивания</caption> + <tbody> + <tr> + <th>Имя</th> + <th>Сокращенный оператор</th> + <th>Смысл</th> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">Присваивание</a></td> + <td><code>x = y</code></td> + <td><code>x = y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Addition_assignment">Присваивание со сложением</a></td> + <td><code>x += y</code></td> + <td><code>x = x + y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Subtraction_assignment">Присваивание с вычитанием</a></td> + <td><code>x -= y</code></td> + <td><code>x = x - y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Multiplication_assignment">Присваивание с умножением</a></td> + <td><code>x *= y</code></td> + <td><code>x = x * y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Division_assignment">Присваивание с делением</a></td> + <td><code>x /= y</code></td> + <td><code>x = x / y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Remainder_assignment">Присваивание по модулю</a></td> + <td><code>x %= y</code></td> + <td><code>x = x % y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Left_shift_assignment">Присваивание с левым сдвигом</a></td> + <td><code>x <<= y</code></td> + <td><code>x = x << y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Right_shift_assignment">Присваивание с правым сдвигом</a></td> + <td><code>x >>= y</code></td> + <td><code>x = x >> y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Unsigned_right_shift_assignment">Присваивание с беззнаковым сдвигом вправо</a></td> + <td><code>x >>>= y</code></td> + <td><code>x = x >>> y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Bitwise_AND_assignment">Присваивание с побитовым AND</a></td> + <td><code>x &= y</code></td> + <td><code>x = x & y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Bitwise_XOR_assignment">Присваивание с побитовым XOR</a></td> + <td><code>x ^= y</code></td> + <td><code>x = x ^ y</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Bitwise_OR_assignment">Присваивание с побитовым OR</a></td> + <td><code>x |= y</code></td> + <td><code>x = x | y</code></td> + </tr> + </tbody> +</table> + +<h4 id="Деструктуризация">Деструктуризация</h4> + +<p>Для более сложного присваивания в JavaScript есть синтаксис <a href="/ru/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">деструктуризации</a> - это выражение, которое позволяет извлекать данные из массивов или объектов, используя синтаксис, который зеркалирует конструкторы массивов и литералы объектов.</p> + +<pre class="brush: js">var foo = ["one", "two", "three"]; + +// без деструктуризации +var one = foo[0]; +var two = foo[1]; +var three = foo[2]; + +// с деструктуризацией +var [one, two, three] = foo;</pre> + +<h3 id="Операторы_сравнения">Операторы сравнения</h3> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Оператор сравнения</a> сравнивает свои операнды и возвращает логическое значение, базируясь на истинности сравнения. Операнды могут быть числами, строками, логическими величинами или объектами. Строки сравниваются на основании стандартного лексикографического порядка, используя Unicode-значения. В большинстве случаев, если операнды имеют разный тип, то JavaScript пробует преобразовать их в тип, подходящий для сравнения. Такое поведение обычно происходит при сравнении числовых операндов. Единственным исключением из данного правила является сравнение с использованием операторов <code>===</code> и <code>!==</code>, которые производят строгое сравнение на равенство или неравенство. Эти операторы не пытаются преобразовать операнды перед их сравнением. Следующая таблица описывает операторы сравнения в контексте следующего примера кода:</p> + +<pre class="brush: js">var var1 = 3, var2 = 4; +</pre> + +<table class="standard-table"> + <caption>Операторы сравнения</caption> + <thead> + <tr> + <th scope="col">Оператор</th> + <th scope="col">Описание</th> + <th scope="col">Примеры, возвращающие true</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Equality">Равно</a> (<code>==</code>)</td> + <td>Возвращает true, если операнды равны.</td> + <td><code>3 == var1</code><br> + <code>"3" == var1</code><br> + <code>3 == '3'</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Inequality">Не равно</a> (<code>!=</code>)</td> + <td>Возвращает true, если операнды не равны.</td> + <td><code>var1 != 4<br> + var2 != "3"</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Identity">Строго равно</a> (<code>===</code>)</td> + <td>Возвращает true, если операнды равны и имеют одинаковый тип. См. также {{jsxref("Object.is")}} и <a href="/ru/docs/Web/JavaScript/Equality_comparisons_and_sameness" title="/ru/docs/Web/JavaScript/Guide/Sameness">sameness in JS</a>.</td> + <td><code>3 === var1</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Nonidentity">Строго не равно</a>(<code>!==</code>)</td> + <td>Возвращает true, если операнды не равны и/или имеют разный тип.</td> + <td><code>var1 !== "3"<br> + 3 !== '3'</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Greater_than_operator">Больше</a> (<code>></code>)</td> + <td>Возвращает true, если операнд слева больше операнда справа.</td> + <td><code>var2 > var1<br> + "12" > 2</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Greater_than_or_equal_operator">Больше или равно</a> (<code>>=</code>)</td> + <td>Возвращает true, если операнд слева больше или равен операнду справа.</td> + <td><code>var2 >= var1<br> + var1 >= 3</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_operator">Меньше</a> (<code><</code>)</td> + <td>Возвращает true, если операнд слева меньше операнда справа.</td> + <td><code>var1 < var2<br> + "2" < 12</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_or_equal_operator">Меньше или равно</a> (<code><=</code>)</td> + <td>Возвращает true, если операнд слева меньше или равен операнду справа.</td> + <td><code>var1 <= var2<br> + var2 <= 5</code></td> + </tr> + </tbody> +</table> + +<div class="note"> +<p><strong>Замечание: </strong>(<strong>=></strong>) не оператор, а нотация <a href="/ru/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Стрелочных функций</a>.</p> +</div> + +<h3 id="Арифметические_операторы">Арифметические операторы</h3> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">Арифметические операторы</a> используют в качестве своих операндов числа (также литералы или переменные) и в качестве результата возвращают одно числовое значение. Стандартными арифметическими операторами являются сложение (+), вычитание (-), умножение (*), и деление (/). При работе с числами с плавающей точкой эти операторы работают аналогично их работе в большинстве других языках программирования (обратите внимание, что деление на ноль возвращает бесконечность {{jsxref("Infinity")}}). Например:</p> + +<pre class="brush: js">console.log(1 / 2); /* возвращает 0.5 */ +console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */ +</pre> + +<p>Кроме того, JavaScript позволяет использовать следующие арифметические операторы, представленные в таблице:</p> + +<table class="fullwidth-table"> + <caption>Арифметические операторы</caption> + <thead> + <tr> + <th scope="col">Оператор</th> + <th scope="col">Описание</th> + <th scope="col">Пример</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder">Остаток от деления</a> (<code>%</code>)</td> + <td>Бинарный оператор. Возвращает целочисленный остаток от деления двух операндов.</td> + <td>12 % 5 вернёт 2.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment">Инкремент</a> (<code>++</code>)</td> + <td>Унарный оператор. Добавляет единицу к своему операнду. Если используется в качестве префикса (<code>++x</code>), то возвращает значение операнда с добавленной к нему единицей; а в случае применения в качестве окончания (<code>x++</code>) возвращает значение операнда перед добавлением к нему единицы.</td> + <td><code>Если x</code> равно 3, тогда <code>++x</code> установит значение <code>x</code> равным 4 и вернёт 4, напротив <code>x++</code> вернёт 3 и потом установит значение <code>x</code> равным 4.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement">Декремент</a> (<code>--</code>)</td> + <td>Унарный оператор. Вычитает единицу из значения своего операнда. Логика данного оператора аналогична оператору инкремента.</td> + <td>Если <code>x</code> равно 3, тогда <code>--x</code> установит значение <code>x</code> равным 2 и вернёт 2, напротив <code>x--</code> вернёт 3 и потом установит значение <code>x</code> равным 2.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_negation">Унарный минус</a><code>-</code></td> + <td>Унарный оператор. Возвращает отрицательное значение своего операнда.</td> + <td>Если <code>x</code> равно 3, тогда <code>-x</code> вернёт -3.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus">Унарный плюс</a> (<code>+</code>)</td> + <td>Унарный оператор. Пытается конвертировать операнд в число, если он ещё не оно.</td> + <td><code>+"3"</code> вернёт <code>3</code>.<br> + <code>+true</code> вернёт <code>1.</code></td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation">Возведение в степень</a> (<code>**</code>) {{experimental_inline}}</td> + <td>Возводит <code>основание</code> в показатель <code>степени</code>, как, <code>основание<sup>степень</sup></code></td> + <td><code>2 ** 3</code> вернёт <code>8</code>.<br> + <code>10 ** -1</code> вернёт <code>0.1</code>.</td> + </tr> + </tbody> +</table> + +<h3 id="Битовые_(поразрядные)_операторы">Битовые (поразрядные) операторы</h3> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Битовые операторы</a> обрабатывают свои операнды как последовательности из 32 бит (нулей и единиц), а не как десятичные, шестнадцатеричные или восьмеричные числа. Например, десятичное число 9 имеет двоичное представление 1001. Битовые операторы выполняют операции над таким двоичным представлением, но результат возвращают как обычное числовое значение JavaScript.</p> + +<p>Следующая таблица обобщает битовые операторы JavaScript.</p> + +<table class="standard-table"> + <caption>Битовые операторы</caption> + <thead> + <tr> + <th scope="col">Оператор</th> + <th scope="col">Использование</th> + <th scope="col">Описание</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_AND">Побитовое И</a></td> + <td><code>a & b</code></td> + <td>Возвращает единицу в каждой битовой позиции, для которой соответствующие биты обеих операндов являются единицами.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_OR">Побитовое ИЛИ </a></td> + <td><code>a | b</code></td> + <td>Возвращает единицу в каждой битовой позиции, для которой один из соответствующих битов или оба бита операндов являются единицами.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">Исключающее ИЛИ</a></td> + <td><code>a ^ b</code></td> + <td>Возвращает единицу в каждой битовой позиции, для которой только один из соответствующих битов операндов является единицей.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_NOT">Побитовое НЕ</a></td> + <td><code>~ a</code></td> + <td>Заменяет биты операнда на противоположные.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Left_shift">Сдвиг влево</a></td> + <td><code>a << b</code></td> + <td>Сдвигает <code>a</code> в двоичном представлении на <code>b</code> бит влево, добавляя справа нули.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Right_shift">Сдвиг вправо с переносом знака</a></td> + <td><code>a >> b</code></td> + <td>Сдвигает <code>a</code> в двоичном представлении на <code>b</code> бит вправо, отбрасывая сдвигаемые биты.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Unsigned_right_shift">Сдвиг вправо с заполнением нулями</a></td> + <td><code>a >>> b</code></td> + <td>Сдвигает <code>a</code> в двоичном представлении на <code>b</code> бит вправо, отбрасывая сдвигаемые биты и добавляя слева нули.</td> + </tr> + </tbody> +</table> + +<h4 id="Bitwise_Logical_Operators" name="Bitwise_Logical_Operators">Битовые логические операторы</h4> + +<p>Основной смысл работы битовых логических операторов состоит в следующем:</p> + +<ul> + <li>Операнды преобразуются в 32-битные целые числа и представляются в виде последовательности бит (нулей и единиц). Числа, имеющие более 32 битов будут сокращены. Например, следующее число имеет больше 32 битов и сконвертируется в 32-х битное: + <pre class="brush: html">До : 11100110111110100000000000000110000000000001 +После : 10100000000000000110000000000001</pre> + </li> + <li>Каждый бит первого операнда связывается с соответствующим битом второго операнда: первый бит с первым битом, второй бит - со вторым, и так далее.</li> + <li>К каждой паре бит применяется заданный оператор, и побитово формируется итоговый результат.</li> +</ul> + +<p>Например, двоичным представлением числа 9 является 1001, а двоичным представлением пятнадцати - 1111. Результаты применения к этим числам битовых логических операторов выглядят следующим образом:</p> + +<table class="standard-table"> + <caption>Примеры работы битовых операторов</caption> + <thead> + <tr> + <th scope="col">Выражение</th> + <th scope="col">Результат</th> + <th scope="col">Двоичное описание</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>15 & 9</code></td> + <td><code>9</code></td> + <td><code>1111 & 1001 = 1001</code></td> + </tr> + <tr> + <td><code>15 | 9</code></td> + <td><code>15</code></td> + <td><code>1111 | 1001 = 1111</code></td> + </tr> + <tr> + <td><code>15 ^ 9</code></td> + <td><code>6</code></td> + <td><code>1111 ^ 1001 = 0110</code></td> + </tr> + <tr> + <td><code>~15</code></td> + <td><code>-16</code></td> + <td><code>~</code><code>00000000...</code><code>00001111 = </code><code>1111</code><code>1111</code><code>...</code><code>11110000</code></td> + </tr> + <tr> + <td><code>~9</code></td> + <td><code>-10</code></td> + <td><code>~</code><code>00000000</code><code>...</code><code>0000</code><code>1001 = </code><code>1111</code><code>1111</code><code>...</code><code>1111</code><code>0110</code></td> + </tr> + </tbody> +</table> + +<p>Обратите внимание, что все 32 бита преобразуются с использованием битового оператора НЕ, и что величины с наиболее значимым (самым левым) битом равным 1 представляют собой отрицательные числа (в представлении дополнения до двух).</p> + +<h4 id="Bitwise_Shift_Operators" name="Bitwise_Shift_Operators">Битовые операторы сдвига</h4> + +<p>Битовые операторы сдвига используют два операнда: первый представляет величину, подлежащую сдвигу, а второй операнд указывает число битовых позиций на которое должен быть сдвинут первый операнд. Направление операции сдвига определяется используемым оператором.</p> + +<p>Операторы сдвига преобразуют свои операнды в 32-битные целые числа и возвращают результат того же типа, каким является левый операнд.</p> + +<p>Операторы сдвига перечислены в следующей таблице.</p> + +<table class="fullwidth-table"> + <caption>Битовые операторы сдвига</caption> + <thead> + <tr> + <th scope="col">Оператор</th> + <th scope="col">Описание</th> + <th scope="col">Пример</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#<<_(Left_shift)">Сдвиг влево</a><br> + (<code><<</code>)</td> + <td>Данный оператор сдвигает первый операнд на указанное количество бит влево. Излишние биты, сдвинутые влево, отбрасываются. Справа число дополняется нулевыми битами.</td> + <td><code>9<<2</code> равно 36, так как 1001 после сдвига на 2 бита влево превращается в 100100, что соответствует числу 36.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#>>_(Sign-propagating_right_shift)">Сдвиг вправо с переносом знака</a> (<code>>></code>)</td> + <td>Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется копиями крайнего слева бита.</td> + <td><code>9>>2</code> равно 2, так как 1001 после сдвига на 2 бита вправо превращается в 10, что соответствует числу 2. Подобным же образом <code>-9>>2</code> равно -3, так как знак сохраняется.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#>>>_(Zero-fill_right_shift)">Сдвиг вправо с заполнением нулями</a> (<code>>>></code>)</td> + <td>Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется нулевыми битами.</td> + <td><code>19>>>2</code> равно 4, так как 10011 после сдвига на 2 бита вправо превращается в 100, что соответствует числу 4. Для неотрицательных чисел сдвиг вправо с заполнением нулями и сдвиг вправо с переносом знака дают одинаковый результат.</td> + </tr> + </tbody> +</table> + +<h3 id="Логические_операторы">Логические операторы</h3> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Логические операторы</a> обычно используются с булевыми (логическими) значениями; при этом возвращаемое ими значение также является булевым. Однако операторы && и || фактически возвращают значение одного из операндов, поэтому, если эти операторы используются с небулевыми величинами, то возвращаемая ими величина также может быть не булевой. Логические операторы описаны в следующей таблице.</p> + +<table class="fullwidth-table"> + <caption>Логические операторы</caption> + <thead> + <tr> + <th scope="col">Оператор</th> + <th scope="col">Использование</th> + <th scope="col">Описание</th> + </tr> + </thead> + <tbody> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND">Логическое И</a><code> </code>(<code>&&</code>)</td> + <td><code>expr1 && expr2</code></td> + <td>(Логическое И) Возвращает операнд <code>expr1</code>, если он может быть преобразован в <code>false</code>; в противном случае возвращает операнд <code>expr2</code>. Таким образом, при использовании булевых величин в качестве операндов, оператор <code>&&</code> возвращает <code>true</code>, если оба операнда <code>true</code>; в противном случае возвращает <code>false</code>.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR">Логическое ИЛИ </a>(<code>||</code>)</td> + <td><code>expr1 || expr2</code></td> + <td>(Логическое ИЛИ) Возвращает операнд <code>expr1</code>, если он может быть преобразован в <code>true</code>; в противном случае возвращает операнд <code>expr2</code>. Таким образом, при использовании булевых величин в качестве операндов, оператор <code>||</code> возвращает <code>true</code>, если один из операндов <code>true</code>; если же оба <code>false</code>, то возвращает <code>false</code>.</td> + </tr> + <tr> + <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT">Логическое НЕ </a>(<code>!</code>)</td> + <td><code>!expr</code></td> + <td>(Логическое НЕ) Возвращает <code>false</code>, если операнд может быть преобразован в <code>true</code>; в противном случае возвращает <code>true</code>.</td> + </tr> + </tbody> +</table> + +<p>Примерами выражений, которые могут быть преобразованы в false являются: null, 0, NaN, пустая строка ("") или undefined.</p> + +<p>Следующий код демонстрирует примеры использования оператора && (логическое И).</p> + +<pre class="brush: js">var a1 = true && true; // t && t возвращает true +var a2 = true && false; // t && f возвращает false +var a3 = false && true; // f && t возвращает false +var a4 = false && (3 == 4); // f && f возвращает false +var a5 = "Cat" && "Dog"; // t && t возвращает Dog +var a6 = false && "Cat"; // f && t возвращает false +var a7 = "Cat" && false; // t && f возвращает false +</pre> + +<p>Следующий код демонстрирует примеры использования оператора || (логическое ИЛИ).</p> + +<pre class="brush: js">var o1 = true || true; // t || t возвращает true +var o2 = false || true; // f || t возвращает true +var o3 = true || false; // t || f возвращает true +var o4 = false || (3 == 4); // f || f возвращает false +var o5 = "Cat" || "Dog"; // t || t возвращает Cat +var o6 = false || "Cat"; // f || t возвращает Cat +var o7 = "Cat" || false; // t || f возвращает Cat +</pre> + +<p>Следующий код демонстрирует примеры использования оператора ! (логическое НЕ).</p> + +<pre class="brush: js">var n1 = !true; // !t возвращает false +var n2 = !false; // !f возвращает true +var n3 = !"Cat"; // !t возвращает false +</pre> + +<h4 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Сокращённая оценка</h4> + +<p>Так как логические выражения вычисляются слева направо, они проверяются на возможность выполнения сокращённой оценки с использованием следующих правил:</p> + +<ul> + <li><code>false</code> && anything<em> - </em>сокращение с результатом false.</li> + <li><code>true</code> || <em>anything - </em>сокращение с результатом true.</li> +</ul> + +<p>Правила логики гарантируют, что данные вычисления всегда корректны. Обратите внимание, что часть "<em>anything"</em> представленных выше выражений не вычисляется, таким образом удается избежать любых побочных эффектов вычисления данной части.</p> + +<h3 id="Строковые_операторы">Строковые операторы</h3> + +<p>В дополнение к операторам сравнения, которые могут использоваться со строковыми значениями, оператор (+) позволяет объединить две строки, возвращая при этом третью строку, которая представляет собой объединение двух строк-операндов:</p> + +<pre class="brush: js">console.log("my " + "string"); // в консоли выведется строка "my string".</pre> + +<p>Сокращенный оператор присваивания += также может быть использован для объединения (конкатенации) строк:</p> + +<pre class="brush: js">var mystring = "alpha"; mystring += "bet"; // получается значение "alphabet" и присваивается mystring. +</pre> + +<h3 id="Условный_(тернарный)_оператор" name="Условный_(тернарный)_оператор">Условный (тернарный) оператор</h3> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Conditional_Operator">Условный оператор</a> является единственным оператором JavaScript, который использует три операнда. Оператор принимает одно из двух значений в зависимости от заданного условия. Синтаксис оператора:</p> + +<pre class="syntaxbox"><em>condition</em> ? <em>val1</em> : <em>val2</em> +</pre> + +<div class="warning"> +<p><em> val1 и val2 обязательно должны что-то возвращать, поэтому в этой конструкции нельзя использовать continue или break</em></p> +</div> + +<p>Если <code>condition (условие)</code> - истина, то оператор принимает значение <code>val1</code>. В противном случае оператор принимает значение <code>val2</code>. Вы можете использовать условный оператор во всех случаях, где может быть использован стандартный оператор.</p> + +<pre class="brush: js">var status = (age >= 18) ? "adult" : "minor"; +</pre> + +<p>Данное выражение присваивает значение "adult" переменной <code>status</code>, если <code>age</code> имеет значение 18 или более. В противном случае переменной <code>status</code> присваивается значение "minor".</p> + +<h3 id="Оператор_запятая" name="Оператор_запятая">Оператор запятая</h3> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Comma_Operator">Оператор запятая</a> (<code>,</code>) просто вычисляет оба операнда и возвращает значение последнего операнда. Данный оператор в основном используется внутри цикла <code>for</code>, что позволяет при каждом прохождении цикла одновременно обновлять значения нескольких переменных.</p> + +<p>Например, если <code>a</code> является двумерным массивом, каждая строка которого содержит 10 элементов, то следующий код с использованием оператора запятая позволяет выполнять одновременное приращение двух переменных. Данный код выводит на экран значения диагональных элементов массива:</p> + +<pre class="brush: js">for (var i = 0, j = 9; i <= 9; i++, j--) + document.writeln("a[" + i + "][" + j + "]= " + a[i][j]); +</pre> + +<h3 id="Унарные_операторы">Унарные операторы</h3> + +<p>Унарная операция - операция только с одним операндом.</p> + +<h4 id="delete" name="delete"><code>delete</code></h4> + +<p>Оператор <a href="/ru/docs/Web/JavaScript/Reference/Operators/delete">delete</a> выполняет удаление объекта, свойства объекта, или элемента массива с заданным индексом. Синтаксис оператора:</p> + +<pre class="brush: js">delete objectName; +delete objectName.property; +delete objectName[index]; +delete property; // допустимо только внутри with +</pre> + +<p>где <code>objectName</code> представляет собой имя объекта, <code>property</code> - свойство объекта, а <code>index</code> - целое число, указывающее на положение (номер позиции) элемента в массиве.</p> + +<p>Четвертый вариант использования позволяет удалить свойство объекта, но допускается только внутри <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code>.</p> + +<p>Вы можете использовать оператор <code>delete</code> для удаления переменных, объявленных неявно, но вы не можете с его помощью удалять переменные, объявленные с помощью <code>var</code>.</p> + +<p>После применения оператора <code>delete</code> свойство элемента меняется на <code>undefined</code>. Оператор <code>delete</code> возвращает <code>true</code> если выполнение операции возможно; оператор возвращает <code>false</code>, если выполнение операции невозможно.</p> + +<pre class="brush: js">x = 42; +var y = 43; +myobj = new Number(); +myobj.h = 4; // создаём свойство h +delete x; // возвращает true (можно удалить переменную объявленную неявно) +delete y; // возвращает false (нельзя удалить переменную объявленную с помощью var) +delete Math.PI; // возвращает false (нельзя удалить встроенные свойства) +delete myobj.h; // возвращает true (можно удалить пользовательские свойства) +delete myobj; // возвращает true (можно удалить объект объявленный неявно) +</pre> + +<h5 id="Удаление_элементов_массива">Удаление элементов массива</h5> + +<p>Удаление элемента массива не влияет на длину массива. Например, если вы удалите <code>a[3]</code>, элемент <code>a[4]</code> останется <code>a[4],</code> <code>a[3]</code> станет undefined.</p> + +<p>Когда элемент массива удаляется с помощью оператора <code>delete</code>, то из массива удаляется значение данного элемента. В следующем примере элемент <code>trees[3]</code> удален с помощью оператора <code>delete</code>. Однако, элемент <code>trees[3]</code> остается адресуемым и возвращает значение <code>undefined</code>.</p> + +<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); +delete trees[3]; +if (3 in trees) { + // условие не выполняется +} +</pre> + +<p>Если вы хотите, чтобы элемент оставался в массиве, но имел значение undefined, то используйте ключевое слово <code>undefined</code> вместо оператора <code>delete</code>. В следующем примере элементу <code>trees[3]</code> присвоено значение <code>undefined</code>, но элемент при этом остается в массиве:</p> + +<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); +trees[3] = undefined; +if (3 in trees) { + // данный блок кода выполняется +} +</pre> + +<h4 id="typeof" name="typeof"><code>Оператор typeof</code></h4> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/typeof">Оператор<code> typeof</code></a> используется одним из следующих способов:</p> + +<pre class="syntaxbox">typeof operand +typeof (operand)</pre> + +<p>Оператор <code>typeof</code> возвращает строку обозначающую тип невычисленного операнда. Значение <code>operand</code> может быть строкой, переменной, дескриптором, или объектом, тип которого следует определить. Скобки вокруг операнда необязательны.</p> + +<p>Предположим, вы определяете следующие переменные:</p> + +<pre class="brush: js">var myFun = new Function("5 + 2"); +var shape = "round"; +var size = 1; +var today = new Date(); +</pre> + +<p>Оператор <code>typeof</code> возвращает следующие результаты для этих переменных:</p> + +<pre class="brush: js">typeof myFun; // возвращает "function" +typeof shape; // возвращает "string" +typeof size; // возвращает "number" +typeof today; // возвращает "object" +typeof dontExist; // возвращает "undefined" +</pre> + +<p>Для дескрипторов <code>true</code> и <code>null</code> оператор <code>typeof</code> возвращает следующие результаты:</p> + +<pre class="brush: js">typeof true; // возвращает "boolean" +typeof null; // возвращает "object" +</pre> + +<p>Для чисел и строк оператор <code>typeof</code> возвращает следующие результаты:</p> + +<pre class="brush: js">typeof 62; // возвращает "number" +typeof 'Hello world'; // возвращает "string" +</pre> + +<p>Для свойств оператор <code>typeof</code> возвращает тип значения данного свойства:</p> + +<pre class="brush: js">typeof document.lastModified; // возвращает "string" +typeof window.length; // возвращает "number" +typeof Math.LN2; // возвращает "number" +</pre> + +<p>Для методов и функций оператор <code>typeof</code> возвращает следующие результаты:</p> + +<pre class="brush: js">typeof blur; // возвращает "function" +typeof eval; // возвращает "function" +typeof parseInt; // возвращает "function" +typeof shape.split; // возвращает "function" +</pre> + +<p>Для встроенных объектов оператор <code>typeof</code> возвращает следующие результаты:</p> + +<pre class="brush: js">typeof Date; // возвращает "function" +typeof Function; // возвращает "function" +typeof Math; // возвращает "object" +typeof Option; // возвращает "function" +typeof String; // возвращает "function"</pre> + +<h4 id="void" name="void"><code>Оператор void</code></h4> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/void">Оператор<code> </code><code>void</code></a> используется любым из следующих способов:</p> + +<pre class="syntaxbox">void (expression) +void expression +</pre> + +<p>Оператор <code>void</code> определяет выражение, которое должно быть вычислено без возвращения результата. <code>expression</code> - это выражение JavaScript, требующее вычисления. Скобки вокруг выражения необязательны, но их использование является правилом хорошего тона.</p> + +<p>Вы можете использовать оператор <code>void</code> для указания на то, что операнд-выражение является гипертекстовой ссылкой. При этом выражение обрабатывается, но не загружается в текущий документ.</p> + +<p>Следующий код служит примером создания гипертекстовой ссылки, которая бездействует при нажатии на неё пользователем. Когда пользователь нажимает на ссылку, <code>void(0)</code> вычисляется равным <code>undefined</code>, что не приводит ни к каким действиям в JavaScript.</p> + +<pre class="brush: html"><A HREF="javascript:void(0)">Нажмите здесь, чтобы ничего не произошло</A> +</pre> + +<p>Приведенный ниже код создает гипертекстовую ссылку, которая подтверждает отправку формы при клике на ней пользователем:</p> + +<pre class="brush: html"><A HREF="javascript:void(document.form.submit())"> +Нажмите здесь, чтобы подтвердить отправку формы</A></pre> + +<h3 id="Операторы_отношения">Операторы отношения</h3> + +<p>Оператор отношения сравнивает свои операнды и возвращает результат сравнения в виде булева значения.</p> + +<h4 id="Оператор_in"><code>Оператор in</code></h4> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/in">Оператор <code>in</code></a> возвращает true, если указанный объект имеет указанное свойство. Синтаксис оператора:</p> + +<pre class="syntaxbox">propNameOrNumber in objectName +</pre> + +<p>где <code>propNameOrNumber</code> - строка или числовое выражение, представляющее имя свойства или индекс массива, а <code>objectName</code> - имя объекта.</p> + +<p>Некоторые примеры способов использования оператора <code>in</code>:</p> + +<pre class="brush: js">// Массивы +var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); +0 in trees; // возвращает true +3 in trees; // возвращает true +6 in trees; // возвращает false +"bay" in trees; // возвращает false (следует указать индекс элемента массива, + // а не значение элемента) +"length" in trees; // возвращает true (length является свойством объекта Array) + +// Встроенные объекты +"PI" in Math; // возвращает true +var myString = new String("coral"); +"length" in myString; // возвращает true + +// Пользовательские объекты +var mycar = {make: "Honda", model: "Accord", year: 1998}; +"make" in mycar; // возвращает true +"model" in mycar; // возвращает true +</pre> + +<h4 id="instanceof" name="instanceof">Оператор <code>instanceof</code></h4> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/instanceof">Оператор <code>instanceof</code> </a>возвращает true, если заданный объект является объектом указанного типа. Его синтаксис:</p> + +<pre class="syntaxbox">objectName instanceof objectType +</pre> + +<p>где <code>objectName</code> - имя объекта, тип которого необходимо сравнить с <code>objectType</code>, а <code>objectType</code> - тип объекта, например, {{jsxref("Date")}} или {{jsxref("Array")}}.</p> + +<p><code><font face="Open Sans, Arial, sans-serif">Используйте оператор </font>instanceof</code>, когда вам необходимо подтвердить тип объекта во время выполнения программы. Например, при перехвате исключений вы можете создать различные программные переходы для обработки исключений в зависимости от типа обрабатываемого исключения.</p> + +<p>Например, следующий код использует оператор <code>instanceof</code> для проверки того, является ли объект <code>theDay</code> объектом типа <code>Date</code>. Так как <code>theDay</code> действительно является объектом типа <code>Date</code>, то программа выполняет код, содержащийся в утверждении <code>if</code>.</p> + +<pre class="brush: js">var theDay = new Date(1995, 12, 17); +if (theDay instanceof Date) { + // выполняемый код +} +</pre> + +<h3 id="Приоритет_операторов">Приоритет операторов</h3> + +<p><em>Приоритет</em> операторов определяет порядок их выполнения при вычислении выражения. Вы можете влиять на приоритет операторов с помощью скобок.</p> + +<p>Приведенная ниже таблица описывает приоритет операторов от наивысшего до низшего.</p> + +<table class="standard-table"> + <caption>Таблица 3.7 Приоритет операторов</caption> + <thead> + <tr> + <th scope="col">Тип оператора</th> + <th scope="col">Операторы</th> + </tr> + </thead> + <tbody> + <tr> + <td>свойство объекта</td> + <td><code>. []</code></td> + </tr> + <tr> + <td>вызов, создание экземпляра объекта</td> + <td><code>() new</code></td> + </tr> + <tr> + <td>отрицание, инкремент</td> + <td><code>! ~ - + ++ -- typeof void delete</code></td> + </tr> + <tr> + <td>умножение, деление</td> + <td><code>* / %</code></td> + </tr> + <tr> + <td>сложение, вычитание</td> + <td><code>+ -</code></td> + </tr> + <tr> + <td>побитовый сдвиг</td> + <td><code><< >> >>></code></td> + </tr> + <tr> + <td>сравнение, вхождение</td> + <td><code>< <= > >= in instanceof</code></td> + </tr> + <tr> + <td>равенство</td> + <td><code>== != === !==</code></td> + </tr> + <tr> + <td>битовое-и</td> + <td><code>&</code></td> + </tr> + <tr> + <td>битовое-исключающее-или</td> + <td><code>^</code></td> + </tr> + <tr> + <td>битовое-или</td> + <td><code>|</code></td> + </tr> + <tr> + <td>логическое-и</td> + <td><code>&&</code></td> + </tr> + <tr> + <td>логическое-или</td> + <td><code>||</code></td> + </tr> + <tr> + <td>условный (тернарный) оператор</td> + <td><code>?:</code></td> + </tr> + <tr> + <td>присваивание</td> + <td><code>= += -= *= /= %= <<= >>= >>>= &= ^= |=</code></td> + </tr> + <tr> + <td>запятая</td> + <td><code>,</code></td> + </tr> + </tbody> +</table> + +<p>Более подробная версия данной таблицы, содержащая ссылки и дополнительную информацию по каждому оператору, находится в <a href="/ru/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table">справочнике JavaScript</a>.</p> + +<h2 id="Выражения">Выражения</h2> + +<p><em>Выражением </em>является любой корректный блок кода, который возвращает значение.</p> + +<p>Концептуально, существуют два типа выражений: те которые присваивают переменной значение, и те, которые вычисляют значение без его присваивания.</p> + +<p>Выражение <code>x = 7</code> является примером выражения первого типа. Данное выражение использует <em>оператор</em> = для присваивания переменной<span style="line-height: 1.5;"> </span><code style="font-style: normal; line-height: 1.5;">x </code><span style="line-height: 1.5;">значения 7</span><span style="line-height: 1.5;">. Само выражение также равняется 7.</span></p> + +<p>Код <code>3 + 4</code> является примером выражения второго типа. Данное выражение использует <em>оператор</em><span style="line-height: 1.5;"> "+" для сложения чисел 3 и 4 без присваивания переменной полученного результата 7.</span></p> + +<p>Все выражения в JavaScript делятся на следующие категории:</p> + +<ul> + <li><strong>Арифметические</strong>: вычисляются в число, например: 3.14159 (Используют {{ web.link("#Arithmetic_operators", "арифметические операторы") }}).</li> + <li><strong>Строковые</strong>: вычисляются в текстовую строку, например: "Fred" или "234" (Используют {{ web.link("#String_operators", "строковые операторы") }}).</li> + <li><strong>Логические</strong>: вычисляются в true или false (Используют {{ web.link("#Logical_operators", "логические операторы") }}).</li> + <li><strong>Основные выражения</strong>: Базовые ключевые слова и основные выражения в JavaScript.</li> + <li><strong>Левосторонние выражения</strong>: Значениям слева назначаются значения справа.</li> +</ul> + +<h3 id="Основные_выражения">Основные выражения</h3> + +<p>Базовые ключевые слова и основные выражения в JavaScript.</p> + +<h4 id="this" name="this">Оператор <code>this</code></h4> + +<p>Используйте ключевое слово <code>this</code> для указания на текущий объект. В общем случае <code>this</code> указывает на вызываемый объект, которому принадлежит данный метод. Используйте <code>this</code> следующим образом:</p> + +<pre class="syntaxbox">this["propertyName"] +this.propertyName +</pre> + +<p>Предположим, функция <code>validate</code> выполняет проверку свойства <code>value</code> некоторого объекта; задан объект, а также верхняя и нижняя граница величины данного свойства:</p> + +<pre class="brush: js">function validate(obj, lowval, hival){ + if ((obj.value < lowval) || (obj.value > hival)) + alert("Неверное значение!"); +} +</pre> + +<p>Вы можете вызвать функцию <code>validate</code> для обработчика события <code>onChange</code> для каждого элемента формы, используя <code>this</code> для указания на элемент формы, как это показано в следующем примере:</p> + +<pre class="brush: html"><B>Введите число от 18 до 99:</B> +<INPUT TYPE="text" NAME="age" SIZE=3 + onChange="validate(this, 18, 99);"> +</pre> + +<h4 id="Оператор_группировки">Оператор группировки</h4> + +<p>Оператор группировки <code>"скобки" ( )</code> контролирует приоритет вычисления выражений. Например, вы можете переопределить порядок - "умножение и деление, а потом сложение и вычитание", так чтобы, например, чтобы сложение выполнялось до умножения:</p> + +<pre class="brush: js">var a = 1; +var b = 2; +var c = 3; + +// обычный порядок +a + b * c // 7 +// выполняется, как обычно, так +a + (b * c) // 7 + +// теперь поменяем порядок +// сложение до умножения +(a + b) * c // 9 + +// что эквивалентно следующему +a * c + b * c // 9</pre> + +<h4 id="Упрощенный_синтаксис_создания_массивов_и_генераторов">Упрощенный синтаксис создания массивов и генераторов</h4> + +<p>Упрощенный синтаксис - экспериментальная возможность JavaScript, которая возможно будет добавлена в будущие версии ECMAScript. Есть 2 версии синтаксиса:</p> + +<dl> + <dt>{{experimental_inline}} {{jsxref("Operators/Array_comprehensions", "[for (x of y) x]")}}</dt> + <dd>Упрощенный синтаксис для массивов.</dd> + <dt>{{experimental_inline}} {{jsxref("Operators/Generator_comprehensions", "(for (x of y) y)")}}</dt> + <dd>Упрощенный синтаксис для генераторов.</dd> +</dl> + +<p>Упрощенные синтаксисы существуют во многих языках программирования и позволяют вам быстро собирать новый массив, основанный на существующем. Например:</p> + +<pre class="brush: js">[for (i of [ 1, 2, 3 ]) i*i ]; +// [ 1, 4, 9 ] + +var abc = [ "A", "B", "C" ]; +[for (letters of abc) letters.toLowerCase()]; +// [ "a", "b", "c" ]</pre> + +<h3 id="Левосторонние_выражения">Левосторонние выражения</h3> + +<p>Значениям слева назначаются значения справа.</p> + +<h4 id="new" name="new"><code>new</code></h4> + +<p>Вы можете использовать <a href="/ru/docs/Web/JavaScript/Reference/Operators/new">оператор <code>new</code></a> для создания экземпляра объекта пользовательского типа или одного из встроенных объектов. Используйте оператор <code>new</code> следующим образом:</p> + +<pre class="brush: js">var objectName = new objectType([param1, param2, ..., paramN]); +</pre> + +<h4 id="super">super</h4> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/super">Ключевое слово</a> используется, чтобы вызывать функции родительского объекта. Это полезно и с <a href="/ru/docs/Web/JavaScript/Reference/Classes">классами</a> для вызова конструктора родителя, например.</p> + +<pre class="brush: js">super([arguments]); // вызывает конструктор родителя. super.functionOnParent([arguments]);</pre> + +<h4 id="Оператор_расширения">Оператор расширения</h4> + +<p><a href="/ru/docs/Web/JavaScript/Reference/Operators/Spread_operator">Оператор расширения</a> позволяет выражению расширяться в местах с множеством аргументов (для вызовов функций) или множестве элементов (для массивов).</p> + +<p><strong>Пример:</strong> Сегодня, если у вас есть массив и вы хотите создать новый с существующей частью первого, то литерального синтаксиса массива уже не достаточно, и вы должны писать императивный (без вариантов) код, используя комбинацию <code>push</code>, <code>splice</code>, <code>concat</code> и т.д. Но с этим оператором код становится более коротким:</p> + +<pre class="brush: js">var parts = ['shoulder', 'knees']; +var lyrics = ['head', ...parts, 'and', 'toes'];</pre> + +<p>Похожим образом оператор работает с вызовами функций:</p> + +<pre class="brush: js">function f(x, y, z) { } +var args = [0, 1, 2]; +f(...args);</pre> + +<p>{{PreviousNext("Web/JavaScript/Guide/Functions", "Web/JavaScript/Guide/Numbers_and_dates")}}</p> + +<h3 id="sect1"> </h3> + +<h2 id="sect2"> </h2> + +<ul> +</ul> |