Qual è la differenza tra null e undefined in JavaScript?

Voglio sapere qual è la differenza tra nulle undefinedin JavaScript.

In JavaScript, undefinedsignifica che una variabile è stata dichiarata ma non è stato ancora assegnato un valore, come ad esempio:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

nullè un valore di assegnazione. Può essere assegnato a una variabile come rappresentazione senza valore:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

Dagli esempi precedenti, è chiaro che undefinede nullsono due tipi distinti: undefinedè un tipo stesso (non definito) mentre nullè un oggetto.

null === undefined // false
null == undefined // true
null === null // true

e

null = 'value' // ReferenceError
undefined = 'value' // 'value'

L'ho scelto da qui

Il valore indefinito è un valore primitivo utilizzato quando a una variabile non è stato assegnato un valore.

Il valore null è un valore primitivo che rappresenta il riferimento null, vuoto o inesistente.

Quando dichiari una variabile attraverso var e non le dai un valore, il valore non sarà definito. Di per sé, se provi a WScript.Echo () o avvisa () questo valore, non vedrai nulla. Tuttavia, se aggiungi una stringa vuota ad essa, all'improvviso apparirà:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Puoi dichiarare una variabile, impostarla su null e il comportamento è identico, tranne per il fatto che vedrai "null" stampato contro "non definito". Questa è davvero una piccola differenza.

Puoi anche confrontare una variabile non definita con null o viceversa e la condizione sarà vera:

undefined == null
null == undefined

Sono, tuttavia, considerati due tipi diversi. Mentre undefined è un tipo tutto per sé, null è considerato un valore oggetto speciale. Puoi vederlo usando typeof () che restituisce una stringa che rappresenta il tipo generale di una variabile:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

L'esecuzione dello script precedente comporta il seguente output:

undefined
object

Indipendentemente dal fatto che si tratti di tipi diversi, agiranno comunque allo stesso modo se si tenta di accedere a un membro di uno dei due, ad esempio, vale a dire che genereranno un'eccezione. Con WSH vedrai il temuto "'varname' è nullo o non un oggetto" e questo è se sei fortunato (ma questo è un argomento per un altro articolo).

È possibile impostare esplicitamente una variabile come non definita, ma sconsiglio vivamente. Consiglio solo di impostare le variabili su null e di lasciare indefinito il valore per le cose che hai dimenticato di impostare. Allo stesso tempo, ti incoraggio davvero a impostare sempre ogni variabile. JavaScript ha una catena di ambito diversa da quella dei linguaggi in stile C, che confonde facilmente anche i programmatori veterani e impostare le variabili su null è il modo migliore per prevenire i bug basati su di esso.

Un'altra istanza in cui viene visualizzato un pop-up indefinito è quando si utilizza l'operatore di eliminazione. Quelli di noi di un mondo C potrebbero interpretare erroneamente questo come distruggere un oggetto, ma non è così. Ciò che questa operazione fa è rimuovere un indice da un array o un membro da un oggetto. Per gli array non ha effetto sulla lunghezza, ma piuttosto quel pedice ora è considerato indefinito.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

Il risultato dello script sopra è:

0.) a
1.) undefined
2.) c

Riceverai anche un ritorno indefinito quando leggi un pedice o un membro che non è mai esistito.

La differenza tra null e undefined è: JavaScript non imposterà mai nulla su null, di solito è quello che facciamo. Mentre possiamo impostare le variabili su indefinite, preferiamo null perché non è qualcosa che viene mai fatto per noi. Quando esegui il debug, ciò significa che tutto ciò che è impostato su null è di tua iniziativa e non JavaScript. Oltre a ciò, questi due valori speciali sono quasi equivalenti.

(aggiungendo personaggi per mancanza di personaggi, quindi sono autorizzato a postare questo.)

null è una parola chiave speciale che indica un'assenza di valore.

pensalo come un valore, come:

• "pippo" è stringa,
• vero è booleano,
• 1234 è numero,
• null non è definito.

la proprietà non definita indica che a una variabile non è stato assegnato un valore incluso anche null. Piace

var foo;

la variabile vuota definita è nulldi tipo datiundefined

Entrambi rappresentano un valore di una variabile senza valore

AND null non rappresenta una stringa che non ha valore - stringa vuota-

Piace

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Ora se

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

MA

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

Quindi ognuno ha il suo modo di usare

non definito usarlo per confrontare il tipo di dati variabile

null lo usa per svuotare un valore di una variabile

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null : assenza di valore per una variabile; indefinito : assenza della variabile stessa;

..where variabile è un nome simbolico associato a un valore.

