igualdades - operadores de comparacion javascript

Comprobación de JavaScript para nulo frente a no definido y diferencia entre== y===

Question

Lo sé, sé que debe haber algunos hilos que cubren este tema. Pero utilicé la búsqueda y no obtuve la respuesta que se ajustara a mis necesidades. Así que, aquí vamos:

1. ¿Cómo verifico una variable si es null o undefined y cuál es la diferencia entre null e undefined ?

2. ¿Cuál es la diferencia entre "==" y "===" (es difícil buscar en Google === )?

Answer 1

¿Cómo verifico una variable si es null o undefined ...

Es la variable null :

if (a === null)
// or
if (a == null) // but see note below

... pero tenga en cuenta que esto último también será cierto si a undefined está undefined .

¿Está undefined ?

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

... pero de nuevo, note que el último es vago; también será cierto si a es null .

Ahora, a pesar de lo anterior, la forma habitual de verificarlos es utilizar el hecho de que son falsos :

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

Esto está definido por ToBoolean en la especificación.

... y cual es la diferencia entre null e undefined ?

Ambos son valores que usualmente se usan para indicar la ausencia de algo. undefined es el más genérico, usado como el valor predeterminado de las variables hasta que se les asigna algún otro valor, como el valor de los argumentos de la función que no se proporcionaron cuando se llamó a la función, y como el valor que obtiene cuando pregunta a un objeto de una propiedad que no tiene. Pero también se puede usar explícitamente en todas esas situaciones. (Hay una diferencia entre un objeto que no tiene una propiedad y tener la propiedad con el valor undefined ; hay una diferencia entre llamar a una función con el valor undefined para un argumento y dejar ese argumento por completo).

null es ligeramente más específico que undefined : es una referencia de objeto en blanco. Por supuesto, JavaScript está escrito de forma holgada, pero no todas las cosas con las que interactúa JavaScript se escriben de forma imprecisa. Si una API como el DOM en los navegadores necesita una referencia de objeto que está en blanco, usamos null , no undefined . Y de manera similar, la operación getElementById del DOM devuelve una referencia de objeto: una válida (si encontró el elemento DOM) o null (si no lo encontró).

Curiosamente (o no), son sus propios tipos. Es decir, null es el único valor en el tipo Nulo e undefined es el único valor en el tipo undefined .

¿Cuál es la diferencia entre "==" y "==="

La única diferencia entre ellos es que == hará coacción de tipo para tratar de conseguir que los valores coincidan, y === no lo hará. Entonces, por ejemplo, "1" == 1 es verdadero, porque "1" obliga a 1 . Pero "1" === 1 es falso , porque los tipos no coinciden. (¡ "1" !== 1 es verdadero.) El primer paso (real) de === es "¿Son los tipos de los operandos iguales?" y si la respuesta es "no", el resultado es false . Si los tipos son iguales, hace exactamente lo que == hace.

El tipo de coerción usa reglas bastante complejas y puede tener resultados sorprendentes (por ejemplo, "" == 0 es verdadero).

Más en la especificación:

• Comparación de igualdad abstracta ( == , también llamada igualdad "suelta")
• Comparación de igualdad estricta ( === )

Answer 2

¿Cómo verifico una variable si es nula o no definida?

simplemente compruebe si una variable tiene un valor válido como este:

if(variable)

devolverá verdadero si la variable no contiene:

• nulo
• indefinido
• 0
• falso
• "" (una cadena vacía)
• Yaya

Answer 3

La diferencia es sutil.

En JavaScript, una variable undefined es una variable que nunca se ha declarado o nunca se le ha asignado un valor. Digamos que usted declara var a; por ejemplo, a será undefined , porque nunca se le asignó ningún valor.

Pero si luego asignas a = null; entonces a será ahora null . En JavaScript, null es un objeto (pruebe con typeof null en una consola de JavaScript si no me cree), lo que significa que null es un valor (de hecho, incluso undefined es un valor).

Ejemplo:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

Esto puede resultar útil en argumentos de función. Es posible que desee tener un valor predeterminado, pero considere nulo como aceptable. En cuyo caso puedes hacer:

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

Si omite el parámetro optional doSomething(1, 2) then opcional será la cadena "three" pero si pasa doSomething(1, 2, null) , opcional será null .

En cuanto a los comparadores igual == y estrictamente igual === , el primero es de tipo débil, mientras que estrictamente igual también verifica el tipo de valores. Eso significa que 0 == "0" devolverá verdadero; mientras que 0 === "0" devolverá false, porque un número no es una cadena.

Puede usar esos operadores para verificar entre un null undefined . Por ejemplo:

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

El último caso es interesante, porque le permite verificar si una variable es indefinida o nula y nada más:

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

Answer 4

Si su comprobación (lógica) es para una negación (!) Y desea capturar JS null y undefined (ya que diferentes navegadores le darán resultados diferentes), usaría la comparación menos restrictiva: por ejemplo:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

Esto capturará tanto null como undefined

Answer 5

La especificación es el lugar para obtener respuestas completas a estas preguntas. Aquí hay un resumen:

1. Para una variable x , puedes:
   
   
   • compruebe si es null mediante comparación directa utilizando === . Ejemplo: x === null
   • verifique si está undefined por uno de estos dos métodos básicos: comparación directa con undefined o typeof . Por varias razones , prefiero typeof x === "undefined" .
   • compruebe si es uno de null e undefined utilizando == y confiando en las reglas de coerción de tipo ligeramente arcano que significan que x == null hace exactamente lo que desea.
     
     
2. La diferencia básica entre == y === es que si los operandos son de diferentes tipos, === siempre devolverá false mientras que == convertirá uno o ambos operandos en el mismo tipo usando rules que conducen a un comportamiento poco intuitivo. Si los operandos son del mismo tipo (por ejemplo, ambos son cadenas, como en la comparación de tipo de arriba), == y === se comportarán exactamente igual.

Más lectura:

• La Verdad, Igualdad y JavaScript de Angus Croll
• La coacción de JavaScript de Andrea Giammarchi es desmitificada
• Comp.lang.javascript Preguntas frecuentes: conversión de tipos de JavaScript

Answer 6

indefinido

Significa que la variable aún no está inicializada.

Ejemplo:

var x;
if(x){ //you can check like this
   //code.
}

es igual a (==)

Solo verifica el valor es igual al tipo de datos.

Ejemplo:

var x = true;
var y = new Boolean(true);
x == y ; //returns true

Porque solo comprueba valor.

Igual estricto (===)

Comprueba que el valor y el tipo de datos deben ser iguales.

Ejemplo:

var x = true;
var y = new Boolean(true);
x===y; //returns false.

Debido a que verifica el tipo de datos, x es un tipo primitivo y y es un objeto booleano.