Если вы создаете веб-приложение или защищенную страницу, вы всегда должны использовать (только когда это возможно)

===

потому что он проверит, является ли это одним и тем же содержимым и одного типа!

поэтому, когда кто-то входит:

var check = 1;
if(check == '1') {
    //someone continued with a string instead of number, most of the time useless for your webapp, most of the time entered by a user who does not now what he is doing (this will sometimes let your app crash), or even worse it is a hacker searching for weaknesses in your webapp!
}

но с

var check = 1;
if(check === 1) {
    //some continued with a number (no string) for your script
} else {
    alert('please enter a real number');
}

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

Я хочу сказать, что

===

добавит безопасности вашим скриптам

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

Причина, по которой я опубликовал это, заключается в том, что в этом разговоре никогда не использовалось слово «более безопасный» или «безопасность» (если вы посмотрите на iCloud.com, он использует 2019 раз === и 1308 раз ==, это также означает, что вы иногда используйте == вместо ===, потому что в противном случае это заблокирует вашу функцию, но, как сказано в начале, вы должны использовать === как можно чаще)

Мой процесс рассуждений с использованием emacs org-mode и node.js для запуска теста.

| use ==     | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | t     | f       | f         | f    | f          |
| '0'        |    | x   | t     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | t          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | t    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          | 



| use ===    | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | f     | f       | f         | f    | f          |
| '0'        |    | x   | f     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | f          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | f    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          |

Мой тестовый скрипт ниже: run> node xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
var colItems = rowItems