JS potrebbe essere abbastanza gentile da avviare implicitamente variabili appena dichiarate con null , ma non lo fa.

Si prega di leggere attentamente quanto segue. Rimuoverà tutti i tuoi dubbi sulla differenza tra null e non definito in JavaScript. Inoltre è possibile utilizzare la funzione di utilità indicata di seguito per determinare esattamente i tipi.

In JavaScript possiamo avere i seguenti tipi di variabili.

1. Variabili non dichiarate
2. Variabili dichiarate ma non assegnate
3. Variabili assegnate con letterale indefinito
4. Variabili assegnate con null letterale
5. Variabili assegnate con qualcosa di diverso da indefinito o nullo

Di seguito viene spiegato ciascuno di questi casi uno per uno

1. Variabili non dichiarate : il seguito vale per le variabili non dichiarate

   • Può essere verificato solo da typeof () che restituisce la stringa 'non definita'
   • Non è possibile verificare con == o === o dall'operatore if o condizionale ? (genera un errore di riferimento)

2. Variabili dichiarate ma non assegnate

   • typeof restituisce la stringa 'undefined'
   • == verifica con null restituisce vero
   • == verifica con ritorni indefiniti vero
   • === verifica con null restituisce false
   • === verifica con valori indefiniti restituiti true
   • se o operatore condizionale ? restituisce false

3. Variabili assegnate con letterale indefinito : queste variabili sono trattate in modo simile alle variabili dichiarate ma non assegnate .

4. Variabili assegnate con null letterale

   • typeof restituisce la stringa 'oggetto'
   • == verifica con null restituisce vero
   • == verifica con ritorni indefiniti vero
   • === verifica con null restituisce vero
   • === verifica con rendimenti indefiniti false
   • se o operatore condizionale ? restituisce false

5. Variabili assegnate con qualcosa di diverso da indefinito o nullo

   • typeof restituisce una delle seguenti stringhe: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

Di seguito viene fornito l'algoritmo per il corretto controllo del tipo di una variabile:

1. Controllare non dichiarato / non assegnato / assegnato con non definito utilizzando typeof . restituisce se viene restituita la stringa "non definita" .
2. Controllare null usando === . restituisce 'null' se vero .
3. Verificare il tipo effettivo utilizzando typeof . restituisce il tipo se non uguale a "oggetto"
4. Chiamare Object.prototype.toString.call (o) per determinare il tipo di oggetto effettivo. Restituirà una stringa di tipo '[object ObjectType]' per tutti gli oggetti definiti in Javascript o DOM definiti. Per gli oggetti definiti dall'utente restituisce '[oggetto Object]'

È inoltre possibile utilizzare la seguente funzione di utilità per determinare i tipi. Attualmente supporta tutti i tipi di ECMA 262 2017.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

Potresti considerare indefinito rappresentare un'assenza di valore a livello di sistema, imprevista o simile a un errore e null per rappresentare un'assenza di valore a livello di programma, normale o previsto.

tramite JavaScript: la guida definitiva

Mi spiego undefined, nulle Uncaught ReferenceError:

1 - Uncaught ReferenceError: la variabile non è stata dichiarata nel tuo script, non vi è alcun riferimento a questa variabile
2 - undefined: variabile dichiarata ma non inizializzata
3 - null: variabile dichiarata ed è un valore vuoto

Undefined significa che una variabile è stata dichiarata ma non ha valore:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null è un compito:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

null e undefined sono due tipi di oggetti distinti che hanno in comune quanto segue:

• entrambi possono contenere solo un singolo valore, rispettivamente nullo e indefinito ;
• entrambi non hanno proprietà o metodi e un tentativo di leggere qualsiasi proprietà di entrambi provocherà un errore di runtime (per tutti gli altri oggetti, si ottiene un valore indefinito se si tenta di leggere una proprietà inesistente);
• i valori null e indefiniti sono considerati uguali tra loro e nient'altro da ==e !=operatori.

Le somiglianze tuttavia finiscono qui. Per una volta, esiste una differenza fondamentale nel modo in cui vengono implementate le parole chiave null e indefinite . Questo non è ovvio, ma considera il seguente esempio:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

indefinito , NaN e Infinity sono solo nomi di variabili "superglobal" preinizializzate: sono inizializzate in fase di esecuzione e possono essere sovrascritte da una normale variabile globale o locale con gli stessi nomi.

Ora proviamo la stessa cosa con null :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Oops! null , true e false sono parole chiave riservate - il compilatore non ti permetterà di usarle come nomi di variabili o proprietà

