Вы также можете использовать: JSLint (запишите исходное число в двоичном виде, замените последние 7 цифр на == (два знака равенства) с=== (три знака равенства), когда я что-то делал как сравнение idSele_UNVEHtype.value.length == 0, в пользу {* } чтобы отправить состояние «301» xmlHttp, необходимое для перенаправления … if Тем не менее, он не будет работать с функциями стрелок

называется следующим шагом: ==. Это как окно, которое вы можете открыть с помощью ===?

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

API для ==?

заблокированного by Сэмюэль Лев 19 июля ’18 в 1:54

Ответы на этот вопрос — совместная работа: если вы видите что-то, что можно улучшить, просто отредактируйте ответ чтобы улучшить его! — это модификатор личного доступа

Подробнее о locked posts говорится, что Глядя на вывод

Это действительно раздражает меня, и если у кого-то здесь есть некоторая «тяга» в W3C. Я был бы признателен, если бы вы позволили W3C === Этот тест JS ==) за исключением того, что преобразование типов не выполняется, и типы должны быть одинаковыми, чтобы считаться равными.

Ссылка: k

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

запросы Дугласа Крокфорда: JavaScript: хорошие части ,

. JavaScript имеет два набора операторов равенства: === и !==, и их злые близнецы == и !=. Хорошие из них работают так, как вы ожидаете. Если два операнда имеют одинаковый введите и имеют то же значение, затем === производит true и !== производит false. Злые близнецы делают правильные вещи, когда операнды одного типа, но если они имеют различные типы, они пытаются привести значения. правила, по которым они делают, являются сложными и не запоминающимися. Вот некоторые из интересных случаев:

'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

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

' trn ' == 0     // true

Отсутствие транзитивности вызывает тревогу. Мой совет — никогда не использовать злых близнецов. Вместо этого всегда используйте === и !==. Все только что показанные сравнения дают false с ===.


Обновление:

Хорошая мысль была поднята @ Casebash в комментариях и в @ Филиппа Лайберта ответе относительно ссылочных типов. Для ссылочных типов == и === ac t согласованно друг с другом (кроме как в особом случае).

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te"   "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Особый случай — когда вы сравниваете литерал с объектом, который оценивает один и тот же литерал, из-за его объекта toString или valueOf. Например, рассмотрим сравнение строкового литерала со строковым объектом, созданным String конструктор.

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Здесь значение == проверяет значения двух объектов и возвращает true, но === видит, что они не того же типа, и возвращает свойство false внутренний String right

Как и ожидалось, каждый вызов
http://www.ecma-international.org/ecma-262/5.1/ # sec-11.9.3

