Вопросы Теги

как я могу перебирать элементы массива и показывать сообщение, когда он находится в середине в javascript? [Дубликат]

Я предпочитаю фреймворк Underscore. Он предлагает много полезных операций с объектами. Ваша задача: 

var newArray = homes.filter(
    price <= 1000 & 
    sqft >= 500 &
    num_of_beds >=2 & 
    num_of_baths >= 2.5);

может быть перезаписана как: 

var newArray = _.filter (homes, function(home) {
    return home.price<=1000 && sqft>=500 && num_of_beds>=2 && num_of_baths>=2.5;
});

Надеюсь, это будет полезно для вас!

5673
задан Taryn 22 March 2017 в 17:13
поделиться

30 ответов

В типичном сценарии разница производительности не будет. Более важным может быть тот факт, что тысячи «===» составляют 1 & nbsp; KB тяжелее, чем тысячи «==» :) Профилировщики JavaScript могут сказать вам, есть ли разница в производительности в вашем случае.

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

5745
ответ дан Community 20 August 2018 в 07:54
поделиться
  • 1
    === не быстрее, если типы одинаковы. Если типы не совпадают, === будет быстрее, потому что он не будет пытаться выполнить преобразование. – Bill the Lizard 31 December 2008 в 04:02
  • 2
    === никогда не будет медленнее, чем ==. Они оба проверяют тип, поэтому === не делает ничего лишнего по сравнению с ==, но проверка типа может позволить === выйти раньше, когда типы не совпадают. – Bill the Lizard 2 February 2009 в 05:17
  • 3
    Не всегда верно. С сжатием gzip разница будет почти незначительной. – Daniel X Moore 23 June 2009 в 00:43
  • 4
    Замена all == /! = С === /! == увеличивает размер js-файла, потребуется больше времени для загрузки. :) – Marco Demaio 31 March 2010 в 10:22
  • 5
    «... правила, с помощью которых они делают, которые являются сложными и неподвластными ...» Теперь такие заявления заставляют вас чувствовать себя в безопасности при программировании ... – Johan 9 December 2011 в 18:24
  • 6
    Иногда система типа JavaScript заставляет меня хотеть убежать от крика. – Yawar 8 November 2012 в 06:06
  • 7
    Согласитесь, но тысячи & quot; === & quot; означает также 10 тысяч строк кода, поэтому 1kb больше или меньше ...;) – Jonny 28 September 2016 в 18:32
  • 8
    Если вы заинтересованы в размере, просто замените все == с ===, затем используйте regexp, завернутый в av eval, чтобы переключить его обратно – user 23 April 2017 в 03:30

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

Ссылка: Javascript Tutorial: Операторы сравнения

Оператор == будет сравнивать для равенства после выполнения любых необходимых преобразований типа . Оператор === не будет выполнять преобразование, поэтому, если два значения не совпадают, === просто вернет false.

Чтобы проголосовать за отличный Douglas Crockford: Хорошие части ,

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

' \t\r\n ' == 0     // true

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

Обновление:

Хорошая точка была поднята @Casebash в комментариях и в @Phillipe Laybaert's ответ относительно ссылочных типов. Для ссылочных типов == и === действуют последовательно друг с другом (за исключением специального случая). 

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 для создания строковых объектов.

Ссылка http://www.ecma-international.org/ecma-262 /5.1/#sec-11.9.3