Un'altra differenza è che undefined è un tipo primitivo, mentre null è un tipo di oggetto (che indica l'assenza di un riferimento a un oggetto). Considera quanto segue:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Inoltre, esiste una differenza importante nel modo in cui vengono considerati null e indefiniti in un contesto numerico:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

null diventa 0 se utilizzato in espressioni aritmetiche o confronti numerici - analogamente a false , è fondamentalmente solo un tipo speciale di "zero". undefined , d'altra parte, è un vero "nulla" e diventa NaN ("non un numero") quando si tenta di utilizzarlo in un contesto numerico.

Si noti che nulla e non definiti ricevono un trattamento speciale da ==e !=operatori, ma si può provare vera uguaglianza numerica di un e B con l'espressione (a >= b && a <= b).

tl; dr

Utilizzare nullper impostare una variabile che si sa che è un oggetto.

Utilizzare undefinedper impostare una variabile il cui tipo è misto.

Questo è il mio uso sia di 5 primitive che di tipo di oggetto, e questo spiega la differenza tra «caso d'uso» di undefinedo null.

Corda

Se sai che una variabile è solo una stringa mentre tutto il ciclo di vita, per convenzione, potresti inizializzarla, per "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Numero

Se sai che una variabile è solo un numero mentre tutto il ciclo di vita, per convenzione, potresti inizializzarlo, a 0(o NaNse 0è un valore importante nel tuo utilizzo):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

o

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

booleano

Se sai che una variabile è solo un valore booleano mentre tutto il ciclo di vita, per convenzione, potresti inizializzarlo, per false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Oggetto

Se sai che una variabile è solo un oggetto mentre tutto il ciclo di vita, per convenzione, potresti inizializzarlo, per null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Nota: l'uso intelligente off null deve essere la versione falsa di un oggetto perché un oggetto è sempre truee perché typeof nullrestituito object. Ciò significa che typeof myVarObjectrestituisce un valore coerente sia per l'oggetto che per il tipo null.

Tutti

Se sai che una variabile ha un tipo misto (qualsiasi tipo durante tutto il ciclo di vita), per convenzione, puoi inizializzarlo a undefined.

nullè un valore speciale che significa "nessun valore". nullè un oggetto speciale perché typeof nullrestituisce 'oggetto'.

D'altra parte, undefinedsignifica che la variabile non è stata dichiarata o non ha ricevuto un valore.

Il modo migliore per capire la differenza è prima chiarire la tua mente sul funzionamento interno di JavaScript e capire semplicemente le differenze di significato tra:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Esiste una differenza di significato tra questi tre casi e JavaScript distingue gli ultimi due casi con due valori diversi nulle undefined. Sei libero di usare quei valori in modo esplicito per trasmettere quei significati.

Quindi quali sono alcuni dei problemi specifici di JavaScript che sorgono a causa di questa base filosofica?

1. Una variabile dichiarata senza un inizializzatore ottiene il valore undefinedperché non hai mai detto nulla sul valore desiderato.

   let supervisor;
   assert(supervisor === undefined);

2. Una proprietà di un oggetto che non è mai stata impostata valuta undefinedperché nessuno ha mai detto nulla su quella proprietà.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. nulle undefinedsono "simili" tra loro perché lo ha detto Brendan Eich. Ma non sono assolutamente uguali tra loro.

   assert(null == undefined);
   assert(null !== undefined);

4. nulle per undefinedfortuna hanno diversi tipi. nullappartiene al tipo Nulle undefinedal tipo Undefined. Questo è nelle specifiche, ma non lo sapresti mai a causa della typeofstranezza che non ripeterò qui.

5. Una funzione che raggiunge la fine del suo corpo senza una dichiarazione di ritorno esplicita ritorna undefinedpoiché non sai nulla di ciò che ha restituito.

A proposito, ci sono altre forme di "nulla" in JavaScript (è bene aver studiato filosofia ...)

• NaN
• Usare una variabile che non è mai stata dichiarata e ricevere a ReferenceError
• Utilizzando una leto constvariabile locale definita nella sua zona morta temporale e riceve unReferenceError

• Celle vuote in matrici sparse. Sì, questi non sono nemmeno undefinedse confrontati ===con indefiniti.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

In JavasSript ci sono 5 tipi di dati primitivi String, Number, Boolean, null e undefined. Proverò a spiegare con qualche semplice esempio

diciamo che abbiamo una funzione semplice

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

anche nella funzione sopra se (a == null) è uguale a se (! a)

ora quando chiamiamo questa funzione senza passare il parametro a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

anche

var a;
alert(typeof a); 

