Является ли третий = необходимым при сравнении типов объектов?

Question

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

typeof x === "object" 
typeof x == "object" // does the same thing 100% of the time and uses one less character 

Answer 1

Вы не сравниваете типы объектов. Вы сравниваете строки: буквальный ('object') и который возвращается оператором typeof.

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

Answer 2

1 (очень) веская причина: консистенция.

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

Я бы принял согласованность и специфичность в связи с необходимостью набрать 1 символ в 100% случаев.

Answer 3

В этой конкретной ситуации единственным преимуществом === является то, что он немного быстрее.

Для получения результатов профилирования см .: http://jsperf.com/equal-performance (в частности, «строка + двойные равные» и «строка + триплекс равен»).

Answer 4

== - означает проверку значений vars, но не проверяет их типы (например, «2» == 2 => return true).

=== - означает, что значения проверки и их типов (например, «2» === 2 => вернуться ложным, потому что левый аргумент является строкой, и второй ряд, поэтому вары не делает то же самое)

EDIT : === в целом то же, что и var1 == var2 && var1.contructor == var2.contructor.

Answer 5

В-третьих, сравните даже типы данных.

JavaScript typeof возвращает строки, только если проверенная переменная имеет значение null, не возвращает «null», но null.

Если вы сравниваете TYPEOF х с строкой, второй равно возвращает всегда то же самое, такие как третьи.

Answer 6

Хорошо, теперь большинство людей сказали вам (справедливо), что использование трех = - лучшая практика. Тем не менее, ваш пример вызывает одну из возможных ошибок при использовании сравнений type of value-of. Возьмите это, например:

var date1 = new Date(); 
var date2 = new Date(date1.valueOf()); 

Это означает, что Дат как date1 и date2 одного и того же типа (объекты, тот же объект даже: Date) и имеют точно такое же значение. Таким образом, логично:

console.log(date1 === date2);//logs FALSE 

Почему? Потому что переменные объекта JS являются ссылками.То, что приведенный выше оператор фактически выполняет, - это проверка того, являются ли два места в памяти (оба являются новыми экземплярами) одинаковыми. Не проверяется их содержимое, но их адрес mem. Поэтому
Логика подсказывает, что:

var date1 = new Date(); 
var date2 = date1; 
console.log(date1 === date2);//True 

Примечание: JS всегда копирует значения переменных, но в случае объектов, эти переменные являются ссылками, поэтому JS копирует мем адрес, который хранится в date1 к date2.

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

Простым решением многих людей, применяемых для применения, было перезаписать метод прототипа объекта JS valueOf. Это по-прежнему работает, но вызывает проблемы с типом и проверками значения (тип объекта все еще играет роль, в то время):

function SomeConstructor() 
{ 
    this.foo = 'foobar'; 
    this.bar = function() 
    { 
     console.log('I am a messy constructor!'); 
     return this.foo; 
    }; 
} 
var inst = new SomeConstructor(); 
inst.valueOf = function() 
{ 
    return 1; 
} 

console.log(inst == 1);//logs true 
console.log(inst === 1);//logs FALSE 

Есть много способов, чтобы обойти эту проблему, я видел человек JSON.stringify -ный два объекта , и разбор их потом, люди, использующие for...in, чтобы проверить каждое свойство, ... Хотя все, что нужно сделать, это сохранить возвращаемое значение valueOf() в дополнительной переменной. Job Done (?) То, что на самом деле нужно делать, это написать лучший код, но я устал и дрейфую. WAY не в теме, где .... вернуться к вопросу:

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

Под этим я подразумеваю, что, когда вы пишете код, особенно на мягком, напечатанном языке, вы обнаруживаете, что пишете функции или методы, которые принимают определенное количество аргументов определенного типа.
Следующим шагом, как правило, при отладке, является то, что ваши функции начинаются с строк, таких как argument1 = parseInt(argument1); и argument1 = argument1 || 0;. Код, подобный этому, никогда не может быть обойден всеми вместе, но должен быть сведен к минимуму.

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