Controllo JavaScript per null vs non definito e differenza tra == e ===

1. Come posso controllare una variabile se è nullo undefinede qual è la differenza tra nulle undefined?

2. Qual è la differenza tra ==e ===(è difficile cercare "===" su Google)?

Come posso controllare una variabile se è nullo undefined...

È la variabile null:

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

... ma nota che anche quest'ultimo sarà vero se lo aè undefined.

È undefined:

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

... ma ancora una volta, nota che l'ultimo è vago; sarà anche vero se lo aè null.

Ora, nonostante quanto sopra, il solito modo per verificarli è usare il fatto che sono falsi :

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

Questo è definito da ToBoolean nelle specifiche.

... e qual è la differenza tra il nulle undefined?

Sono entrambi valori normalmente usati per indicare l'assenza di qualcosa. undefinedè quello più generico, utilizzato come valore predefinito delle variabili fino a quando non viene assegnato loro un altro valore, come valore degli argomenti della funzione che non sono stati forniti quando è stata chiamata la funzione e come valore ottenuto quando si chiede un oggetto per una proprietà che non ha. Ma può anche essere esplicitamente utilizzato in tutte quelle situazioni. (C'è una differenza tra un oggetto che non ha una proprietà e avere la proprietà con il valore undefined; c'è una differenza tra chiamare una funzione con il valore undefinedper un argomento e lasciare completamente quell'argomento.)