questo darà indefinito; abbiamo dichiarato una variabile ma non abbiamo assegnato alcun valore a questa variabile; ma se scriviamo

var a = null;
alert(typeof a); will give alert as object

quindi null è un oggetto. in un certo senso abbiamo assegnato un valore null a 'a'

Per il undefinedtipo, v'è uno ed un solo valore: undefined.

Per il nulltipo, v'è uno ed un solo valore: null.

Quindi, per entrambi, l'etichetta è sia il suo tipo che il suo valore.

La differenza tra loro. Per esempio:

• null è un valore vuoto
• undefined è un valore mancante

O:

• undefined non ha ancora avuto un valore
• null aveva un valore e non lo fa più

In realtà, nullè una parola chiave speciale , non un identificatore, e quindi non puoi trattarla come una variabile a cui assegnare.

Tuttavia, undefinedè un identificatore . In entrambe le non-strictmodalità e strictmodalità, tuttavia, è possibile creare una variabile locale del nome non definito. Ma questa è un'idea terribile!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Quando dichiari una variabile in javascript, viene assegnato il valore undefined . Ciò significa che la variabile è intatta e può essere assegnata a qualsiasi valore in futuro. Implica anche che non si conosce il valore che questa variabile manterrà al momento della dichiarazione.

Ora puoi assegnare esplicitamente una variabile null . Significa che la variabile non ha alcun valore. Ad esempio: alcune persone non hanno un secondo nome. Quindi in tal caso è meglio assegnare il valore null alla variabile middlename di un oggetto persona.

Supponiamo ora che qualcuno stia accedendo alla variabile middlename dell'oggetto person e che abbia il valore undefined. Non saprebbe se lo sviluppatore abbia dimenticato di inizializzare questa variabile o se non avesse alcun valore. Se ha il valore null, l'utente può facilmente dedurre che il nome medio non ha alcun valore e non è una variabile non trattata.

null e undefined sono entrambi usati per rappresentare l'assenza di un certo valore.

var a = null;

a è inizializzato e definito.

typeof(a)
//object

null è un oggetto in JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

b è indefinito e non inizializzato

anche le proprietà dell'oggetto non definito sono indefinite. Ad esempio "x" non è definito sull'oggetto c e se si tenta di accedere a cx, verrà restituito indefinito.

Generalmente assegniamo null a variabili non indefinite.

L'articolo completo di Ryan Morr su questo argomento ...

"In genere, se è necessario assegnare un non valore a una variabile o proprietà, passarlo a una funzione o restituirlo da una funzione, null è quasi sempre l'opzione migliore. Per dirla semplicemente, JavaScript utilizza undefined e i programmatori dovrebbero usa null. "

Vedi Esplorazione dell'abisso eterno di nulla e indefinito

Sia Null che indefinito in JavaScript indicano assenza di valore.

var a = null; //variable assigned null value
var b;  // undefined

Nonostante entrambi esistano per assenza di valore ma: Undefined in realtà significa che la variabile non è inizializzata. Funzioni che non restituiscono nulla e parametri di funzione per i quali non viene fornito alcun valore, viene restituito un valore indefinito. Utilizzare l'operatore di uguaglianza rigorosa === per distinguere tra null e non definito.

Riferimento: http://www.thesstech.com/javascript/null-and-undefined

OK, potremmo confonderci quando sentiamo parlare nulle undefined, ma cominciamo semplice, entrambi sono falsi e simili in molti modi, ma parte strana di JavaScript, li rende un paio di differenze significative, ad esempio, typeof null è 'object'mentre typeof undefined è 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Ma se li controlli ==come di seguito, vedi che sono entrambi falsi :

null==undefined; //true

Inoltre è possibile assegnare nulla una proprietà dell'oggetto o a una primitiva, mentre si undefinedpuò semplicemente ottenere non assegnando nulla.

Creo un'immagine rapida per mostrare le differenze per te a colpo d'occhio.

Poiché typeof restituisce undefined, undefined è un tipo in cui null è un inizializzatore che indica che la variabile punta a nessun oggetto (praticamente tutto in Javascript è un oggetto).

In JavaScript tutte le variabili sono memorizzate come coppie chiave-valore. Ogni variabile è memorizzata come nome_variabile: valore_valore / riferimento .

undefined significa che a una variabile è stato assegnato uno spazio in memoria, ma nessun valore è assegnato ad essa. Come best practice, non utilizzare questo tipo come compito.

In tal caso, come indicare quando si desidera che una variabile sia priva di valore in un punto successivo del codice? È possibile utilizzare il tipo null , che è anche un tipo utilizzato per definire la stessa cosa, assenza di un valore, ma non è lo stesso di un indefinito, poiché in questo caso si ha effettivamente il valore in memoria. Quel valore è nullo