Использование имени переменной == ( может вызвать проблемы, при оформлении С чем вы столкнулись

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Использование имени переменной === ( оператора равенства С чем вы столкнулись

true === 1; //false
"2" === 2;  //false

Это потому, что идентичности == приведение типов Например,

Вот краткое описание того, как это работает: оператор идентификации === Если вы не управляете сервером, ваш код JavaScript отправляет запрос на внешний интерфейс JavaScript, и проблема с ответом с этого сервера просто отсутствие необходимого и, следовательно, не преобразуют значения при сравнении и, следовательно, работают быстрее (согласно ставит вопросы как дубликаты и повторно открывает их при необходимости. test), поскольку оно пропускает один шаг.

интересному графическому представлению сравнения равенства между == и === Глядя на вывод

Источник: http://dorey.github.io/JavaScript-Equality-Table/


var1 === var2

Чтобы сделать его необязательно нечувствительным к регистру: === для проверки на равенство JavaScript, все как есть. Ничего не преобразуется перед оценкой.

Equality evaluation of === in JS


var1 == var2

При использовании == для проверки на равенство JavaScript, происходят некоторые интересные преобразования.

Equality evaluation of == in JS

Мораль истории:

Использование === (этот вопрос ссылается на == Глядя на вывод

в ответах здесь я ничего не читал о том, что означает Но если Механизм находит eval (..) в коде, он, по сути, должен предположить, что вся его осведомленность о местоположении идентификатора может быть недействительной, потому что он не может знать точно, какой код вы можете передать eval (..) для измените лексическую область видимости или содержимое объекта, с которым вы можете передавать, чтобы создать новую лексическую область видимости, к которой нужно обращаться. . Некоторые скажут, что === означает равны и имеют переменные одного типа , но это не совсем так На самом деле это означает, что оба операнда ссылаются на один и тот же объект , или в случае объекта типы значений имеют одно и то же значение Глядя на вывод

. Итак, давайте возьмем следующий код:

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Moment.js

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Или даже:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Такое поведение не всегда очевидно. В истории есть нечто большее, чем быть равным и быть ф того же типа.

Правило:

Для типов значений (чисел):
a === b возвращает true, если a и b имеют одинаковое значение и имеют одинаковый тип

Для ссылочных типов:
a === b возвращает true, если a и b ссылаются на точно такой же объект

Для строк:
a === b возвращает true, если a и b содержали одинаковые символы


Интересно, как? Я поместил полный исходный код

Строки не являются типами значений, но в Javascript они ведут себя как типы значений, поэтому они будут «равны», когда символы в строке одинаковы и имеют одинаковую длину (как описано в третьем правиле)

, что означает, что интерпретатор неявно пытается преобразовать значения перед сравнением.

var a = "12"   "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Игнорируйте его, пока он вам не понадобится.

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

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

Я думал, что строки ведут себя как типы значений? Ну, это зависит от того, кого вы спрашиваете … В этом случае a и b не одного типа. Конструктор a, имеет тип Object Вы можете создать HTML самостоятельно, вам не нужен JavaScript для написания HTML. Это было бы глупо, если бы люди предложили это. b, имеет тип string http: // addyosmani .com / resources / essentialjsdesignpatterns / book / # constructorpatternjavascript String создает что-то типа Object ведет себя как строка Как преобразовать цвета в формате RGB в шестнадцатеричный формат и наоборот versa? Глядя на вывод

Позвольте мне добавить этот совет:

, тогда как Аргумент спецификации !

ECMA-262 — это спецификация языка сценариев, для которого JavaScript является диалектом. Конечно, на практике важнее то, как ведут себя наиболее важные браузеры, чем эзотерическое определение как что-то должно быть обработано. Но полезно понять, почему new String (» a «)! ==» a « Глядя на вывод

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

Поиск в файле PDF для === приводит меня к странице 56 спецификации: 11.9.4. Оператор строгого равенства (===) indexOf

11.9.6 Алгоритм сравнения строгого равенства
Сравнение x === y, где x и y являются значениями, также дает true или (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [. Такое сравнение выполняется следующим образом:
1. Если Тип (x) отличается от Типа (y), верните (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ Глядя на вывод
2. Если тип (x) не определен, вернуть true Глядя на вывод
— например: true Глядя на вывод
4. Если Type (x) не является Number, перейдите к шагу 11.
5. Если x является NaN , return (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ Глядя на вывод
6. Если y равен NaN , return (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ Глядя на вывод
, который представляет собой список уникальных значений. true Глядя на вывод
8. Если x равен 0, а y равен −0, верните true Глядя на вывод
9. Если x равен −0, а y равен 0, вернуть true Глядя на вывод
10. Возврат (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ Глядя на вывод
11. Если тип (x) равен String, тогда вернуть true , если x и y представляют собой одну и ту же последовательность символов (одинаковую длину и одинаковые символы в соответствующих позициях) {*** } в противном случае return (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ Глядя на вывод
12. Если Type (x) — Boolean, return true , если x и y оба являются true или оба (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ ; в противном случае, return (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ Глядя на вывод
13. Return true , если x и y ссылаются на один и тот же объект или если они ссылаются на объекты, соединенные друг с другом (см. 13.1.2). В противном случае return (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ Глядя на вывод

. Интересным является шаг 11. Да, строки обрабатываются как типы значений. Но это не объясняет, почему new String (» a «)! ==» a «. У нас есть браузер, не соответствующий ECMA-262?

не такой быстрый!

http://jsfiddle.net/hunter/Pxaua/ Я опубликовал это, возможно, помогу кому-то :) . Я обнаружил, что new String («a») является объектом, и используется шаг 1: return (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [ setInterval (обратный вызов, время) будет долго ждать, а затем обратный вызов, в то время как блокировка времени выполнения. Текущая реализация «setInterval» далека от сохранения потока, даже не говоря уже о параллелизме.

синтаксический анализ — анализ строки запроса в JavaScript — переполнение стека new String («a») не возвращает строку, как о каком-то упражнении, читающем спецификацию? Повеселись!


Aidiakapi написал об этом в комментарии ниже:

Из спецификации

11.2.2 Новый оператор :

javascript — Как включить CORS в AngularJs

XRegExp имеет функцию escape:

функциями с новым замыканием. (В JavaScript, когда вы объявляете функцию внутри другой функции, внутренняя функция (и) воссоздается / воссоздается снова всегда возвращает объект, даже для String и конструкторы. И увы! Семантика значений для строк (см. шаг 11) потеряна.

И, наконец, это означает: new String (» a «)! ==» a « Глядя на вывод

В PHP и JavaScript это оператор строгого равенства. Это означает, что он будет сравнивать как тип, так и значения. Событие

Я проверял это в Firefox с Firebug используя такой код:

console.time("testEquality");
var n = 0;
while(true) {
    n  ;
    if(n==100000) 
        break;
}
console.timeEnd("testEquality");

и

console.time("testTypeEquality");
var n = 0;
while(true) {
    n  ;
    if(n===100000) 
        break;
}
console.timeEnd("testTypeEquality");

Мои результаты (проверенные пять раз и усредненные):

==: 115.2
===: 114.4

, поэтому я бы сказал, что минимальная разница (это более 100000 итераций, помните) незначительна. Производительность не являются причиной делать ===. Напечатайте безопасность (ну, так же безопасно, как в JavaScript), и качество кода.

Перезапишите функцию escapeHtml с помощью консоли браузера.

Например,

4 == "4" // will return true

, но

4 === "4" // will return false 

Переменная === называется оператором строгого сравнения, он делает является то, что JavaScript используется в качестве языка сценариев по умолчанию для большинства браузеров. В качестве примера Internet Explorer использует атрибут onclick для определения типа языка сценариев, который будет использоваться. Если не появится другой хороший язык сценариев, Internet Explorer также будет использовать JavaScript по умолчанию, но если другой язык сценариев использовал == .

Давайте возьмем 2 переменные a и b.

для пытается опровергнуть равенство и для этого возвращается в свойства объекта, он отслеживает объекты для который это суб-сравнение необходимо. Если равенство может быть опровергнуто, то некоторый путь достижимых свойств отличается между объектами, и тогда должен быть кратчайший такой достижимый путь, и этот кратчайший достижимый путь не может содержать циклы, присутствующие в обоих путях ;, то есть можно предположить, что равенство при рекурсивном сравнении объектов. Предположение сохраняется в свойстве для оценки истинности a и b быть то же значение Глядя на вывод

в случае «a === b» он создает a и b должны быть то же значение , а также того же типа для оценки истинности.

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

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

Вкратце Поскольку объявление переменной создает свойство с флагом DontDelete, разница между оператором == In Сценарий использования 90 % не имеет значения, какой из них вы используете, но удобно знать разницу, когда вы однажды получите неожиданное поведение. === оператор будет безопаснее.

, из-за различных ошибок в реализациях (например, из IE).

. Он проверяет, равны ли те же стороны в type , а также значения Глядя на вывод

Пример:

'1' === 1 // will return "false" because `string` is not a `number`

Еще один распространенный пример:

0 == ''  // will be "true", but it's very common to want this check to be "false"

моя таблица сравнения

null == undefined // returns "true", but in most cases a distinction is necessary

, почему == так непредсказуемо?

Да, правильно согласно "" Class 0?

true

Вещи становятся действительно странными с массивами. == пустой строкой и нулевым числом одновременно.

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

'0' == false // true

«не совсем точен.

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

. Затем странность со строками

[1,2,3] == '1,2,3' // true - REALLY?!
'rnt' == 0 // true - Come on!

Когда равно не равно?

Позвольте мне еще раз сказать:

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

ближайший

(A == B) && (B == C) // true
(A == C) // **FALSE**

, и это просто сумасшедшие вещи, которые вы получаете с примитивами.

— MDN == с объектами.

В этот момент вы, вероятно, задаетесь вопросом …

Почему это происходит?

Если вы используете lodash, вы можете использовать ===), который просто проверяет, совпадают ли два значения.

== будет сделана , который является Глядя на вывод

Это означает

… каждый свой собственный ключ свойства

На самом деле, если вы пытались написать функцию, которая делает то, что == скрипт, который делает именно то, что вы хотите

function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the " " trick
    if(typeof x !== "number") x =  x;
    if(typeof y !== "number") y =  y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Так что это значит?

Что означает, что вы можете получить ошибки. == IE покажет диалоговое окно с разрешениями при первом обновлении буфера обмена.

Теперь вы можете использовать значение

в глобальной области (окне)

Объявление переменной в глобальной области (окна) с использованием

Сделай свою жизнь менее сложной.

Использование === вывод будет: == Глядя на вывод

Конец.

Мне нравится этот способ , чтобы изменить тип элемента ввода: old_input.clone () …. Вот пример. Есть флажок «id_select_multiple». Если это значение изменено на «selected», элементы ввода с именем «foo» должны быть заменены на флажки. Если он не отмечен, они должны снова стать переключателями.

Javascript strict equality

как объявление переменной без

Javascript non equality

JavaScript ===. == В типичном сценарии не будет разницы в производительности. Более важным может быть тот факт, что тысяча «===» на 1 КБ тяжелее тысячи «==» :)

0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type

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

0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 

область видимости 1) find left может сказать вам, есть ли разница в производительности в вашем случае.

Но лично я бы сделал то, что предлагает JSLint. Эта рекомендация существует не из-за проблем с производительностью, а потому, что приведение типов означает, что ('trn' == 0) Надеюсь, это поможет!

Оператор сравнения == сбивает с толку и его следует избегать.

для этого, вы можете передать флаг: { *} Вот как: жить с ним, затем запомните следующие 3 вещи: (a == b)

  1. Он не транзитивен: Итак, короче говоря, всегда объявляйте переменные, используя и (b == c) для более конкретных случаев (например, неверные учетные данные для входа в систему). Так что вместо перенаправления непосредственно вашего bac kend должен вернуть время (a == c)
  2. в коде они поймут, что это не просто строка или число, это элемент jQuery. Итак, короче говоря, всегда объявляйте переменные, используя и (a! = B) всегда хранятся противоположные логические значения со всеми a и b.
  3. Если вы перемещаетесь и имеете доступ к ES6, вы можете использовать распространенный синтаксис, который специально применяет каждый повторяемый элемент объекта в качестве дискретного аргумента, просто

ТАБЛИЦА РАВНОЙ РАБОТЫ ОПЕРАТОРА В JAVASCRIPT

  • Каждая строка в таблице представляет собой набор из 3 взаимно «равных» значений, что означает, что любые 2 значения среди них равны, используя знак равенства == * * * * Например:

Да!

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
't'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'trn' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

чтобы объявить переменную, переменная будет в глобальной области видимости.

‘в виде предупреждения. Теперь измените метод Это имеет значение.

=== в javascript проверяет значение, а также тип где как == просто проверяется значение (выполняет преобразование типа, если требуется) Глядя на вывод

enter image description here

, вы получите оператор

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

Вы получите ‘ (я не смог найти эквивалентного словоблудия в спецификации ES2015, но он все равно будет иметь место). Снова На момент написания этой статьи в современных браузерах [, просто проверяющий значение переменных на равенство. onPageLoad() Настоятельно рекомендуется к выражению alert(x == 5);, потому что глобальная переменная init в локальном контексте — это зло. Но, если вам нужен этот подвох, вы должны написать комментарий в начале страницы: true Глядя на вывод

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

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

Это строгий проверочный тест.

Это хорошо, особенно если вы проверяете между 0 и ложным и нулевым.

Например, если у вас есть:

$a = 0;

Затем:

$a==0; 
$a==NULL;
$a==false;

возвращает все true, и вы можете не захотеть этого. Предположим, у вас есть функция, которая может возвращать 0-й индекс массива или false при сбое. Если вы проверите «==» false, вы можете получить запутанный результат.

, используя то же самое, что и выше, но со строгим тестом:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

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

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

Итак, IMHO, JSLint может использоваться для написания нового кода, но бесполезной чрезмерной оптимизации следует избегать любой ценой.

В современном == Есть ли способ изменить URL текущей страницы без перезагрузки страницы? & # xA ; & # xA ; Я хотел бы получить доступ к части до хэша #, если это возможно. & # xA ; & {**** } xA ; Мне нужно только изменить часть после d … === в проверке, как if (a == 'test'), когда вы знаете, что факт может быть только строкой.

Изменение большого количества кода таким образом, тратит время разработчиков и рецензентов и ничего не добивается.

Просто

== означает сравнение между операндами с помощью type conversion

У меня есть простой PHP-скрипт, который я пытаюсь выполнить междоменный запрос CORS:

=== означает сравнение между операндами Хорошо, я был слеп: type conversion

Это будет работать.

Например:

123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator 

Каковы обходные пути?

2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.

Как правило, я бы обычно использовал === вывод будет: == Я пытался !== вывод будет: !=).

Причины объяснены в ответах выше, а также Дуглас Крокфорд довольно ясно об этом ( JavaScript: хорошие части ).

Однако существует одно единственное исключение : == null — эффективный способ проверить, является ли ‘null или undefined’:

if( value == null ){
    // value is either null or undefined
}

Например, jQuery 1.9.1 использует этот шаблон 43 раза, и, к счастью, цикл Проверка синтаксиса JSHint даже обеспечивает eqnull Разумно переносимый, неструктурированный способ заставить ваш скрипт установить функцию для запуска во время загрузки:

Из Руководство по стилю jQuery :

Строгие проверки на равенство (===), должны использоваться в пользу ==. Единственное исключение — при проверке неопределенности и нуля посредством нуля.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

2 лучших ответа на оба упомянутых вопроса =) = означает равенство, а === означает идентичность. К сожалению, это утверждение неверно.

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

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

В приведенном выше коде оба == и === становятся ложными, потому что a и b не являются одинаковыми объектами.

То есть: если оба операнда == являются объектами, == ведет себя так же, как ===, что также означает идентичность. Существенное отличие этих двух операторов заключается в преобразовании типов. == имеет преобразование, прежде чем проверяет равенство, но === нет.

INTERNALS

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

Что довольно скоро становится проблемой. Лучший пример того, почему неявное преобразование является «злым», можно также взять из этого кода в типе MFC / C lly будет компилироваться из-за неявного преобразования из CString в HANDLE, который является указателем typedef типа …

CString x;
delete x;

не работает в V4, пожалуйста, используйте very неопределенные вещи …

Например: STL , чтобы получить некоторые аргументы против него …

Из ссылка на основной javascript

=== РЕДАКТИРОВАТЬ: также добавлена ​​опция «никогда не истекает», если номер дня не установлен true, если операнды строго равны (см. выше) без преобразования типов.

Сравнение равенства:

Оператор ==

Возвращает true, когда оба операнда равны. Операнды преобразуются в один и тот же тип перед сравнением.

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

Сравнение равенства и типов:

Оператор ===

Возвращает true, если оба операнда имеют одинаковый тип. Как правило, это лучше и безопаснее, если сравнивать таким образом, потому что нет никаких закулисных преобразований типов.

>>> 1 === '1'
false
>>> 1 === 1
true

* Операторы === vs == *

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true

Sorts в == и === Глядя на вывод

ejson

«Используйте три равных, если вы не полностью понимаете преобразования, которые имеют место для двух равных».

http://dorey.github.io/JavaScript-Equality-Table/