path: root/files/ru/web/javascript/guide/expressions_and_operators/index.html

---
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 &lt;&lt;= y</code></td>
   <td><code>x = x &lt;&lt; y</code></td>
  </tr>
  <tr>
   <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Right_shift_assignment">Присваивание с правым сдвигом</a></td>
   <td><code>x &gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt; 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 &gt;&gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt;&gt; 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 &amp;= y</code></td>
   <td><code>x = x &amp; 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>&gt;</code>)</td>
   <td>Возвращает true, если операнд слева больше операнда справа.</td>
   <td><code>var2 &gt; var1<br>
    "12" &gt; 2</code></td>
  </tr>
  <tr>
   <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Greater_than_or_equal_operator">Больше или равно</a> (<code>&gt;=</code>)</td>
   <td>Возвращает true, если операнд слева больше или равен операнду справа.</td>
   <td><code>var2 &gt;= var1<br>
    var1 &gt;= 3</code></td>
  </tr>
  <tr>
   <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_operator">Меньше</a> (<code>&lt;</code>)</td>
   <td>Возвращает true, если операнд слева меньше операнда справа.</td>
   <td><code>var1 &lt; var2<br>
    "2" &lt; 12</code></td>
  </tr>
  <tr>
   <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Операторы_сравнения#Less_than_or_equal_operator">Меньше или равно</a> (<code>&lt;=</code>)</td>
   <td>Возвращает true, если операнд слева меньше или равен операнду справа.</td>
   <td><code>var1 &lt;= var2<br>
    var2 &lt;= 5</code></td>
  </tr>
 </tbody>
</table>

<div class="note">
<p><strong>Замечание: </strong>(<strong>=&gt;</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 &amp; 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 &lt;&lt; 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 &gt;&gt; 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 &gt;&gt;&gt; b</code></td>
   <td>Сдвигает <code>a</code> в двоичном представлении на <code>b</code> бит вправо, отбрасывая сдвигаемые биты и добавляя слева нули.</td>
  </tr>
 </tbody>
</table>

<h4 id="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 &amp; 9</code></td>
   <td><code>9</code></td>
   <td><code>1111 &amp; 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">Битовые операторы сдвига</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#&lt;&lt;_(Left_shift)">Сдвиг влево</a><br>
    (<code>&lt;&lt;</code>)</td>
   <td>Данный оператор сдвигает первый операнд на указанное количество бит влево. Излишние биты, сдвинутые влево, отбрасываются. Справа число дополняется нулевыми битами.</td>
   <td><code>9&lt;&lt;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>&gt;&gt;</code>)</td>
   <td>Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется копиями крайнего слева бита.</td>
   <td><code>9&gt;&gt;2</code> равно 2, так как 1001 после сдвига на 2 бита вправо превращается в 10, что соответствует числу 2. Подобным же образом <code>-9&gt;&gt;2</code> равно -3, так как знак сохраняется.</td>
  </tr>
  <tr>
   <td><a href="/ru/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#>>>_(Zero-fill_right_shift)">Сдвиг вправо с заполнением нулями</a> (<code>&gt;&gt;&gt;</code>)</td>
   <td>Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется нулевыми битами.</td>
   <td><code>19&gt;&gt;&gt;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> обычно используются с булевыми (логическими) значениями; при этом возвращаемое ими значение также является булевым. Однако операторы &amp;&amp; и || фактически возвращают значение одного из операндов, поэтому, если эти операторы используются с небулевыми величинами, то возвращаемая ими величина также может быть не булевой. Логические операторы описаны в следующей таблице.</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>&amp;&amp;</code>)</td>
   <td><code>expr1 &amp;&amp; expr2</code></td>
   <td>(Логическое И) Возвращает операнд <code>expr1</code>, если он может быть преобразован в <code>false</code>; в противном случае возвращает операнд <code>expr2</code>. Таким образом, при использовании булевых величин в качестве операндов, оператор <code>&amp;&amp;</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>Следующий код демонстрирует примеры использования оператора &amp;&amp; (логическое И).</p>

<pre class="brush: js">var a1 =  true &amp;&amp; true;     // t &amp;&amp; t возвращает true
var a2 =  true &amp;&amp; false;    // t &amp;&amp; f возвращает false
var a3 = false &amp;&amp; true;     // f &amp;&amp; t возвращает false
var a4 = false &amp;&amp; (3 == 4); // f &amp;&amp; f возвращает false
var a5 = "Cat" &amp;&amp; "Dog";    // t &amp;&amp; t возвращает Dog
var a6 = false &amp;&amp; "Cat";    // f &amp;&amp; t возвращает false
var a7 = "Cat" &amp;&amp; false;    // t &amp;&amp; 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">Сокращённая оценка</h4>

<p>Так как логические выражения вычисляются слева направо, они проверяются на возможность выполнения сокращённой оценки с использованием следующих правил:</p>

<ul>
 <li><code>false</code> &amp;&amp; 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="Условный_(тернарный)_оператор">Условный (тернарный) оператор</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 &gt;= 18) ? "adult" : "minor";
</pre>

<p>Данное выражение присваивает значение "adult" переменной <code>status</code>, если <code>age</code> имеет значение 18 или более. В противном случае переменной <code>status</code> присваивается значение "minor".</p>

<h3 id="Оператор_запятая">Оператор запятая</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 &lt;= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
</pre>

<h3 id="Унарные_операторы">Унарные операторы</h3>

<p>Унарная операция - операция только с одним операндом.</p>

<h4 id="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"><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"><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">&lt;A HREF="javascript:void(0)"&gt;Нажмите здесь, чтобы ничего не произошло&lt;/A&gt;
</pre>

<p>Приведённый ниже код создаёт гипертекстовую ссылку, которая подтверждает отправку формы при клике на ней пользователем:</p>

<pre class="brush: html">&lt;A HREF="javascript:void(document.form.submit())"&gt;
Нажмите здесь, чтобы подтвердить отправку формы&lt;/A&gt;</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">Оператор <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>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</code></td>
  </tr>
  <tr>
   <td>сравнение, вхождение</td>
   <td><code>&lt; &lt;= &gt; &gt;= in instanceof</code></td>
  </tr>
  <tr>
   <td>равенство</td>
   <td><code>== != === !==</code></td>
  </tr>
  <tr>
   <td>битовое-и</td>
   <td><code>&amp;</code></td>
  </tr>
  <tr>
   <td>битовое-исключающее-или</td>
   <td><code>^</code></td>
  </tr>
  <tr>
   <td>битовое-или</td>
   <td><code>|</code></td>
  </tr>
  <tr>
   <td>логическое-и</td>
   <td><code>&amp;&amp;</code></td>
  </tr>
  <tr>
   <td>логическое-или</td>
   <td><code>||</code></td>
  </tr>
  <tr>
   <td>условный (тернарный) оператор</td>
   <td><code>?:</code></td>
  </tr>
  <tr>
   <td>присваивание</td>
   <td><code>= += -= *= /= %= &lt;&lt;= &gt;&gt;= &gt;&gt;&gt;= &amp;= ^= |=</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">Оператор <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 &lt; lowval) || (obj.value &gt; hival))
    alert("Неверное значение!");
}
</pre>

<p>Вы можете вызвать функцию <code>validate</code> для обработчика события <code>onChange</code> для каждого элемента формы, используя <code>this</code> для указания на элемент формы, как это показано в следующем примере:</p>

<pre class="brush: html">&lt;B&gt;Введите число от 18 до 99:&lt;/B&gt;
&lt;INPUT TYPE="text" NAME="age" SIZE=3
   onChange="validate(this, 18, 99);"&gt;
</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"><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>