Entrambi sono simili ma l'uso e il significato sono diversi.

Voglio aggiungere una differenza molto sottile tra nulle undefinedche è bene sapere quando stai cercando di imparare Vanilla JavaScript (JS) da zero:

• nullè una parola chiave riservata in JS mentre undefinedè una variabile sull'oggetto globale dell'ambiente di runtime in cui ci si trova.

Durante la scrittura del codice, questa differenza non è identificabile come entrambi nulle undefinedviene sempre utilizzata in RHS di un'istruzione JavaScript. Ma quando li usi in LHS di un'espressione, puoi facilmente osservare questa differenza. Quindi l'interprete JS interpreta il codice seguente come errore:

var null = 'foo'

Dà sotto l'errore:

Uncaught SyntaxError: token imprevisto null

Mentre sotto il codice viene eseguito correttamente anche se non ti consiglio di farlo nella vita reale:

var undefined = 'bar'

Questo funziona perché undefinedè una variabile sull'oggetto globale (oggetto finestra del browser in caso di JS lato client)

La differenza tra undefinede nullè minima, ma c'è una differenza. Una variabile il cui valore è undefinednon è mai stata inizializzata. Una variabile il cui valore è nullstato esplicitamente assegnato un valore null, il che significa che la variabile è stata esplicitamente impostata per non avere alcun valore. Se si confronta undefinede nullusando l' null==undefinedespressione, saranno uguali.

Fondamentalmente, Undefined è una variabile globale che javascript crea in fase di esecuzione se null significa che nessun valore è stato assegnato alla variabile (in realtà null è esso stesso un oggetto).

Facciamo un esempio:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Non definito, ecco cosa otterrai come output.

Adesso,

        x=5;
        y=null;
        z=x+y;

e otterrai 5 come output. Questa è la differenza principale tra il Non definito e il null

nullo - È un valore di assegnazione, che viene utilizzato con la variabile per rappresentare nessun valore (è un oggetto).

non definito - È una variabile a cui non è assegnato alcun valore, quindi JavaScript gli assegnerà un indefinito (è un tipo di dati).

undeclared : se una variabile non viene creata affatto, è nota come non dichiarata.

Controllalo. L'output vale più di mille parole.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Guarda anche:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

Saluti!

Entrambi i valori speciali implicano uno stato vuoto.

La differenza principale è che undefined rappresenta il valore di una variabile non ancora inizializzata, mentre null rappresenta un'assenza intenzionale di un oggetto.

Il numero variabile è definito, tuttavia, non è assegnato con un valore iniziale:

let number;
number; // => undefined

la variabile numerica non è definita, il che indica chiaramente una variabile non inizializzata

Lo stesso concetto non inizializzato si verifica quando si accede a una proprietà dell'oggetto inesistente:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

Poiché la proprietà lastName non esiste in obj, JavaScript valuta correttamente obj.lastName come non definito.

In altri casi, sai che una variabile prevede di contenere un oggetto o una funzione per restituire un oggetto. Ma per qualche motivo, non puoi istanziare l'oggetto. In tal caso, null è un indicatore significativo di un oggetto mancante.

Ad esempio, clone () è una funzione che clona un semplice oggetto JavaScript. La funzione dovrebbe restituire un oggetto:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

Tuttavia, clone () potrebbe essere invocato con un argomento non oggetto: 15 o null (o generalmente un valore primitivo, null o non definito). In tal caso, la funzione non può creare un clone, quindi restituisce null - l'indicatore di un oggetto mancante.

L' operatore typeof fa la distinzione tra i due valori:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

L'operatore di qualità rigorosa === differenzia correttamente undefined da null:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

Oltre a un significato diverso ci sono altre differenze:

1. La destrutturazione degli oggetti funziona diversamente per questi due valori:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () mantiene nullma ometteundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. operatore di tipo

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

Se una variabile non è inizializzata, non è definita. non definito non è un oggetto. Esempio: var MyName; console.log (typeof MyName);

Controllare il registro della console nello strumento di sviluppo, verrà stampato come non definito.

null è un oggetto. Se si desidera che una variabile sia nulla, viene utilizzato null. Nessuna variabile esiste ma il valore non è noto. Dovrebbe essere assegnato a una variabile in modo grammaticale. null non viene inizializzato automaticamente.

Esempio: var MyName = null; console.log (typeof MyName); Controlla il registro csole nello strumento di sviluppo, sarà un oggetto.