nullè leggermente più specifico di undefined: è un riferimento a un oggetto vuoto. Ovviamente JavaScript viene tipizzato in modo approssimativo, ma non tutte le cose con cui interagisce JavaScript vengono digitate in modo approssimativo. Se un'API come il DOM nei browser ha bisogno di un riferimento a un oggetto che è vuota, si usa null, non è undefined. Allo stesso modo, l' getElementByIdoperazione del DOM restituisce un riferimento a un oggetto, valido (se ha trovato l'elemento DOM) o null(in caso contrario).

È interessante (o no), sono i loro stessi tipi. Vale a dire, nullè l'unico valore nel tipo Null ed undefinedè l'unico valore nel tipo Non definito.

Qual è la differenza tra "==" e "==="

L'unica differenza tra loro è che ==digiteranno la coercizione per cercare di far corrispondere i valori e ===non lo faranno. Quindi per esempio "1" == 1è vero, perché "1"costringe a 1. Ma "1" === 1è falso , perché i tipi non corrispondono. ( "1" !== 1è vero.) Il primo (reale) passo di ===è "I tipi di operandi sono uguali?" e se la risposta è "no", il risultato è false. Se i tipi sono uguali, fa esattamente quello che ==fa.

La coercizione del tipo utilizza regole piuttosto complesse e può avere risultati sorprendenti (ad esempio, "" == 0è vero).

Più nelle specifiche:

• Confronto astratto dell'uguaglianza ( ==, chiamato anche uguaglianza "libera")
• Confronto rigoroso sull'uguaglianza ( ===)

La differenza è sottile.

In JavaScript una undefinedvariabile è una variabile che non è mai stata dichiarata o che non ha mai assegnato un valore. Diciamo che dichiari var a;ad esempio, allora alo sarà undefined, perché non gli è mai stato assegnato alcun valore.

Ma se poi assegna a = null;allora asarà ora null. In JavaScript nullè un oggetto (prova typeof nullin una console JavaScript se non mi credi), il che significa che null è un valore (in realtà undefinedè anche un valore).

Esempio:

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

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

Ciò può rivelarsi utile negli argomenti delle funzioni. È possibile che si desideri avere un valore predefinito, ma considerare null accettabile. Nel qual caso puoi fare:

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

Se si omette il optionalparametro doSomething(1, 2) thenfacoltativo sarà la "three"stringa ma se si passa, doSomething(1, 2, null)sarà facoltativo null.

Per quanto riguarda i comparatori uguali ==e rigorosamente uguali ===, il primo è di tipo debole, mentre rigorosamente uguale controlla anche il tipo di valori. Ciò significa che 0 == "0"tornerà vero; while 0 === "0"restituirà false, poiché un numero non è una stringa.

È possibile utilizzare tali operatori per controllare tra undefinedun null. Per esempio:

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

L'ultimo caso è interessante, perché ti permette di verificare se una variabile è indefinita o nulla e nient'altro:

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

La specifica è il posto dove cercare risposte complete a queste domande. Ecco un riassunto:

1. Per una variabile x, puoi:
   
   
   • controlla se è nulltramite confronto diretto usando ===. Esempio:x === null
   • controlla se si tratta undefineddi uno dei due metodi di base: confronto diretto con undefinedo typeof. Per vari motivi , preferisco typeof x === "undefined".
   • controlla se è una delle nulle undefinedusando ==e facendo affidamento sulle regole di coercizione di tipo leggermente arcane che significano x == nullfare esattamente quello che vuoi.
     
     
2. La differenza fondamentale tra ==e ===è che se gli operandi sono di tipo diverso, ===ritorneranno sempre falsementre ==convertiranno uno o entrambi gli operandi nello stesso tipo usando regole che portano a comportamenti leggermente non intuitivi. Se gli operandi sono dello stesso tipo (ad es. Entrambi sono stringhe, come nel typeofconfronto sopra), ==e ===si comporteranno esattamente allo stesso modo.

Più lettura:

• Verità, uguaglianza e JavaScript di Angus Croll
• Demercitazione della coercizione JavaScript di Andrea Giammarchi
• Domande frequenti su comp.lang.javascript: conversione di tipo JavaScript

Come posso controllare una variabile se è nulla o non definita

controlla solo se una variabile ha un valore valido come questo:

if(variable)

restituirà vero se la variabile non contiene:

• nullo
• non definito
• 0
• falso
• "" (una stringa vuota)
• NaN

non definito

Significa che la variabile non è ancora stata inizializzata.

Esempio :

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

uguale (==)

Verifica solo che il valore sia uguale al tipo di dati.

Esempio :

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

Perché controlla solo il valore.

Uguali rigorosi (===)

Verifica che il valore e il tipo di dati siano uguali.

Esempio :

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

Perché controlla il tipo di dati x è un tipo primitivo e y è un oggetto booleano.

L'annuncio 1. nullnon è un identificatore per una proprietà dell'oggetto globale, come undefined può essere

let x;      // undefined
let y=null; // null
let z=3;    // has value
// 'w'      // is undeclared

if(!x) console.log('x is null or undefined');
if(!y) console.log('y is null or undefined');
if(!z) console.log('z is null or undefined');

try { if(w) 0 } catch(e) { console.log('w is undeclared') }
// typeof not throw exception for undelared variabels
if(typeof w === 'undefined') console.log('w is undefined');

Annuncio 2. ===Valori e tipi di controllo. Il ==Dont richiedono stessi tipi e reso conversione implicita prima del confronto (usando .valueOf()e .toString()). Qui hai tutto ( src ):

Se

== (la sua negazione ! = )

=== (la sua negazione ! == )

Se il tuo controllo (logico) è per una negazione (!) E vuoi catturare sia JS nullche undefined (poiché diversi Browser ti daranno risultati diversi) useresti il ​​confronto meno restrittivo: es:

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

Questo catturerà sia nulleundefined

Prova con logica diversa . Puoi usare il codice seguente per controllare tutte e quattro le condizioni (4) per la convalida come non null, non vuoto, non definito e non zero utilizzare questo codice (! (! (Variabile))) in javascript e jquery.

function myFunction() {
var data;  //The Values can be like as null, blank, undefined, zero you can test

if(!(!(data)))
{
   //If data has valid value
    alert("data "+data);
} 
else 
{
    //If data has null, blank, undefined, zero etc.
    alert("data is "+data);
}

}