JavaScript
Операции сравнения

замечания

Логические операторы с булевыми

var x = true,
    y = false;

А ТАКЖЕ

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

x && y;

Это вернет false, потому что y является ложным.

ИЛИ ЖЕ

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

x || y;

Это вернет true, потому что x истинно.

НЕ

Этот оператор вернет false, если выражение справа оценивается как true и возвращает true, если выражение справа оценивается как false.

!x;

Это вернет false, потому что x истинно.

Абстрактное равенство (==)

Операторы абстрактного оператора равенства сравниваются после преобразования в общий тип. Как это преобразование происходит на основе спецификации оператора:

Спецификация для оператора == :

7.2.13.

Сравнение x == y , где x и y - значения, создает true или false . Такое сравнение выполняется следующим образом:

1. Если Type(x) совпадает с Type(y) , то:

• а. Верните результат выполнения строгого сравнения равенств x === y .

2. Если x равно null а y не undefined , верните true .
3. Если x не undefined и y равно null , верните true .
4. Если Type(x) - Number и Type(y) - String , верните результат сравнения x == ToNumber(y) .
5. Если Type(x) - String и Type(y) - Number , верните результат сравнения ToNumber(x) == y .
6. Если Type(x) является Boolean , верните результат сравнения ToNumber(x) == y .
7. Если Type(y) является Boolean , верните результат comparison x == ToNumber(y) .
8. Если Type(x) является либо String , Number , либо Symbol и Type(y) - Object , верните результат сравнения x == ToPrimitive(y) .
9. Если Type(x) - Object и Type(y) - либо String , Number , либо Symbol , верните результат сравнения ToPrimitive(x) == y .
10. Вернуть false .

Примеры:

1 == 1;                     // true
1 == true;                  // true  (operand converted to number: true => 1)
1 == '1';                   // true  (operand converted to number: '1' => 1 )
1 == '1.00';                // true
1 == '1.00000000001';       // false
1 == '1.00000000000000001'; // true  (true due to precision loss)
null == undefined;          // true  (spec #2)
1 == 2;                     // false
0 == false;                 // true
0 == undefined;             // false
0 == "";                    // true

Реляционные операторы (<, <=,>,> =)

Когда оба операнда являются числовыми, их обычно сравнивают:

1 < 2        // true
2 <= 2       // true
3 >= 5       // false
true < false // false (implicitly converted to numbers, 1 > 0)

Когда оба операнда являются строками, они сравниваются лексикографически (в алфавитном порядке):

'a' < 'b'    // true
'1' < '2'    // true
'100' > '12' // false ('100' is less than '12' lexicographically!)

Когда один операнд является строкой, а другой - числом, строка перед сравнением преобразуется в число:

'1' < 2      // true
'3' > 2      // true
true > '2'   // false (true implicitly converted to number, 1 < 2)

Когда строка не является числовой, числовое преобразование возвращает NaN (не-число). Сравнение с NaN всегда возвращает false :

1 < 'abc'    // false
1 > 'abc'    // false

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

1 > ''        // true
1 < ''        // false
1 > null      // true
1 < null      // false
1 > undefined // false
1 < undefined // false

Когда один операнд является объектом, а другой - числом, объект преобразуется в число перед сравнением. null является частным случаем, потому что Number(null);//0

new Date(2015)< 1479480185280            // true
null > -1                                //true
({toString:function(){return 123}}) > 122  //true

Неравенство

Оператор != Является инверсией оператора == .
Вернет true если операнды не равны.
Механизм javascript попытается преобразовать оба операнда в соответствующие типы, если они не одного типа. Примечание: если два операнда имеют разные внутренние ссылки в памяти, то возвращается false .

Образец:

1 != '1'     // false
1 != 2       // true

В приведенном выше примере 1 != '1' false потому что примитивный тип числа сравнивается с значением char . Поэтому механизм Javascript не заботится о типе данных значения RHS.

Оператор !== - обратный оператор === . Вернет true, если операнды не равны или если их типы не совпадают.

Пример:

1 !== '1'    // true
1 !== 2      // true
1 !== 1      // false

Логические операторы с небулевыми значениями (булевское принуждение)

Логическое ИЛИ ( || ), читающее слева направо, будет оценивать первое значение правды . Если искомое значение не найдено, возвращается последнее значение.

var a = 'hello' || '';             // a = 'hello'
var b = '' || [];                  // b = []
var c = '' || undefined;           // c = undefined
var d = 1 || 5;                    // d = 1
var e = 0 || {};                   // e = {}
var f = 0 || '' || 5;              // f = 5
var g = '' || 'yay' || 'boo';      // g = 'yay'

Логическое И ( && ), читающее слева направо, будет оценивать первое значение фальшивки . Если значение ложности не найдено, возвращается последнее значение.

var a = 'hello' && '';                  // a = ''
var b = '' && [];                       // b = ''
var c = undefined && 0;                 // c = undefined
var d = 1 && 5;                         // d = 5
var e = 0 && {};                        // e = 0
var f = 'hi' && [] && 'done';           // f = 'done'
var g = 'bye' && undefined && 'adios';  // g = undefined

Этот трюк можно использовать, например, для установки значения по умолчанию для аргумента функции (до ES6).

var foo = function(val) {
    // if val evaluates to falsey, 'default' will be returned instead.
    return val || 'default';
}

console.log( foo('burger') );  // burger
console.log( foo(100) );       // 100
console.log( foo([]) );        // []
console.log( foo(0) );         // default
console.log( foo(undefined) ); // default

Просто имейте в виду, что для аргументов 0 и (в меньшей степени) пустая строка также часто является допустимыми значениями, которые должны быть явно переданы и переопределять значение по умолчанию, которое с этим шаблоном не будет (потому что они являются ложными ).

Null и Undefined

Различия между null и undefined

null и undefined доля абстрактного равенства == но не строгое равенство === ,

null == undefined   // true
null === undefined  // false

Они представляют несколько разные вещи:

• undefined представляет собой отсутствие значения , например, до создания свойства идентификатора / объекта или периода между созданием идентификатора / параметра функции и его первым набором, если таковой имеется.
• null представляет собой намеренное отсутствие значения для идентификатора или свойства, которое уже создано.

Это разные типы синтаксиса:

• undefined - это свойство глобального объекта , обычно неизменяемого в глобальном масштабе. Это означает, что везде, где вы можете определить идентификатор, отличный от глобального пространства имен, может скрываться undefined из этой области (хотя все еще может быть undefined )
• null - это буква буква , поэтому его значение никогда не может быть изменено, и попытка сделать это вызовет ошибку .

Сходства между null и undefined

null и undefined являются ложными.

if (null) console.log("won't be logged");
if (undefined) console.log("won't be logged");

Ни null ни undefined равно false (см. Этот вопрос ).

false == undefined   // false
false == null        // false
false === undefined  // false
false === null       // false

Использование undefined

• Если текущей области нельзя доверять, используйте то, что оценивается как неопределенное , например void 0; ,
• Если undefined затеняется другим значением, это так же плохо, как затенение Array или Number .
• Избегайте устанавливать что-то как undefined . Если вы хотите удалить панель свойств из объекта foo , delete foo.bar; вместо.
• Идентификатор тестирования foo от undefined может вызвать ссылку Error , вместо этого используйте typeof foo вместо "undefined" .

Свойство NaN глобального объекта

NaN (« N ot a N umber») - это специальное значение, определенное стандартом IEEE для арифметики с плавающей запятой , которое используется, когда предоставляется нечисловое значение, но ожидается число ( 1 * "two" ) или когда расчет не имеет действительное number результата ( Math.sqrt(-1) ).

Любое равенство или реляционное сравнение с NaN возвращает false , даже сравнивая его с самим собой. Так как NaN должен обозначать результат бессмысленного вычисления и, как таковой, он не равен результату каких-либо других бессмысленных вычислений.

(1 * "two") === NaN  //false

NaN === 0;          // false
NaN === NaN;        // false
Number.NaN === NaN; // false

NaN < 0;            // false
NaN > 0;            // false
NaN > 0;            // false
NaN >= NaN;         // false
NaN >= 'two';       // false

Неравновесные сравнения всегда будут возвращать true :

NaN !== 0;          // true
NaN !== NaN;        // true

Проверка значения NaN

Number.isNaN(NaN);         // true
Number.isNaN(0 / 0);       // true
Number.isNaN('str' - 12);  // true

Number.isNaN(24);          // false
Number.isNaN('24');        // false
Number.isNaN(1 / 0);       // false
Number.isNaN(Infinity);    // false

Number.isNaN('str');       // false
Number.isNaN(undefined);   // false
Number.isNaN({});          // false

value !== value;    // true for NaN, false for any other value

Number.isNaN = Number.isNaN || function(value) {     
    return value !== value;
}

Напротив, глобальная функция isNaN() возвращает true не только для NaN , но также для любого значения или выражения, которое не может быть принудительно введено в число:

isNaN(NaN);         // true
isNaN(0 / 0);       // true
isNaN('str' - 12);  // true

isNaN(24);          // false
isNaN('24');        // false
isNaN(Infinity);    // false

isNaN('str');       // true
isNaN(undefined);   // true
isNaN({});          // true

ECMAScript определяет алгоритм « SameValue », называемый SameValue который, поскольку ECMAScript 6, может быть вызван с Object.is . В отличие от сравнения == и === использование Object.is() будет рассматривать NaN как то же самое с самим собой (и -0 как не идентичное +0 ):

Object.is(NaN, NaN)      // true
Object.is(+0, 0)         // false

NaN === NaN              // false
+0 === 0                 // true

if (!Object.is) {
  Object.is = function(x, y) {
    // SameValue algorithm
    if (x === y) { // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  };
}

Вопросы для заметок

NaN - это число, означающее, что оно не равно строке «NaN» и, что наиболее важно (хотя, возможно, неинтуитивно):

typeof(NaN) === "number"; //true

Короткое замыкание в булевых операторах

Оператор ( && ) и or-operator ( || ) используют короткое замыкание для предотвращения ненужной работы, если результат операции не изменяется с дополнительной работой.

В x && y y не будет оцениваться, если x оценивает значение false , потому что все выражение гарантированно будет false .

В x || y , y не будет оцениваться, если x оценивается как true , поскольку гарантируется, что все выражение будет true .

Пример с функциями

Возьмите следующие две функции:

function T() { // True
  console.log("T");
  return true;
}

function F() { // False
  console.log("F");
  return false;
}

Пример 1

T() && F(); // false

Выход:

«Т»
'F'

Пример 2.

F() && T(); // false

Выход:

'F'

Пример 3.

T() || F(); // true

Выход:

«Т»

Пример 4.

F() || T(); // true

Выход:

'F'
«Т»

Короткое замыкание для предотвращения ошибок

var obj; // object has value of undefined
if(obj.property){ }// TypeError: Cannot read property 'property' of undefined
if(obj.property && obj !== undefined){}// Line A TypeError: Cannot read property 'property' of undefined

Строка A: если вы отмените порядок, первый условный оператор предотвратит ошибку на втором, не выполнив его, если он выкинет ошибку

if(obj !== undefined && obj.property){}; // no error thrown 

Но его следует использовать только в том случае, если вы ожидаете undefined

if(typeof obj === "object" && obj.property){}; // safe option but slower

Короткое замыкание для обеспечения значения по умолчанию

|| оператор может использоваться для выбора «правдивого» значения или значения по умолчанию.

Например, это можно использовать для обеспечения преобразования значения с нулевым значением в значение, не равное нулю:

var nullableObj = null;
var obj = nullableObj || {};  // this selects {}

var nullableObj2 = {x: 5};
var obj2 = nullableObj2 || {} // this selects {x: 5}

Или вернуть первое правдоподобное значение

var truthyValue = {x: 10};
return truthyValue || {}; // will return {x: 10}

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

envVariable || configValue || defaultConstValue // select the first "truthy" of these

Короткое замыкание для вызова дополнительной функции

Оператор && можно использовать для оценки обратного вызова, только если он передан:

function myMethod(cb) {
    // This can be simplified
    if (cb) {
       cb();
    }

    // To this
    cb && cb();
}

Конечно, вышеприведенный тест не подтверждает, что cb на самом деле является function а не просто Object / Array / String / Number .

Абстрактное равенство / неравенство и преобразование типов

Эта проблема

Абстрактные операторы равенства и неравенства ( == и != ) Преобразуют свои операнды, если типы операндов не совпадают. Такое принуждение является общим источником путаницы в отношении результатов этих операторов, в частности, эти операторы не всегда транзитивны, как и следовало ожидать.

"" ==  0;     // true A
 0 == "0";    // true A
"" == "0";    // false B
false == 0;   // true
false == "0"; // true

"" !=  0;     // false A
 0 != "0";    // false A
"" != "0";    // true B
false != 0;   // false
false != "0"; // false

Результаты начинают иметь смысл, если вы рассматриваете, как JavaScript преобразует пустые строки в числа.

Number("");    // 0
Number("0");   // 0
Number(false); // 0

Решение

В заявлении false B оба операнда являются строками ( "" и "0" ), следовательно, преобразование типа не будет, и поскольку "" и "0" не являются одинаковыми значениями, "" == "0" является false как и ожидалось.

Один из способов устранить неожиданное поведение здесь - убедиться, что вы всегда сравниваете операнды того же типа. Например, если вы хотите, чтобы результаты численного сравнения использовали явное преобразование:

var test = (a,b) => Number(a) == Number(b); 
test("", 0);        // true;
test("0", 0);       // true
test("", "0");      // true;
test("abc", "abc"); // false as operands are not numbers 

Или, если вам требуется сравнение строк:

var test = (a,b) => String(a) == String(b);
test("", 0);   // false;
test("0", 0);  // true
test("", "0"); // false;

Боковое примечание : Number("0") и new Number("0") - это одно и то же! В то время как первый выполняет преобразование типа, последний создает новый объект. Объекты сравниваются по ссылке, а не по значению, которое объясняет приведенные ниже результаты.

Number("0") == Number("0");         // true;
new Number("0") == new Number("0"); // false 

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

"" ===  0;  // false
 0 === "0"; // false
"" === "0"; // false

Дальнейшую ссылку на эту тему можно найти здесь:

Какой оператор равен (== vs ===) должен использоваться в сравнении JavaScript? ,

Абстрактное равенство (==)

Пустой массив

/* ToNumber(ToPrimitive([])) == ToNumber(false) */
[] == false; // true

Когда выполняется [].toString() он вызывает [].join() если он существует, или Object.prototype.toString() противном случае. Это сравнение возвращает true потому что [].join() возвращает '' который, принужденный к 0 , равен false ToNumber .

Остерегайтесь, однако, все объекты являются правдивыми, а Array - экземпляром Object :

// Internally this is evaluated as ToBoolean([]) === true ? 'truthy' : 'falsy'
[] ? 'truthy' : 'falsy'; // 'truthy'

Операции сравнения эквивалов

JavaScript имеет четыре различные операции сравнения сравнений.

SameValue

Он возвращает true если оба операнда принадлежат одному типу и имеют одно и то же значение.

Примечание: значение объекта является ссылкой.

Вы можете использовать этот алгоритм сравнения через Object.is (ECMAScript 6).

Примеры:

Object.is(1, 1);            // true
Object.is(+0, -0);          // false
Object.is(NaN, NaN);        // true
Object.is(true, "true");    // false
Object.is(false, 0);        // false
Object.is(null, undefined); // false
Object.is(1, "1");          // false
Object.is([], []);          // false

Этот алгоритм обладает свойствами отношения эквивалентности :

• Рефлексивность : Object.is(x, x) true , для любого значения x
• Симметрия : Object.is(x, y) true если и только если Object.is(y, x) true для любых значений x и y .
• Транзитивность : если Object.is(x, y) и Object.is(y, z) true , то Object.is(x, z) также true для любых значений x , y и z .

SameValueZero

Он ведет себя как SameValue, но считает, что +0 и -0 равны.

Вы можете использовать этот алгоритм сравнения через Array.prototype.includes (ECMAScript 7).

Примеры:

[1].includes(1);            // true
[+0].includes(-0);          // true
[NaN].includes(NaN);        // true
[true].includes("true");    // false
[false].includes(0);        // false
[1].includes("1");          // false
[null].includes(undefined); // false
[[]].includes([]);          // false

Этот алгоритм все еще обладает свойствами отношения эквивалентности :

• Рефлексивность : [x].includes(x) true , для любого значения x
• Симметрия : [x].includes(y) true если и только если [y].includes(x) true для любых значений x и y .
• Транзитивность : если [x].includes(y) и [y].includes(z) true , то [x].includes(z) также true для любых значений x , y и z .

Строгое сравнение равенства

Он ведет себя как SameValue, но

• Рассматривает +0 и -0 равными.
• Полагает, что NaN отличается от любой ценности, включая

Этот алгоритм сравнения можно использовать с помощью оператора === (ECMAScript 3).

Существует также оператор !== (ECMAScript 3), который отрицает результат === .

Примеры:

1 === 1;            // true
+0 === -0;          // true
NaN === NaN;        // false
true === "true";    // false
false === 0;        // false
1 === "1";          // false
null === undefined; // false
[] === [];          // false

Этот алгоритм обладает следующими свойствами:

• Симметрия : x === y это true , если, и только если у === х is верно , for any values х and y`.
• Транзитивность : если x === y и y === z true , то x === z также true для любых значений x , y и z .

Но это не отношение эквивалентности, потому что

• NaN не является рефлексивным : NaN !== NaN

Абстрактное сравнение равенства

Если оба операнда принадлежат одному типу, он ведет себя как сравнение строгого равенства.

В противном случае он их коэрцитирует следующим образом:

• undefined и null считаются равными
• При сравнении числа со строкой строка принуждается к числу
• Сравнивая логическое с чем-то другим, логическое число принудительно привязывается к числу
• При сравнении объекта с номером, строкой или символом объект принуждается к примитиву

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

Этот алгоритм сравнения можно использовать с помощью оператора == (ECMAScript 1).

Существует также оператор != (ECMAScript 1), который отрицает результат == .

Примеры:

1 == 1;            // true
+0 == -0;          // true
NaN == NaN;        // false
true == "true";    // false
false == 0;        // true
1 == "1";          // true
null == undefined; // true
[] == [];          // false

Этот алгоритм обладает следующим свойством:

• Симметрия : x == y true если и только если y == x true , для любых значений x и y .

Но это не отношение эквивалентности, потому что

• NaN не является рефлексивным : NaN != NaN
• Транзитивность не выполняется, например 0 == '' и 0 == '0' , но '' != '0'

Группирование нескольких логических операторов

Вы можете группировать несколько логических логических операторов в круглых скобках, чтобы создать более сложную логическую оценку, особенно полезную в операторах if.

if ((age >= 18 && height >= 5.11) || (status === 'royalty' && hasInvitation)) {
  console.log('You can enter our club');
}

Мы могли бы также переместить сгруппированную логику в переменные, чтобы сделать оператор немного короче и описательным:

var isLegal = age >= 18;
var tall = height >= 5.11;
var suitable = isLegal && tall;
var isRoyalty = status === 'royalty';
var specialCase = isRoyalty && hasInvitation;
var canEnterOurBar = suitable || specialCase;

if (canEnterOurBar) console.log('You can enter our club');

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

Автоматические преобразования типов

Остерегайтесь того, что числа могут быть случайно преобразованы в строки или NaN (Not a Number).

JavaScript свободно напечатан. Переменная может содержать разные типы данных, а переменная может изменять свой тип данных:

var x = "Hello";     // typeof x is a string
x = 5;               // changes typeof x to a number

При выполнении математических операций JavaScript может преобразовывать числа в строки:

var x = 5 + 7;       // x.valueOf() is 12,  typeof x is a number
var x = 5 + "7";     // x.valueOf() is 57,  typeof x is a string
var x = "5" + 7;     // x.valueOf() is 57,  typeof x is a string
var x = 5 - 7;       // x.valueOf() is -2,  typeof x is a number
var x = 5 - "7";     // x.valueOf() is -2,  typeof x is a number
var x = "5" - 7;     // x.valueOf() is -2,  typeof x is a number
var x = 5 - "x";     // x.valueOf() is NaN, typeof x is a number

Вычитая строку из строки, не генерирует ошибку, но возвращает NaN (Not a Number):

"Hello" - "Dolly"    // returns NaN

Список операторов сравнения

Бит-поля для оптимизации сравнения данных нескольких состояний

Поле бит - это переменная, которая содержит различные логические состояния как отдельные биты. Бит будет представлять true, а off будет ложным. В прошлом бит-поля обычно использовались, поскольку они сохраняли память и уменьшали нагрузку на обработку. Хотя необходимость использования битового поля уже не так важна, они предлагают некоторые преимущества, которые могут упростить многие задачи обработки.

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

Пример чтения клавиатуры через битовое поле

var bitField = 0;  // the value to hold the bits
const KEY_BITS = [4,1,8,2]; // left up right down
const KEY_MASKS = [0b1011,0b1110,0b0111,0b1101]; // left up right down
window.onkeydown = window.onkeyup = function (e) {
    if(e.keyCode >= 37 && e.keyCode <41){
        if(e.type === "keydown"){
            bitField |= KEY_BITS[e.keyCode - 37];
        }else{
            bitField &= KEY_MASKS[e.keyCode - 37];
        }
    }    
}

Пример чтения в виде массива

var directionState = [false,false,false,false];
window.onkeydown = window.onkeyup = function (e) {
    if(e.keyCode >= 37 && e.keyCode <41){
        directionState[e.keyCode - 37] = e.type === "keydown";
    }    
}

Чтобы включить бит, используйте поразрядные или | и значение, соответствующее бит. Поэтому, если вы хотите установить бит бит 2 бит, то bitField |= 0b10 его. Если вы хотите отключить бит, используйте побитовое и & со значением, которое имеет все необходимое для бит. Использование 4 бит и поворот битового bitfield &= 0b1101; 2-го бита bitfield &= 0b1101;

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

Если вы хотите проверить, все ли клавиши вверх.

// as bit field
if(!bitfield) // no keys are on

// as array test each item in array
if(!(directionState[0] && directionState[1] && directionState[2] && directionState[3])){

Вы можете установить некоторые константы, чтобы упростить

// postfix U,D,L,R for Up down left right
const KEY_U = 1;
const KEY_D = 2;
const KEY_L = 4;
const KEY_R = 8;
const KEY_UL = KEY_U + KEY_L; // up left
const KEY_UR = KEY_U + KEY_R; // up Right
const KEY_DL = KEY_D + KEY_L; // down left
const KEY_DR = KEY_D + KEY_R; // down right

Затем вы можете быстро проверить множество различных состояний клавиатуры

if ((bitfield & KEY_UL) === KEY_UL) { // is UP and LEFT only down
if (bitfield  & KEY_UL) {             // is Up left down 
if ((bitfield & KEY_U) === KEY_U) {   // is Up only down
if (bitfield & KEY_U) {               // is Up down (any other key may be down)
if (!(bitfield & KEY_U)) {            // is Up up (any other key may be down)
if (!bitfield ) {                     // no keys are down
if (bitfield ) {                      // any one or more keys are down

Ввод клавиатуры - всего лишь один пример. Битвые поля полезны, когда у вас есть различные состояния, которые должны в комбинации действовать. Javascript может использовать до 32 бит для битового поля. Использование их может значительно увеличить производительность. Они заслуживают внимания.