5745
ответ дан Community 20 August 2018 в 07:54
поделиться
  • 1
    === не быстрее, если типы одинаковы. Если типы не совпадают, === будет быстрее, потому что он не будет пытаться выполнить преобразование. – Bill the Lizard 31 December 2008 в 04:02
  • 2
    === никогда не будет медленнее, чем ==. Они оба проверяют тип, поэтому === не делает ничего лишнего по сравнению с ==, но проверка типа может позволить === выйти раньше, когда типы не совпадают. – Bill the Lizard 2 February 2009 в 05:17
  • 3
    Замена all == /! = С === /! == увеличивает размер js-файла, потребуется больше времени для загрузки. :) – Marco Demaio 31 March 2010 в 10:22
  • 4
    «... правила, с помощью которых они делают, которые являются сложными и неподвластными ...» Теперь такие заявления заставляют вас чувствовать себя в безопасности при программировании ... – Johan 9 December 2011 в 18:24
  • 5
    Иногда система типа JavaScript заставляет меня хотеть убежать от крика. – Yawar 8 November 2012 в 06:06

Использование оператора == ( Равенство ) 

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

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

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

993
ответ дан 12 revs, 7 users 45% 20 August 2018 в 07:54
поделиться
  • 1
    @Software Monkey: не для типов значений (число, логическое, ...) – Philippe Leybaert 5 June 2009 в 21:00
  • 2
    type coercion vs type casting vs type convertion: stackoverflow.com/questions/8857763/… – Adrien Be 23 July 2014 в 13:02
  • 3
    Поскольку никто не упомянул таблицу равенства Javascript, вот она: dorey.github.io/JavaScript-Equality-Table – blaze 6 January 2015 в 04:17
  • 4
    В первом утверждении вы уверены, что «true» преобразуется в 1, а не 1, преобразован в true? – Shadi Namrouti 22 November 2016 в 11:05
  • 5
    Где термины "равенство" и "идентичность" родом из? Стандарт не использует эти термины. Он называет == "абстрактное равенство" и он называет === «строгое равенство». Предоставляемый вызов == любого типа «равенства»; ИМХО ужасно, так как это не транзитивно, но зачем придираться? Я беру больше проблем с «идентификацией». хоть; Я думаю, что этот термин довольно вводит в заблуждение, хотя он «работает». Но серьезно, кто придумал термин «идентичность»? Я обыскаю стандарт и не могу его найти. – Ray Toal 7 February 2018 в 09:03

null и undefined - небытие, то есть 

var a;
var b = null;

Здесь a и b не имеют значений. Принимая во внимание, что 0, false и '' - все значения. Одно из них заключается в том, что все они являются ложными значениями, что означает, что все они удовлетворяют условиям ложности.

Итак, 0, false и 'вместе образуют подгруппу. И, с другой стороны, нуль & amp; undefined образуют вторую подгруппу. Проверьте сравнения в приведенном ниже изображении. null и undefined равны. Остальные три будут равны друг другу. Но все они рассматриваются как фальшивые условия в JavaScript.

Enter image description here [/g0]

Это то же самое, что и любой объект (например, {}, массивы и т. Д.), непустая строка & amp; Булевы истины - все правдивые условия. Но все они не равны.

18
ответ дан 2 revs, 2 users 69% 20 August 2018 в 07:54
поделиться

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

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

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

Смысл, нет никаких причин для изменения == до === в чеке, подобном if (a == 'test'), когда вы это знаете, поскольку факт может быть только строкой.

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

31
ответ дан Alex Weitz 20 August 2018 в 07:54
поделиться

Просто

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

& amp;

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

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

Например: 

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
27
ответ дан Amit 20 August 2018 в 07:54
поделиться

Из ссылки core javascript

=== Возвращает true, если операнды строго равны (см. выше) без преобразования типа.

50
ответ дан Anik Islam Abhi 20 August 2018 в 07:54
поделиться

Да! Это имеет значение.

Оператор

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

enter image description here [/g0]

Вы можете легко протестировать его. Вставьте следующий код в файл HTML и откройте его в браузере. 

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

В предупреждении вы получите «false». Теперь измените метод onPageLoad() на alert(x == 5);, вы получите правду.

33
ответ дан Aniket Thakur 20 August 2018 в 07:54
поделиться

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

Если вы сомневаетесь, прочитайте спецификацию !

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

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

