values - Valores falsos de Javascript(nulo, indefinido, falso, cadena vacía: “” o '''' y 0) y operador de comparación(==)
operadores de comparacion javascript (3)
Esta pregunta ya tiene una respuesta aquí:
Cuando estoy usando cualquiera de los valores ( null , undefined , false , '''' , 0 ) en una sentencia if , siempre se evalúa como falacia ( false ). Además, la negación de estos valores (( null , undefined , false , '''' , 0 ) en una sentencia if siempre se evalúa como tautología ( true ).
if(null){
}else{
}
if(undefined){
}else{
}
if(false){
}else{
}
if(''''){
}else{
}
if(0){
}else{
}
En todos los casos anteriores, if declaración se evalúa como false else instrucción else ejecuta. Sin embargo, cuando estoy comparando estos valores de falacia con el operador == , no siempre se vuelve true . Sorprendentemente, siempre está devolviendo valores true cuando estoy comparando la negación de estos valores.
si el operador es igual a ( == ) verifica / compara valores y no estrictamente para tipos, entonces por qué:
null == false // returns false
null == 0 // returns false
null == '''' // returns false
Pero,
!null == !false // returns true
!null == !0 // returns true
!false == !undefined // returns true
Y,
null == undefined // returns true
false == 0 // returns true
Aprecio si alguien puede aclarar el comportamiento o la relación entre estos valores ( null , undefined , false , '''' , 0 ).
Un error común
"... Si el operador double equalto (
==) solo verifica / compara valores y no tipos ..."
Esa es una suposición incorrecta, aunque a menudo es repetida por personas. En realidad, el == comprueba los tipos y, de hecho, presta mucha más atención a los tipos que una comparación === .
Ver el algoritmo de comparación de igualdad abstracta .
Una comparación == no hace una conversión simple a Boolean . Más bien, se dirige a través de un algoritmo recursivo algo complejo, que, después de verificar los tipos, intenta forzar a los operandos al mismo tipo si no coinciden.
El tipo de coerción que realiza es muy específico para los tipos de los operandos. Una secuencia diferente de coerciones puede tener lugar para diferentes tipos de pares. Por lo general (pero no siempre) termina por obligar a los operandos a tipos de number .
Por que Ingiriendo los operandos cambia las cosas.
Cuando coacciona manualmente ambos operandos usando ! , ahora estás haciendo una conversión simple a Boolean que hace que los tipos coincidan, lo que evita la parte coercitiva de tipo del algoritmo, lo que hace que se comporte esencialmente como el algoritmo de comparación de igualdad estricta .
Entonces, la única manera de predecir el resultado de una comparación == cuando los tipos no coinciden es entender ese algoritmo abstracto.
No te olvides de NaN
Y para tu información, hay un valor más "falsey" a considerar, NaN . Su comparación == siempre será false , no importa qué. Incluso cuando se compara con otro valor de NaN , será false .
NULL es diferente de falso (NULL es de tipo objeto y falso es de tipo booleano), nulo es diferente de 0 (0 es de tipo entero), nulo también es diferente de '''' ('''' es de tipo de cadena). pero todos son valores falsos. Los ! El operador niega un valor booleano. Si ! se usa en valores falsos, resulta en la conversión de valores falsos en un objeto de tipo booleano.
undefined : significa que una variable fue declarada pero no tiene un valor asignado
null : el valor de nulo se ha asignado, lo que significa que no tiene valor
false '''' y 0 , creo que probablemente puedas averiguar qué significan estos.