--- 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>