Поиск файла PDF для === приводит меня на страницу 56 спецификации: 11.9.4. Оператор Strict Equals (===), и после прохождения через спецификацию я нахожу:

11.9.6 Алгоритм сравнения строгих равенств Сравнение x === y, где x и y являются значения, возвращает true или false. Такое сравнение выполняется следующим образом: & nbsp; 1. Если Type (x) отличается от Type (y), верните false. & NBSP; & NBSP; 2. Если Type (x) Undefined, верните true. & NBSP; & NBSP; 3. Если Type (x) - Null, верните true. & NBSP; & NBSP; 4. Если Type (x) не является числом, перейдите к шагу 11. & nbsp; & nbsp; 5. Если x является NaN, верните false. & NBSP; & NBSP; 6. Если y является NaN, верните false. & NBSP; & NBSP; 7. Если x - это то же числовое значение, что и y, верните true. & NBSP; & NBSP; 8. Если x равно +0, а y равно -0, верните true. & NBSP; & NBSP; 9. Если x равно -0 и y равно +0, верните true. & NBSP; & NBSP; 10. Вернуть false. & NBSP; & NBSP; 11. Если Type (x) - String, то верните true, если x и y - это точно такая же последовательность символов (одинаковая длина и одинаковые символы в соответствующих позициях); в противном случае верните false. & NBSP; & NBSP; 12. Если Type (x) является логическим, верните true, если x и y оба true или оба false; в противном случае верните false. & NBSP; & NBSP; 13. Верните true, если x и y относятся к одному и тому же объекту или относятся к объектам, соединенным друг с другом (см. 13.1.2). В противном случае верните false.

Интересным является этап 11. Да, строки рассматриваются как типы значений. Но это не объясняет, почему новый String («a»)! == «a».

Не так быстро!

Давайте проверим типы операндов. Попробуйте сами, обернув их в typeof (). Я обнаружил, что новый String («a») является объектом, и используется шаг 1: return false, если типы разные.

Если вам интересно, почему новая строка («a») не возвращает строка, как насчет некоторых упражнений, читающих спецификацию? Получите удовольствие!

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

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

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

Если тип (конструктор) не является объектом, вызовите исключение TypeError.

Другими словами, если String не будет иметь тип Object, он не может использоваться с новым оператором.

new всегда возвращает объект, даже для конструкторов String. И увы! Семантика значения для строк (см. Шаг 11) потеряна.

И это, наконец, означает: новый String ("a")! == "a".

250
ответ дан BiscuitBaker 20 August 2018 в 07:54
поделиться

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

Если вам нужно жить с ним, тогда запомните следующие 3 вещи:

  1. Это не транзитивно: (a == b) и (b == c) не приводит к (a == c)
  2. Это взаимно исключает его отрицание: (a == b) и (a! = b) всегда имеют противоположные булевы значения , со всеми a и b.
  3. В случае сомнений выучите наизусть следующую таблицу истинности:

EQUAL OPERATOR TRUTH TABLE IN JAVASCRIPT

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

** STRANGE : обратите внимание, что любые два значения в первом столбце не равны в этом смысле. ** 

''       == 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   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 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.
42
ответ дан CuongHuyTo 20 August 2018 в 07:54
поделиться

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

Давайте возьмем 2 vars a и b.

Для «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");
}

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

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

74
ответ дан Doctor Jones 20 August 2018 в 07:54
поделиться

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

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

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

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

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

23
ответ дан Harry He 20 August 2018 в 07:54
поделиться

Интересное живописное представление сравнения равенств между == и ===.

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

var1 === var2

< blockquote>

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

Equality evaluation of === in JS [/g7]

var1 == var2

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

Equality evaluation of == in JS [/g8]

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

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

