voordat we dieper gaan, behandelen we eerst de basis:
undefined wordt geretourneerd als een variabele alleen is gedeclareerd maar geen waarde is toegewezen.
bijvoorbeeld:
var ab
Dit logt undefined:
log(ab)
ongedefinieerde variabelen zijn variabelen zonder waarden., Laten we zeggen dat de omgeving als volgt wordt weergegeven:
environmentVariable = {}
JS engine zou de VariableDeclaration var ab interpreteren als:
environmentVariable = {
ab: undefined
}
dus als het wordt benaderd zal undefined worden teruggekeerd., Nu, wanneer de ab is toegewezen aan een waarde:
ab = 90
De undefined zal worden gewijzigd in de waarde 90:
environmentVariable = {
ab: 90
}
Wanneer we verklaarde ab was ingesteld in de omgevingsvariabele tabel undefined, wat betekent dat de waarde is op de weg, als we nu ab-waarde 90, de undefined veranderd 90.,ab207″>
undefined kan ook optreden als er een object is eigendom bestaat niet
let myDetails = {
age: 27
}log(myDetails.name)
// undefined
of een functie een ontbrekende parameter:
function getMyDetails(a) {
l(a)
}getMyDetails()
// undefined
undefined een primitieve datatype in JS:
Boolean
Undefined
Number
String
Symbolvar ab
typeof ab
// undefined
U kunt controleren of het type gebruik van typeof trefwoord:
if(typeof ab == 'undefined') {
// ...
}
undefined kan expliciet worden ingesteld:
var ab = undefined
l(ab)
// undefinedab = 90
l(ab)
// 90
null
null is een gegevenstype in JS dat verklaart dat geen enkele waarde of non-existent waarde., null kan worden gezien als een opzettelijke afwezigheid van een objectwaarde.
var ab = null
l(ab)
// null
gelijkenissen
laten we eens kijken naar hun gelijkenissen.
beide zijn falsy-waarden
null en undefined Lost altijd op tot een falsy-waarde., Ze zijn onder de falsy waarden in JS:
- null
- undefined
- false
- 0
- Lege string -> “”
- NaN
Als ze in de toestand van een if-else instructie, de else-instructie wordt altijd uitgevoerd worden:
if (null) {
l('yes')
} else {
l('no')
}
Het bovenstaande zal de log: “nee”.
if (undefined) {
l('yes')
} else {
l('no')
}
zal ook”no” loggen.,
beide zijn primitieve waarden
In JS hebben we complexe en primitieve gegevenstypen, null En undefined behoren tot de primitieve gegevenstypen:
- null
- Undefined
- symbool
- String
- Aantal
- Boolean
primitieve gegevenstypen worden opgelost door waarde-of-reference.
verschillen
null en undefined betekent geen-waarde, maar ze lossen op in diff. waarden:
l(typeof null)
// objectl(typeof undefined)
// undefined
u verwachtte dat typeof null “null”zou retourneren? Toch?, Dit is een bug in JS voor bijna twee decennia, maar het ding is dat het niet kan worden opgelost. Dit komt omdat duizenden websites afhankelijk zijn van dit buggy gedrag, de vaststelling van het zal ze breken.
null is een toegewezen waarde, het moet expliciet worden toegewezen door de programmeur., Indien niet toegewezen, wordt de variabele undefined:
var ab = null
var a // undefined
in tegenstelling tot undefined which can be explicitly assigned or unassigned:
var ab = undefined
var bc l(ab)
// undefinedl(bc)
// undefined
Test for null
we zagen dat undefined resolves to “Undefined” but null resolves to “object”.,
We kunnen heel gemakkelijk testen voor undefined:
var abif(typeof ab == "undefined") {
// ...
}
Voor de null kunnen we dit niet doen:
var ab = nullif(typeof ab == "null") {
// ...
}
typeof null geeft als resultaat “object” en we kunnen de verleiding te herschrijven het bovenstaande als volgt uit:
var ab = nullif(typeof ab == "object") {
// ...
}
Veel Complexe data types retourneren van objecten, het type kan worden gecontroleerd via typeof:
let obj = {}
let arr =
class D {}
const d = new D()l(typeof obj)
l(typeof arr)
l(typeof d)// object
// object
// object
Dus het zou mislukken omdat een Array of een Object kan worden van de waarde van de ab.,
nu hoe kunnen we correct testen op null, omdat null een falsy waarde is, zullen we de controle combineren met het type van controle.
var ab = nullif(!ab && typeof ab == "object") {
// ...
}
Abstract/Loose and Strict Equality on null and undefined
laten we eens kijken wat er gebeurt als strikte en loose equality worden uitgevoerd op beide types. Maar daarvoor-een snel overzicht van de losse gelijkheid specificatie:
7.2.14 Abstracte gelijkheid vergelijking
de vergelijking x = = y, waarbij x en y waarden zijn, produceert waar of onwaar., Een dergelijke vergelijking wordt als volgt uitgevoerd:
Kijk naar 2 en 3
- Als x null is en y niet gedefinieerd is, retourneer true.
- als x niet gedefinieerd is en y null is, retourneer true.
2 geeft aan dat als de LHS null is en de RHS niet gedefinieerd is, true wordt geretourneerd., Dit is de reden waarom als we dit doen:
log(null == undefined)
het logt true
log(null == undefined)
// true
en zegt als de LHS is undefined en de RHS is null, het moet ook true
log(undefined == null)
// true
Dit betekent dat null en undefined zijn losjes gelijk, ja, het is begrijpelijk omdat ze allemaal een afwezigheid van geen waarde vertegenwoordigen, zoals in een sleutel-waardepaar, de sleutel is aanwezig, maar de waarde is niet aanwezig/ afwezig.
laten we eens kijken naar strikte gelijkheid:
7.2.,15 strikte Gelijkheidsvergelijking
de vergelijking x = = = y, waarbij x en y waarden zijn, produceert waar of onwaar. Een dergelijke vergelijking wordt als volgt uitgevoerd:
kijkend naar het bovenstaande, geeft strict equality false terug als de RHS en LHS types verschillend zijn
nu, in het geval van
null === undefined
Dit zal false zijn omdat de types object en undefined, zie ze zijn anders, dus het zal vals terugkeren.
log(null === undefined)
So,
null !== undefined
zal waar zijn. Waarom?, Het is omdat null => object niet hetzelfde type is als undefined => undefined.
null != undefined
Dit is de vraag of de LHS niet gelijk is aan de RHS. Dit is nee, ze zijn gelijk omdat Abstracte gelijkheid zegt Waar terug te geven(dat ze gelijk zijn) als de LHS is ofwel null of undefined en de RHS is ofwel null of undefined.,
het Passeren van nul en niet gedefinieerd als een argument van de functie
We moeten voorzichtig zijn bij het verklaren van de standaard argument waarde zoals dit:
function defFunc(name = "nnamdi") {
return name
}
met Deze functie net terug van een naam doorgegeven, zie het argument name heeft een standaard waarde nnamdi, het argument zal nemen nnamdi als waarde wanneer de functie wordt aangeroepen zonder parameters:
log(defFunc())
// nnamdi
Het kan worden gezegd als deze, als het argument naam is niet gedefinieerd wordt ervan uitgegaan dat de nnamdi waarde., Dus als we een ongedefinieerde waarde doorgeven aan defFunc naam zal nnamdi:
var ab
log(defFunc(ab))
// nnamdi
nu, wat gebeurt er als we null doorgeven aan de functie? Denk je dat het Nnamdi zal loggen omdat null de afwezigheid van een waarde betekent of zal het null loggen omdat null een waarde is? Eens kijken:
log(defFunc(null))
// null
Wow!! het logde null. Het zou moeten zijn omdat null een object is. Ik zou zeggen een leeg object, maar nog steeds de afwezigheid van een waarde(s).,
Als u probeert om te controleren voor null-argument, denk don;t dit doen:
function defFunc(name = "nnamdi") {
if(typeof name == "null")
return "nnamdi"
return name
}
dit doen:
function defFunc(name = "nnamdi") {
if(!name && typeof name == "object")
return "nnamdi"
return name
}
of u kunt delegeren null check aan een functie:
function isNull(val) {
return !val && typeof val == "object"
}
u kunt gebruik maken van de isNull functie overal in uw programma:
function defFunc(name = "nnamdi") {
if(isNull(name))
return "nnamdi"
return name
}
Conclusie
ik denk dat we duidelijk zijn over de verschillen en overeenkomsten tussen null en undefined. Dus als je de volgende keer die fout ziet, weet je wat je moet doen.