Perché null è un oggetto e qual è la differenza tra null e undefined?

Question

Perché null è considerato un oggetto in JavaScript?

Sta controllando

if ( object == null )
      Do something

uguale a

if ( !object )
      Do something

E anche:

Qual è la differenza tra null e undefined ?

Answer 1

(name is undefined)

Tu: che cos'è name ? ^(*)
JavaScript: name ? Che cos'è un name ? Non so di cosa stai parlando. Non hai mai menzionato nessun nome prima. Stai vedendo qualche altro linguaggio di scripting sul lato (client)?

name = null;

Tu: che cos'è name ?
JavaScript: non lo so.

In breve; undefined è dove non esiste alcuna nozione della cosa; non ha tipo e non è mai stato menzionato prima in tale ambito; null è dove esiste la cosa, ma non si sa quale sia il valore.

Una cosa da ricordare è che null non è, concettualmente, la stessa cosa di false o " " o simili, anche se si equivalgono dopo il cast del tipo, ovvero

name = false;

Tu: che cos'è name ?
JavaScript: booleano falso.

name = '';

Tu: che cos'è name ?
JavaScript: stringa vuota

---

^{*: name in questo contesto è inteso come una variabile che non è mai stata definita. Potrebbe essere una variabile non definita, tuttavia il nome è una proprietà di quasi tutti gli elementi del modulo HTML. Va molto indietro nel tempo ed è stato istituito ben prima dell'id. È utile perché gli ID devono essere univoci ma i nomi non devono essere.}

Answer 2

La differenza può essere riassunta in questo frammento:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

Controllo

object == null è diverso per controllare if (! object) .

Quest'ultimo è uguale a ! Booleano (oggetto) , perché l'operatore unario ! lancia automaticamente l'operando giusto in un booleano.

Poiché Boolean (null) è uguale a false, allora ! false === true .

Quindi se il tuo oggetto è non nullo , ma falso o 0 o " " ; , il controllo passerà perché:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

Answer 3

null non è non un oggetto , è un valore primitivo . Ad esempio, non è possibile aggiungere proprietà ad esso. A volte le persone assumono erroneamente che si tratti di un oggetto, perché typeof null restituisce " object " . Ma questo è in realtà un bug (che potrebbe anche essere corretto in ECMAScript 6).

La differenza tra null e undefined è la seguente:

• undefined : usato da JavaScript e significa & # 8220; nessun valore & # 8221 ;. Le variabili non inizializzate, i parametri mancanti e le variabili sconosciute hanno quel valore.

  > var noValueYet;
  > console.log(noValueYet);
  undefined
  
  > function foo(x) { console.log(x) }
  > foo()
  undefined
  
  > var obj = {};
  > console.log(obj.unknownProperty)
  undefined
  

  L'accesso a variabili sconosciute, tuttavia, produce un'eccezione:

  > unknownVariable
  ReferenceError: unknownVariable is not defined
  

• null : utilizzato dai programmatori per indicare & # 8220; nessun valore & # 8221 ;, ad es. come parametro per una funzione.

Esame di una variabile:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

Come regola generale, dovresti sempre usare === e mai == in JavaScript (== esegue tutti i tipi di conversioni che possono produrre risultati imprevisti). Il segno di spunta x == null è un caso limite, perché funziona sia per null che per undefined :

> null == null
true
> undefined == null
true

Un modo comune per verificare se una variabile ha un valore è convertirlo in booleano e vedere se è true . Tale conversione viene eseguita dall'istruzione if e dall'operatore booleano! (& # 8220; Non & # 8221;).

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Svantaggio di questo approccio: tutti i seguenti valori vengono valutati in false , quindi è necessario fare attenzione (ad esempio, i controlli di cui sopra non possono distinguere tra undefined e 0 ).

• undefined , null
• Booleani: false
• Numeri: +0 , -0 , NaN
• Stringhe: ""

Puoi testare la conversione in booleano usando Boolean come una funzione (normalmente è un costruttore, da usare con nuovo ):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

Answer 4

  

Qual è la differenza tra null e undefined ??

Una proprietà quando non ha definizione, non è definita. null è un oggetto. Il suo tipo è oggetto. null è un valore speciale che significa "nessun valore. undefined non è un oggetto, il suo tipo non è definito.

Puoi dichiarare una variabile, impostarla su null e il comportamento è identico, tranne per il fatto che vedrai " null " stampato contro "non definito". Puoi persino confrontare una variabile non definita con null o viceversa e la condizione sarà vera:

 undefined == null
 null == undefined

Consultare JavaScript Differenza tra null e non definito per maggiori dettagli.

e con la tua nuova modifica sì

if (object == null)  does mean the same  if(!object)

quando si verifica se l'oggetto è falso, entrambi soddisfano solo la condizione quando si verifica se falso , ma non quando vero

Controlla qui: Javascript gotcha

Answer 5

Prima parte della domanda:

  

Perché null è considerato un oggetto in JavaScript?

È un errore di progettazione JavaScript che non possono essere corretti ora. Avrebbe dovuto essere di tipo null, non di tipo object o non averlo affatto. Richiede un controllo extra (a volte dimenticato) quando si rilevano oggetti reali ed è fonte di bug.

Seconda parte della domanda:

  

Sta controllando
  
   if (oggetto == null)
   Fai qualcosa
  
  lo stesso di
  
   if (! object)
   Fai qualcosa

I due controlli sono sempre entrambi falsi tranne:

L'oggetto

• è indefinito o nullo: entrambi veri.

L'oggetto

• è primitivo e 0, " " o false: prima controlla false, seconda true.

Se l'oggetto non è una primitiva, ma un oggetto reale, come new Number (0) , new String (" ") o new Boolean (false) , quindi entrambi i controlli sono falsi.

Quindi, se 'oggetto' viene interpretato come un oggetto reale, entrambi i controlli sono sempre gli stessi. Se sono consentite le primitive, i controlli sono diversi per 0, " " e false.

In casi come object == null , i risultati non visibili potrebbero essere fonte di bug. L'uso di == non è mai raccomandato, utilizzare invece === .

Terza parte della domanda:

  

E anche:
  
  Qual'è la differenza tra null e undefined?

In JavaScript, una differenza è che null è di tipo object e undefined è di tipo undefined.

In JavaScript, null == undefined è vero e considerato uguale se il tipo viene ignorato. Perché hanno deciso che, ma 0, " " e false non sono uguali, non lo so. Sembra essere un'opinione arbitraria.

In JavaScript, null === undefined non è vero poiché il tipo deve essere lo stesso in === .

In realtà, null e indefinito sono identici, poiché entrambi rappresentano la non esistenza. Lo stesso vale per 0, e " " e anche i contenitori vuoti [] e {} . Così tanti tipi dello stesso niente sono una ricetta per i bug. Un tipo o nessuno è migliore. Vorrei provare a utilizzare il minor numero possibile.

'false', 'true' e '!' sono un'altra borsa di worm che potrebbe essere semplificata, ad esempio se (! x) e se (x) da soli sono sufficienti, non hai bisogno di vero e falso.

Un var x dichiarato è di tipo indefinito se non viene fornito alcun valore, ma dovrebbe essere uguale a se x non fosse mai stato dichiarato affatto. Un'altra fonte di bug è un contenitore vuoto nulla. Quindi è meglio dichiararlo e definirlo insieme, come var x = 1 .

La gente gira e rigira in tondo cercando di capire tutti questi vari tipi di niente, ma è la stessa cosa in complicati abiti diversi. La realtà è

undefined===undeclared===null===0===""===[]==={}===nothing

E forse tutti dovrebbero generare eccezioni.

Answer 6

var x = null;

x è definito come null

y non è definito; // perché non l'ho definito

if (!x)

null viene valutato come falso

Answer 7

Un modo per dare un senso a null e indefinito è capire dove si verificano ciascuno di essi.

Aspettatevi un valore di ritorno nullo nelle seguenti situazioni:

• Metodi che interrogano il DOM

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null
  

• Risposte JSON ricevute da una richiesta Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Nuova funzionalità in stato di flusso. Quanto segue restituisce null:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Tutti gli altri casi di inesistenza sono indicati da undefined (come notato da @Axel). Ciascuna delle seguenti stampe "non definito":

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Naturalmente se decidi di scrivere var unitialised = null; o restituisci null da un metodo tu stesso allora hai null che si verifica in altre situazioni. Ma dovrebbe essere abbastanza ovvio.

Un terzo caso è quando si desidera accedere a una variabile ma non si sa nemmeno se è stata dichiarata. In tal caso, utilizzare typeof per evitare un errore di riferimento:

if(typeof unknown !== "undefined"){
    //use unknown
}

In sintesi, verifica la presenza di null durante la manipolazione del DOM, la gestione di Ajax o l'utilizzo di determinate funzioni di ECMAScript 5. Per tutti gli altri casi è sicuro verificare che non siano definiti con una rigorosa uguaglianza:

if(value === undefined){
  // stuff
}

Answer 8

Confronto di molti diversi controlli null in JavaScript:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http: // aaron-hoffman .blogspot.com / 2013/04 / javascript-null-controllo-undefined-and.html

Answer 9

null e undefined sono entrambi false per l'uguaglianza dei valori (null == undefined): entrambi collassano in booleano false. Non sono lo stesso oggetto (null! == undefined).

undefined è una proprietà dell'oggetto globale ("finestra" nei browser), ma è un tipo primitivo e non un oggetto stesso. È il valore predefinito per le variabili e le funzioni non inizializzate che terminano senza un'istruzione return.

null è un'istanza di Object. null viene utilizzato per i metodi DOM che restituiscono oggetti di raccolta per indicare un risultato vuoto, che fornisce un valore falso senza indicare un errore.

Answer 10

Alcune precisazioni:

null e non definito sono due valori diversi. Uno rappresenta l'assenza di un valore per un nome e l'altro rappresenta l'assenza di un nome.

---

Cosa succede in un if è il seguente per if (o) :

Viene valutata l'espressione tra parentesi o, quindi if inizia a forzare il valore dell'espressione tra parentesi - nel nostro caso o .

I valori falsi (che verranno costretti a falsi) in JavaScript sono: '', null, undefined, 0 e false .

Answer 11

Aggiungere alla risposta di Qual è la differenza tra undefined e null , dalla guida definitiva di JavaScript in questa pagina :

  

Potresti considerare undefined per rappresentare a livello di sistema, imprevisto,   o un'assenza di valore simile a un errore e null per rappresentare a livello di programma,   assenza di valore normale o prevista. Se è necessario assegnare uno di   questi valori a una variabile o proprietà o passare uno di questi valori a   una funzione, null è quasi sempre la scelta giusta.

Answer 12

La seguente funzione mostra perché ed è in grado di capire la differenza:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Se chiami

test();

Stai ricevendo

  

undefined

     

nullo

Il primo console.log (...) tenta di ottenere myProperty da myObj mentre non è ancora definito - quindi ottiene indietro "non definito". Dopo avergli assegnato null, il secondo console.log (...) restituisce ovviamente " null " perché myProperty esiste, ma gli è stato assegnato il valore null .

Per poter interrogare questa differenza, JavaScript ha null e undefined : mentre null è - proprio come in altre lingue un oggetto, undefined non può essere un oggetto perché non è disponibile un'istanza (nemmeno un'istanza null ).

Answer 13

null è un oggetto. Il suo tipo è nullo. undefined non è un oggetto; il suo tipo è indefinito.

Answer 14

Ad esempio window.someWeirdProperty non è definito, quindi

" window.someWeirdProperty === null " restituisce falso mentre

" window.someWeirdProperty === undefined " restituisce true.

Inoltre, checkif if (! o) non equivale a controllare if (o == null) per o essendo false .

Answer 15

L'altra cosa divertente di null, rispetto a undefined, è che può essere incrementato.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

È utile per impostare valori numerici predefiniti per i contatori. Quante volte hai impostato una variabile su -1 nella sua dichiarazione?

Answer 16

In Javascript null non è un tipo object , è un tipo primitave .

Qual è la differenza? Non definito si riferisce a un puntatore che non è stato impostato. Null si riferisce al puntatore null, ad esempio qualcosa ha impostato manualmente una variabile per essere di tipo null

Answer 17

Guarda questo:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

Answer 18

Da " I principi di Javascript orientato agli oggetti " di Nicholas C. Zakas

  

Ma perché un oggetto quando il tipo è null? (In effetti, questo è stato riconosciuto come errore da TC39, il comitato che progetta e mantiene JavaScript. Si potrebbe pensare che null sia un puntatore oggetto vuoto, rendendo "oggetto" un valore di ritorno logico, ma è comunque confuso.)

Zakas, Nicholas C. (2014-02-07). I principi di JavaScript orientato agli oggetti (posizioni Kindle 226-227). Pressa senza amido. Edizione Kindle.

Detto questo:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Caso non definito:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

Answer 19

Il modo migliore per pensare a "null" è ricordare come viene usato il concetto simile nei database, dove indica che un campo contiene "nessun valore". "

• Sì, il valore dell'articolo è noto; è 'definito'. è stato inizializzato.
• Il valore dell'articolo è: " non esiste alcun valore. "

Questa è una tecnica molto utile per scrivere programmi che sono più facilmente debug. Una variabile "non definita" potrebbe essere il risultato di un bug ... (come faresti a saperlo?) ... ma se la variabile contiene il valore "null", sai che " qualcuno, da qualche parte in questo programma, impostalo su "null". " Pertanto, suggerisco che, quando è necessario eliminare il valore di una variabile, non " elimina " ... impostalo su "null". Il vecchio valore verrà reso orfano e presto verrà raccolto. il nuovo valore è "non esiste alcun valore (ora)." In entrambi i casi, lo stato della variabile è certo: "ovviamente, deliberatamente, è arrivato in questo modo."

Answer 20

1. Non definito significa che è stata dichiarata una variabile ma non è stato assegnato alcun valore mentre Null può essere assegnato a una variabile che rappresenta "nessun valore". (Null è un operatore di assegnazione)

2.Undefined è un tipo stesso mentre Null è un oggetto.

3.Javascript stesso può inizializzare qualsiasi variabile non assegnata a indefinita, ma non può mai impostare il valore di una variabile su null. Questo deve essere fatto programmaticamente.