Perché null è un oggetto e qual è la differenza tra null e undefined?
-
03-07-2019 - |
Domanda
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
?
Soluzione
(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.
Altri suggerimenti
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
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
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
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.
var x = null;
x è definito come null
y non è definito; // perché non l'ho definito
if (!x)
null viene valutato come falso
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
}
-
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
}
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
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.
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 .
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 enull
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.
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
).
null
è un oggetto. Il suo tipo è nullo. undefined
non è un oggetto; il suo tipo è indefinito.
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
.
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?
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
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
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.
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."
- 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.