528
ответ дан Ivan 20 August 2018 в 07:54
поделиться
  • 1
    – mfeineis 8 May 2015 в 11:11
  • 2
    – Zo72 14 June 2015 в 20:25
  • 3
    @mfeineis вы имеете в виду === or! == вместо == or! =. Не хочу путать новых кодеров;) – katalin_2003 23 June 2016 в 14:04
  • 4
    @ katalin_2003 oops, вы правы === и! ==, d ** n опечатки, thx – mfeineis 24 June 2016 в 06:20
  • 5
    – vsync 12 February 2017 в 09:47
  • 6
    @vsync: Ого, те люди, которые злоупотребляют JQuery, тоже говорят то же самое. Я никогда не знал, что у тебя так много общего ... – user 23 April 2017 в 03:25
  • 7
    @vsync: Если вы действительно не хотите, чтобы типы были равны , вы должны использовать три равно ! – SNag 24 April 2017 в 05:19
  • 8
    Этот ответ так чертовски полезен !!! – skiabox 13 June 2017 в 13:07

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

Что вы получаете, когда сравниваете пустую строку "" с номером 0 0?

true

Да, это правильно, согласно == пустая строка, а число ноль - одно и то же время.

И это не заканчивается там, вот еще один: 

'0' == false // true

Вещи становятся очень странными с массивами. 

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

Затем более странно со строками 

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 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**

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

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

На этом этапе вам, вероятно, интересно ...

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

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

== делает целую кучу других вещей .

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

Это довольно странно.

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

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();
}

Итак, что это значит?

Это означает, что == сложный.

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

Это означает, что у вас могут быть ошибки.

Итак, мораль этой истории ...

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

Используйте === вместо ==.

Конец.

