example - ¿Cuál es la razón para usar=== en lugar de== con typeof en Javascript?

typeof jquery

Question

A lo largo de muchas bibliotecas de terceros y las mejores prácticas de blogs / recomendaciones, etc ... es común ver una sintaxis como esta:

typeof x === ''object'' (instead of typeof x == ''object'')
typeof y === ''string'' (instead of typeof x == ''string'')
typeof z === ''function'' (instead of typeof x == ''function'')

Si el operador typeof ya devuelve una cadena, ¿cuál es la necesidad de escribir también verificar el valor de retorno? Si typeof (typeof (x)) siempre es una cadena , no importa lo que realmente sea x, entonces == debería ser suficiente y === innecesario.

¿Bajo qué circunstancias typeof no devolverá una cadena literal? E incluso si hay algún caso marginal, ¿por qué se usa la verificación de tipo adicional para objeto, cadena, función, etc.?

Answer 1

Si el operador typeof ya devuelve una cadena, ¿cuál es la necesidad de escribir también verificar el valor de retorno? Si typeof (typeof (x)) siempre es una cadena, no importa lo que realmente sea x, entonces == debería ser suficiente y === innecesario.

Es subjetivo Puedes cambiar esto fácilmente y preguntar: "¿Por qué usarías == cuando no esperas conversiones implícitas?" Ambos funcionan bien aquí, así que use el que crea que expresa mejor su intención. Intenta ser consistente dentro de un proyecto.

Answer 2

Los operadores triples iguales se utilizan principalmente para la comprobación de tipos y valores variables (todo en 1 expresión), también conocido como igualdad sin coacción de tipo .

Ejemplo:

var a = 1;
var b = 1;
var c = "1";
var d = "1";

alert (a === b); //True, same value and same type (numeric)
alert(c === d); //True, same value and same type (string)
alert(b === c); //False, different type but same value of 1

Ver el teatro YUI de Doug Crockford sobre el tipo de coerción.

Si el operador typeof ya devuelve una cadena, ¿cuál es la necesidad de escribir también verificar el valor de retorno? Si typeof (typeof (x)) siempre es una cadena, no importa lo que realmente sea x, entonces == debería ser suficiente y === innecesario.

La razón más eficiente para no usar typeof y, más bien, el operador === sería la coerción (interpretación) de tipo entre navegadores. Algunos navegadores pueden pasar 6=="6" como verdaderos y otros no (según el rigor del intérprete de JS), por lo que al introducir la coacción de tipo se aclararía esto. Además, aportaría el enfoque de "Orientación al Objeto" ya que las variables de JavasScript no son variables basadas en tipos (es decir, los tipos de variables no se declaran en tiempo de compilación como en Java).

Por ejemplo, en Java, esto fallaría:

if ("6" instanceof Number) { // false

Espero haber respondido a tu pregunta.

Answer 3

No hay ninguna razón para favorecer === sobre == en este caso, ya que se garantiza que ambos operandos son cadenas y, por lo tanto, ambos operadores darán el mismo resultado. Ya que == es un personaje menos, lo favorecería.

El consejo de Crockford sobre esto es usar === todo el tiempo, que es un consejo razonable para un principiante pero sin sentido paranoico si conoce los problemas (cubiertos en otras respuestas).

Answer 4

Para responder a la pregunta principal, no hay peligro en usar typeof con == . A continuación se muestra la razón por la que puede usar === todos modos.

La recomendación de Crockford es que es más seguro usar === en muchas circunstancias, y que si lo vas a usar en algunas circunstancias, es mejor ser consistente y usarlo para todo.

La idea es que puedes pensar si usar == o === cada vez que verificas la igualdad, o simplemente puedes adquirir el hábito de escribir siempre === .

Casi nunca hay una razón para usar == sobre === - si se compara con true o false y desea coerción (por ejemplo, quiere que 0 o '''' evalúe como false ), simplemente use if(! empty_str) lugar de que if(empty_str == false) .

Para aquellos que no entienden los problemas de == fuera del contexto de typeof, vea esto, en The Good Parts :

'''' == ''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

Answer 5

Porque === es más rápido que ==, debido a omitir la coacción de tipo. Claro que es probablemente una diferencia insignificante pero todavía está ahí.