for(var i = 0; i < rowItems.length; i++) {
    for (var j = 0; j < colItems.length; j++) {
        var r = (rowItems[i] === colItems[j]) ? true : false;
        console.log(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
    };
}

=== заботится о том, совпадают ли объекты. Следовательно, new String("Hello world") === "Hello world" возвращает false. Однако == не заботится о том, совпадают ли объекты; он просто преобразует один аргумент в тип другого: если преобразование невозможно, верните false. Тогда new String("Hello world") == "Hello world" возвращает true вместо false.

JavaScript - это слабо типизированный язык, т.е. без каких-либо типов данных, как в C, например, C ++. int, boolean, float и т. д., таким образом, переменная может содержать любой тип значения, поэтому существуют эти специальные операторы сравнения

Eg

var i = 20;var j = "20";

если мы применим операторы сравнения, результат этих переменных будет

i==j //result is true

or

j != i//result is false

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

if we do

i===j //result is false

Разные между =, = =, = = =

• Оператор = Используется только для присвоения value.
• Оператор = = Используется для простого сравнения values, а не datatype
• Оператор = = = Используется для сравнения values и datatype.

Оператор == просто сравнивает значения, а не тип данных.

Оператор === сравнивает значения со сравнением своего типа данных.

eg :

1 == "1" //true

1 === "1" //false

Этот оператор ("===") используется в языках, которые выполняют автоматическое приведение типов, например. PHP, Javascript.
Оператор "===" помогает предотвратить неожиданное сравнение, вызванное автоматическим приведением типов.

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

Да, существует большая разница между операторами равенства == и идентификатора ===.
Обычно оператор идентификации работает быстрее, потому что преобразование типов не выполняется. Но если значения одного типа, вы не увидите никакой разницы.
Посмотрите мой пост Легенда оператора равенства JavaScript, в которой объясняются детали, включая алгоритмы преобразования и сравнения типов, с множеством примеров.

Одна неупомянутая причина использования === - это случай, когда вы сосуществуете с / кросс-компиляцией в / из coffee-script. Из Маленькой книжки по CoffeeScript ...

Слабое сравнение на равенство в JavaScript ведет к путанице и часто является источником сбивающих с толку ошибок.

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

Если вы регулярно конвертируете в coffee-script и обратно, вам следует просто использовать ===. Фактически, компилятор coffee-script заставит вас ...

CoffeeScript решает эту проблему, просто заменяя все слабые сравнения строгими, другими словами, преобразовывая все компараторы == в ===. В CoffeeScript нельзя выполнять слабое сравнение на равенство, и при необходимости следует явно преобразовывать типы перед их сравнением.

Строгое равенство по большей части лучше

Тот факт, что Javascript - это слабо типизированный язык, должен постоянно находиться в вашем уме, когда вы работаете с ним. Пока структура данных одна и та же, действительно нет причин не использовать строгое равенство, при обычном равенстве часто происходит неявное преобразование значений, которое происходит автоматически, что может иметь далеко идущие последствия для вашего кода. Очень легко получить проблемы с этим преобразованием, поскольку они происходят автоматически.

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

Javascript типизирован так же, как и php,

var x = "20";
var y =20;

if (x===y) // false

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

Один - строка, другой - int

If(x==y)//true

Однако это просто проверяет, является ли контент одинаковым, независимо от типов данных ...

Я не хочу говорить, что значения равны, потому что строковое значение не может быть логически равно значению int

Во-первых, некоторая терминология о Javascript string equals: Double equals официально известна как оператор сравнения абстрактного равенства, а тройное равенство называется оператором сравнения строгого равенства. Различие между ними можно резюмировать следующим образом: абстрактное равенство будет пытаться разрешить типы данных посредством приведения типов перед выполнением сравнения. Строгое равенство вернет false, если типы разные. Рассмотрим следующий пример:

console.log(3 == "3"); // true
console.log(3 === "3"); // false.
console.log(3 == "3"); // true
console.log(3 === "3"); // false.

Использование двух знаков равенства возвращает истину, потому что строка «3» преобразуется в число 3 перед проведением сравнения. Три знака равенства означает, что типы разные, и возвращает false. Вот еще один:

console.log(true == '1'); // true
console.log(true === '1'); // false
console.log(true == '1'); // true
console.log(true === '1'); // false

Опять же, сравнение абстрактного равенства выполняет преобразование типа. В этом случае и логическое значение «истина», и строка «1» преобразуются в число 1, и результат будет истинным. Строгое равенство возвращает false.

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

console.log(undefined == null); // true
console.log(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.
console.log(undefined == null); // true     
console.log(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.

console.log(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
console.log(true === 'true'); // false
console.log(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
console.log(true === 'true'); // false

Пример ниже интересен тем, что он показывает, что строковые литералы отличаются от строковых объектов.

console.log("This is a string." == new String("This is a string.")); // true
console.log("This is a string." === new String("This is a string.")); // false
console.log("This is a string." == new String("This is a string.")); // true
console.log("This is a string." === new String("This is a string.")); // false

Причина, по которой предлагается заменить == на ===, заключается в том, что оператор === более надежен, чем ==. В нашем контексте надежные средства === также используются для проверки типов. Принимая во внимание лучшие практики программирования, мы всегда должны выбирать более надежную функцию вместо менее надежной. Опять же, когда мы большую часть времени думаем о точно равном оператору, мы по умолчанию считаем, что тип должен быть таким же. Поскольку === предоставляет то же самое, мы должны пойти на это.

Дилемма «Должен ли я использовать == или === при сравнении JavaScript» аналогична вопросу: «Следует ли мне использовать« ложку »или« вилку »для еды.

Единственный разумный ответ на этот вопрос:

1. Вы должны использовать сравнение динамического типа, например :== для сравнения свободного типа.
2. Вы должны использовать сравнение статического типа, например :=== для сравнения строгого типа.

Это потому, что они разные. Они не имеют той же цели и не предназначены для использования с той же целью.

Конечно, и вилки, и ложки предназначены для «еды», но вы решите использовать их в соответствии с тем, что вам подали.

Значение: вы решите использовать «ложку», например: == для приготовления «супа» и / или «вилку», например: === для сбора.

Спросить, лучше ли использовать «вилку» или «ложку» для «еды» - все равно что спросить, лучше ли использовать статический [===] или динамический [==] уравнение, op. в JS. Оба вопроса одинаково неверны и отражают очень узкое или поверхностное понимание предмета, о котором идет речь.

Используйте ===, если вы хотите сравнить несколько вещей в JavaScript, это называется строгое равенство, это означает, что возвращается истина, если только тип и значение одинаковы, поэтому не было бы для вас нежелательной коррекции типа, если вы используете ==, вы в основном не заботитесь о типе, и во многих случаях вы можете столкнуться с проблемами при слабом сравнении равенства.

Строгое равенство с использованием ===

Строгое равенство сравнивает два значения на равенство. Ни одно из значений не будет неявно преобразовано в какое-либо другое значение перед сравнением. Если значения имеют разные типы, значения считаются неравными. В противном случае, если значения имеют один и тот же тип и не являются числами, они считаются равными, если имеют одинаковое значение. Наконец, если оба значения являются числами, они считаются равными, если они оба не NaN и имеют одно и то же значение, или если одно из них равно +0, а второе --0.

var num = 0;
var obj = new String('0');
var str = '0';

console.log(num === num); // true
console.log(obj === obj); // true
console.log(str === str); // true

console.log(num === obj); // false
console.log(num === str); // false
console.log(obj === str); // false
console.log(null === undefined); // false
console.log(obj === null); // false
console.log(obj === undefined); // false

Свободное равенство с использованием ==

Свободное равенство сравнивает два значения на равенство после преобразования обоих значений в общий тип. После преобразований (одна или обе стороны могут быть преобразованы) окончательное сравнение на равенство выполняется точно так же, как это делает ===. Свободное равенство симметрично: A == B всегда имеет семантику, идентичную B == A для любых значений A и B (за исключением порядка применяемых преобразований).

var num = 0;
var obj = new String('0');
var str = '0';

console.log(num == num); // true
console.log(obj == obj); // true
console.log(str == str); // true

console.log(num == obj); // true
console.log(num == str); // true
console.log(obj == str); // true
console.log(null == undefined); // true

// both false, except in rare cases
console.log(obj == null);
console.log(obj == undefined);

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Увидел это в одном из ответов. a и b в этом случае не являются одним и тем же типом. Если вы отметите typeof(a), вы получите 'object', а typeof(b) будет 'string'.