61
ответ дан Luis Perez 20 August 2018 в 07:54
поделиться
  • 1
    Ваш looseEqual ошибочен. Function == Function.toString() истинно, но looseEqual(Function, Function.toString()) неверно. Не уверен, почему вы отфильтровываете функции в начале. – Oriol 7 September 2016 в 22:16
  • 2
    @Oriol, вы были правы, я обновил код для учета этого, FYI, основанный на моих тестах, недостаточно, чтобы удалить фильтр для «функций», вместо этого «функции». нужно было по-другому обрабатывать. – Luis Perez 8 September 2016 в 22:43
  • 3
    Помните, что spec не обрабатывает функции по-разному, это просто объекты. Проблема в том, что вы полагаетесь на typeof x === "object", чтобы проверить, является ли это объектом, но `typeof работает только для непустых примитивов. Возможно, вам будет интересен список правильных способов проверки, является ли значение объектом – Oriol 8 September 2016 в 23:25
  • 4
    Я пробовал обрабатывать функции и объекты одинаково, но обнаружил, что результаты были неверными. Например, если функции обрабатывались как объекты, тогда сравнение функции с объектом, реализующим функцию valueOf () или toString (), которая соответствует функции, будет проходить, но на самом деле это не так. Пример: (function blah() { console.log("test"); }) != {valueOf:function(){return "function blah() { console.log(\"test\"); }";}} - проверьте этот JS Fiddle, который запускает все тесты: jsfiddle.net/luisperezphd/7k6gcn6g (там 1,225 тестовых перестановок) – Luis Perez 10 September 2016 в 16:22
  • 5
    Интересно. Но обратите внимание, что ваш код не работает с {toString:function(){return null;}} и некоторыми ES6. См. jsfiddle.net/7k6gcn6g/1 – Oriol 10 September 2016 в 21:02
  • 6
    – Luis Perez 11 September 2016 в 13:20
  • 7
    – Davi Lima 21 November 2017 в 10:07

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

Причины объясняются в ответах выше, а также Douglas Crockford довольно ясно об этом ( JavaScript: The Good Parts ).

Однако существует одно исключение: == null - эффективный способ проверить, что «имеет значение null или undefined ': 

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

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

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

Строгие проверки равенства (===) следует использовать в пользу ==. Единственное исключение - проверка неопределенного и нулевого значения с помощью null. 

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;
22
ответ дан mar10 20 August 2018 в 07:54
поделиться

Это означает, что равенство без принуждения типа принуждения означает, что 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
48
ответ дан Md Nakibul Hassan 20 August 2018 в 07:54
поделиться

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

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true
18
ответ дан Mr.G 20 August 2018 в 07:54
поделиться

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

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

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

CString x;
delete x;

Что очевидно во время выполнения very неопределенных вещей ...

Google для неявных преобразований в C ++ и STL чтобы получить некоторые аргументы против него ...

88
ответ дан Peter Mortensen 20 August 2018 в 07:54
поделиться
  • 1
    Больше, чем тип безопасности, вы хотите логической корректности - иногда вы хотите, чтобы вещи были правдивыми, когда == не согласен. – rpjohnst 13 September 2011 в 22:14
  • 2
    Теперь, как они сравниваются, когда существует фактическое принуждение типа для оператора ==? Помните, что когда есть повышение производительности. – Hubert OG 13 July 2013 в 22:13
  • 3
    0 == null неверно. – Garrett 13 January 2014 в 02:25
  • 4
    ОСНОВНАЯ разница при правильном тестировании по вышеупомянутым причинам, позволяющим быстрее проверять неравномерность типа. jsfiddle.net/4jhuxkb2 – Doug Morrow 6 July 2015 в 17:04

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

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

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

Тот же здесь: 

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 являются обеими строками и содержат одни и те же символы

< hr>

Строки: специальный случай ...

Строки не являются типами значений, но в 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, а b имеет тип string. Просто помните, что создание строкового объекта с использованием конструктора String создает что-то типа Object, которое ведет себя как строка большую часть времени .

551
ответ дан Philippe Leybaert 20 August 2018 в 07:54
поделиться
  • 1
    activa: Я бы уточнил, что строки настолько равны, только когда они являются литералами. новая строка (& quot; abc & quot;) === & quot; abc & quot; является ложным (согласно моим исследованиям). – Lawrence Dol 5 June 2009 в 20:54
  • 2
    new Number() == "0". Также в Firefox: (function(){}) == "function () {\n}" – Thomas Eding 30 March 2011 в 06:21
  • 3
    Спасибо, что объяснили, почему new String("123") !== "123". Они разные. Простой, но сбивающий с толку. – styfle 26 August 2012 в 06:51
  • 4
    String объекты ведут себя как строки, а - любой другой объект . new String никогда не должен использоваться, поскольку это не создает настоящие строки. Действительная строка и может быть выполнена со строковыми литералами или вызовом String в качестве функции без new, например: String(0); //"0", Real string, not an object – Esailija 5 December 2012 в 01:51
  • 5
    Но в случаях, которые вы подробно описали, оператор "==" ведет себя точно так же. – Yaron Levi 6 February 2015 в 11:48

Это строгий контрольный тест.

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

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

$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
30
ответ дан Praxis Ashelin 20 August 2018 в 07:54
поделиться
  • 1
    В JavaScript это совершенно неправильно и ошибочно неполно. 0 != null. -1 – Ry-♦ 6 May 2013 в 04:07

Схема последовательности выполнения Javascript для строгого равенства / Сравнение '==='

Схема последовательности выполнения Javascript для нечеткого равенства / сравнения '= = '

61
ответ дан Samar Panda 20 August 2018 в 07:54
поделиться
  • 1
    Я не понимаю, почему стрелка string указывает на большой серый квадрат, предполагается ли это, что прерыватель переводит строку в число? – vsync 11 February 2017 в 14:26
  • 2
    @vsync Указывает на параметр строки в сером поле i.e string - & gt; # || NaN. Javascript не является языком сценариев типов. В принципе, он может иметь любой тип переменной. Таким образом, он указывает на серое окно. – Samar Panda 12 February 2017 в 07:56
  • 3
    Я просто спросил, подходит ли это для кастингов, так как предполагается, что string сравнивается с типом number, поэтому прерыватель смотрит на то, что строка должна быть сопоставлена ​​и соответственно лить строку? – vsync 12 February 2017 в 09:44
  • 4
    Большой серый квадрат - это то, что ToNumber вернется при задании разных типов, поэтому, если ему задана строка, он будет выбирать только последний вариант (и преобразовать его в число). == использует ToNumber только в случаях string == number или boolean == anything выше (и только на string / boolean). Это означает, что == никогда не преобразует undefined или null, даже если они находятся в сером поле. (Для любой комбинации либо undefined, либо null или обоих, == всегда будет возвращать true. Кроме того, не имеет значения значение слева или справа, == (и === ]) вернет тот же результат.) – user2033427 7 March 2018 в 06:54

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

34
ответ дан Sean 20 August 2018 в 07:54
поделиться

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

93
ответ дан Shiki 20 August 2018 в 07:54
поделиться
  • 1
    @David: правильно. Вот почему этот ответ является неточным (или даже неправильным) – Philippe Leybaert 31 May 2010 в 13:25
  • 2
    @David var a = {}, b = {}; a == b возвращает false. – nyuszika7h 26 February 2011 в 19:37
  • 3
    Да: Два разных объекта с одним и тем же типом и значением сравнивают false, т. Е. Этот ответ просто неверен. Почему у этого есть 50 upvotes? – alexis 18 October 2013 в 11:45
  • 4
    Я понимаю, что это старо, но для того, чтобы выяснить, почему этот ответ все еще «правильный». потому что в примере var a = {}, b = {};, хотя оба a и b действительно оба являются объектами, но они не являются значением same , технически говорящим. Это разные экземпляры . Обратите внимание, что сравнение экземпляров ведет себя иначе, чем сравнение примитивов. Что, вероятно, добавляет к этой путанице. Вы увидите аналогичное поведение сравнения, если используете экземплярную версию примитивных типов данных. Например, new String('asdf') или new Number(5). Пример: new Number(5) == new Number(5) неверно, хотя они имеют одинаковое значение. – Norman Breau 18 May 2017 в 18:02
  • 5
    – Stokely 3 September 2018 в 20:05

Простым примером является 

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

2 === '2'  -> false, values are NOT SAME because of no type conversion.
25
ответ дан Tamil Selvan C 20 August 2018 в 07:54
поделиться

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

Оператор ==

Возвращает true, когда оба операнда равны. 

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

Сравнение параметров и эквивалентов:

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

>>> 1 === '1'
false
>>> 1 === 1
true
20
ответ дан user2601995 20 August 2018 в 07:54
поделиться

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

Пример: 

'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
65
ответ дан vsync 20 August 2018 в 07:54
поделиться
Оператор

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

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

31
ответ дан Alex Weitz 20 August 2018 в 07:54
поделиться

JavaScript === vs ==. 

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
50
ответ дан Anik Islam Abhi 20 August 2018 в 07:54
поделиться

В JavaScript это означает одно и то же значение и тип.

Например, 

4 == "4" // will return true

, но 

4 === "4" // will return false
88
ответ дан Peter Mortensen 20 August 2018 в 07:54
поделиться
  • 1
    Больше, чем тип безопасности, вы хотите логической корректности - иногда вы хотите, чтобы вещи были правдивыми, когда == не согласен. – rpjohnst 13 September 2011 в 22:14
  • 2
    Теперь, как они сравниваются, когда существует фактическое принуждение типа для оператора ==? Помните, что когда есть повышение производительности. – Hubert OG 13 July 2013 в 22:13
  • 3
    ОСНОВНАЯ разница при правильном тестировании по вышеупомянутым причинам, позволяющим быстрее проверять неравномерность типа. jsfiddle.net/4jhuxkb2 – Doug Morrow 6 July 2015 в 17:04
91
ответ дан Peter Mortensen 31 October 2018 в 06:50
поделиться
Другие вопросы по тегам:

Похожие вопросы: