path: root/files/ru/conflicting/web/javascript/reference/operators_69135a8d5772f8b6e45265523df05d89/index.html

---
title: Операторы сравнения
slug: >-
  conflicting/Web/JavaScript/Reference/Operators_69135a8d5772f8b6e45265523df05d89
tags:
  - JavaScript
  - Операторы
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators
original_slug: Web/JavaScript/Reference/Operators/Операторы_сравнения
---
<div>{{jsSidebar("Operators")}}</div>

<p>В JavaScript имеются как строгие сравнения, так и сравнения с преобразованием типа операндов. Строгие сравнения (к примеру, ===) истинны только в том случае, если типы сравниваемых значений являются одинаковыми (к примеру: string-string, number-number). Однако, чаще используются сравнения с преобразованием типов (к примеру, ==). Такой тип сравнения, перед тем как непосредственно выполнить сравнение, приводит операнды к одному типу. В случае же абстрактного реляционного сравнения, операнды сперва преобразуются в примитивы, затем приводятся к одному типу, и только после этого сравниваются.</p>

<p>Строки сравниваются на основе стандартного лексикографического упорядочения, используя значения Unicode.</p>

<p>Особенности сравнений:</p>

<ul>
 <li>Две строки строго равны только в том случае, если они имеют одинаковую длину, и те же символы в одинаковой последовательности и соответствующих позициях.</li>
 <li>Два числа строго равны в том случае, если они численно равны. <a href="/ru/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="NaN">NaN</a> не равно ничему, в том числе и NaN. Нули с положительным и отрицательным знаком равны.</li>
 <li>Два логических значения (boolean) равны только в том случае, если они оба <code>истинны (true)</code> или <code>ложны (false</code>).</li>
 <li>Два различных объекта никогда не равны как в строгих, так и в абстрактных сравнениях.</li>
 <li>Сравнение объекта истинно лишь в том случае, если оба операнда ссылаются на один и тот же объект в памяти.</li>
 <li>Виды <code>null</code> и <code>undefined</code> равны себе как в строгом сравнении, так и в абстрактном.</li>
</ul>

<p><strong>При использовании сравнения с преобразованием типов, следует быть крайне осторожным, так как это может привести к непредвиденным проблемам, связанным с особенностями конвертации различных типов (см. параграф "Использование операторов равенства").</strong></p>

<h2 id="Операторы_равенства">Операторы равенства</h2>

<h3 id="Равно"><a name="Equality">Равно (==)</a></h3>

<p><em>Оператор равно</em> сначала приводит операнды к одному типу, и затем применяет строгое сравнение. Если оба операнда являются объектами, то JavaScript сравнивает внутренние ссылки, которые равны в том случае, если они ссылаются на один и тот же объект в памяти.</p>

<h4 id="Синтаксис">Синтаксис</h4>

<pre class="syntaxbox notranslate">x == y
</pre>

<h4 id="Примеры">Примеры</h4>

<pre class="brush: js notranslate"> 1  ==  1      // истина
"1" ==  1      // истина
 1  == '1'     // истина
 3  ==  5      // ложь
 0  == false   // истина
"foo" == "bar" // ложь
</pre>

<h3 id="Не_равно_!"><a name="Inequality">Не равно (!=)</a></h3>

<p><em>Оператор не равно</em> возвращает <code>true</code> в том случае, если операнды не равны.<em>Он </em>аналогичен оператору равенства, перед сравнением приводит операнды к одному типу. В случае если оба операнда являются объектами,  JavaScript сравнивает внутренние ссылки, которые не равны в том случае, если относятся к разным объектам в памяти.</p>

<h4 id="Синтаксис_2">Синтаксис</h4>

<pre class="syntaxbox notranslate">x != y</pre>

<h4 id="Примеры_2">Примеры</h4>

<pre class="brush: js notranslate">1 !=   2       // истина
1 !=  "1"      // ложь
1 !=  '1'      // ложь
1 !=  true     // ложь
0 !=  false    // ложь
"foo" != "bar" // истина
</pre>

<h3 id="Строго_равно"><a name="Identity">Строго равно (===)</a></h3>

<p>Оператор возвращает истину в том случае, если операнды строго равны (см. выше). В отличие от <em>оператора равно</em>, данный оператор <strong>не приводит операнды к одному типу.</strong></p>

<h4 id="Синтаксис_3">Синтаксис</h4>

<pre class="syntaxbox notranslate">x === y</pre>

<h4 id="Примеры_3">Примеры</h4>

<pre class="brush: js  notranslate">3 === 3   // истина
3 === '3' // ложь
'foo' === 'foo' // истина
</pre>

<h3 id="Строго_не_равно_!"><a name="Nonidentity">Строго не равно (!==)</a></h3>

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

<h4 id="Синтаксис_4">Синтаксис</h4>

<pre class="syntaxbox notranslate">x !== y</pre>

<h4 id="Примеры_4">Примеры</h4>

<pre class="brush: js notranslate">3 !== '3' // истина
4 !== 3   // истина
</pre>

<h2 id="Операторы_сравнения">Операторы сравнения</h2>

<h3 id="Больше_>"><a name="Greater_than_operator">Больше (&gt;)</a></h3>

<p><em>Оператор больше</em> возвращает истину в том случае, если значение левого операнда больше, чем правого.</p>

<h4 id="Синтаксис_5">Синтаксис</h4>

<pre class="syntaxbox notranslate">x &gt; y</pre>

<h4 id="Примеры_5">Примеры</h4>

<pre class="brush: js notranslate">4 &gt; 3 // истина
1 &gt; 5 // ложь
</pre>

<h3 id="Больше_или_равно_>"><a name="Greater_than_or_equal_operator">Больше или равно (&gt;=)</a></h3>

<p><em>Оператор больше или равно, </em>возвращает истину в том случае, если значение операнда слева больше или равно значению операнда справа.</p>

<h4 id="Синтаксис_6">Синтаксис</h4>

<pre class="syntaxbox notranslate"> x &gt;= y</pre>

<h4 id="Примеры_6">Примеры</h4>

<pre class="brush: js notranslate">4 &gt;= 3 // истина
3 &gt;= 3 // истина
</pre>

<h3 id="Меньше&lt;"><a name="Less_than_operator">Меньше(&lt;)</a></h3>

<p><em>Оператор меньше, </em>возвращает истину в том случае, если значение операнда слева меньше, чем значение операнда справа.</p>

<h4 id="Синтаксис_7">Синтаксис</h4>

<pre class="syntaxbox notranslate"> x &lt; y</pre>

<h4 id="Примеры_7">Примеры</h4>

<pre class="brush: js notranslate">3 &lt; 4 // истина
5 &lt; 2 // ложь
</pre>

<h3 id="Меньше_или_равно_&lt;"><a id="Less_than_or_equal_operator" name="Less_than_or_equal_operator">Меньше или равно (&lt;=)</a></h3>

<p><em>Оператор меньше или равно, </em>возвращает истину в том случае, если значение операнда слева меньше, или равно значению операнда справа.</p>

<h4 id="Синтаксис_8">Синтаксис</h4>

<pre class="syntaxbox notranslate"> x &lt;= y</pre>

<h4 id="Примеры_8">Примеры</h4>

<pre class="brush: js notranslate">3 &lt;= 4 // истина
3 &lt;= 3 // истина
</pre>

<h2 id="Использование_операторов_равенства">Использование операторов равенства</h2>

<p>Стандартные операции равенства с преобразованием типов (<code>==</code> и <code>!=</code>) используют <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">Абстрактный Алгоритм Эквивалентного Сравнения</a> для сравнения двух операндов. Если у операндов различные типы, то JavaScript пытается привести их к одному типу, перед тем как сравнивать их. К примеру, в выражении <code>5 == '5'</code>, строка справа конвертируется в число, и только потом сравнивается.</p>

<p><em>Операторы строгого равентсва</em> (<code>===</code> и <code>!==</code>) используют Строгий Алгоритм Эквивалентного Сравнения, и предназначены для сравнения операндов одного типа. <strong>Если операнды имеют разные типы, то результат операции сравнения всегда будет ложью.</strong> К примеру, выражение <code>5 !== '5'</code> будет истинным.</p>

<p>Используйте <em>операторы строгого равенства</em> в тех случаях, когда необходимо проверять не только значения операндов, но так же и их типы. Во противном случае, используйте операторы стандартного равенства, которые позволяют сравнить два операнда вне зависимости от их типов.</p>

<p>Когда происходит преобразование типов (т.е в случаях использования нестрогого сравнения), JavaScript преобразует типы String, Number, Boolean и Object, следующим образом:</p>

<ul>
 <li>При сравнении числа <code>(Number)</code> и строки <code>(String)</code>, JavaScript пытается преобразовать числовой литерал строки в число. Затем полученное число округляется до ближайшего возможного значения типа <code>Number</code>.</li>
 <li>Если один из операндов является логическим <code>(Boolean)</code>, то он преобразуется в значение типа <code>(Number)</code>. <strong>Если значение логического операнда равняется истине <code>(true)</code>, то значение этого операнда преобразуется в 1. Иначе - в 0 <code>(ложь / false)</code>.</strong></li>
 <li>Если объект сравнивается с числом или строкой, JavaScript пытается получить значение по умолчанию для данного объекта. Полученное значение преобразуется в примитив, посредством методов <strong><code>valueOf()</code></strong> и <strong><code>toString()</code></strong>. Если преобразовать объект не удается, генерируется ошибка времени выполнения.</li>
 <li>Обратите внимание на то, что объект преобразуется в примитив, если, и только если, второй операнд является примитивом. В ином случае, операнды сравниваются как объекты, соответственно, операция сравнения вернет истину в том случае, если внутренние ссылки обоих объектов ссылаются на один и тот же объект в памяти.</li>
</ul>

<div class="note"><strong>Внимание:</strong> Объекты String имеют тип Object, а не String. Такие объекты используются редко, так что следующий код может вас сильно удивить.</div>

<pre class="brush:js notranslate">// Истина, так как оба операнда имеют тип String
'foo' === 'foo'

var a = new String('foo');
var b = new String('foo');

// Ложь, так как операнды являются объектами, внутренние ссылки которых, ссылаются на разные объекты в памяти
a == b

// Ложь, так как операнды являются объектами, внутренние ссылки которых, ссылаются на разные объекты в памяти
a === b

// Истина, так как объект a (String) будет преобразован в строку 'foo', перед сопоставлением
a == 'foo' </pre>

<h2 id="Спецификации">Спецификации</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Спецификация</th>
   <th scope="col">Статус</th>
   <th scope="col">Комментарий</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Появление в спецификации. Выполняется в JavaScript 1.0</td>
  </tr>
  <tr>
   <td>{{SpecName('ES3')}}</td>
   <td>{{Spec2('ES3')}}</td>
   <td>Добавлены операторы <code>===</code> и <code>!==</code>. Выполняется в JavaScript 1.3</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.8')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td>Определено в нескольких секциях спецификации: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Относительные операторы</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Операторы равенства</a></td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-relational-operators')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Определено в нескольких секциях спецификации: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Относительные операторы</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Операторы равенства</a></td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td>Определено в нескольких секциях спецификации: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Относительные операторы</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Операторы равенства</a></td>
  </tr>
 </tbody>
</table>

<h2 id="Поддержка_браузерами">Поддержка браузерами</h2>

<p>{{CompatibilityTable}}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th></th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td>Базовая поддержка</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>
    <p>{{CompatVersionUnknown}}</p>
   </td>
  </tr>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table" style="height: 73px; width: 1078px;">
 <tbody>
  <tr>
   <th></th>
   <th>Android</th>
   <th>Chrome for Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td>Базовая поддержка</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
 </tbody>
</table>
</div>

<h2 id="Смотрите_также"><br>
 Смотрите также</h2>

<ul>
 <li>{{jsxref("Object.is()")}}</li>
 <li><a href="/ru/docs/Web/JavaScript/Equality_comparisons_and_sameness">Операторы сравнения и одинаковость</a></li>
</ul>