innan du dyker djupare, låt oss först täcka grunderna:
undefined returneras om en variabel endast deklarerades men inte tilldelades ett värde.
till exempel:
var ab
detta kommer att loggaundefined:
log(ab)
odefinierade variabler är variabler som inte har några värden., Låt oss säga att miljön är representerad så här:
environmentVariable = {}
JS-motorn skulle tolka VariableDeclaration varab som:
environmentVariable = {
ab: undefined
}
så när den nås kommerundefined att returneras., Nu när ab tilldelas ett värde:
ab = 90
undefined kommer att ändras till värdet 90:
environmentVariable = {
ab: 90
}
När vi förklarade ab det sattes i miljövariabeltabellen som undefined, vilket betyder att värdet är på väg, nu när vi AB till värde 90 ändrades undefined till 90.,ab207″>
undefined kan också uppstå om ett objekts egendom inte existerar
let myDetails = {
age: 27
}log(myDetails.name)
// undefined
eller om en funktion har en saknad parameter:
function getMyDetails(a) {
l(a)
}getMyDetails()
// undefined
undefined är en primitiv datatyp i JS:
Boolean
Undefined
Number
String
Symbolvar ab
typeof ab
// undefined
Du kan kontrollera typen med typeof nyckelord:
if(typeof ab == 'undefined') {
// ...
}
undefined kan ställas in explicit:
var ab = undefined
l(ab)
// undefinedab = 90
l(ab)
// 90
null
null är en datatyp i js som deklarerar inget värde eller obefintligt värde., null kan ses som en avsiktlig frånvaro av något objektvärde.
var ab = null
l(ab)
// null
likheter
låt oss titta på deras likheter.
båda är falsiga värden
nullochundefined löser alltid till ett falsigt värde., De är bland falsy värden i JS:
- null
- undefined
- false
- 0
- Tom string -> ””
- NaN
om de är i skick av en if-else uttalande, else statement kommer alltid att utföras:
if (null) {
l('yes')
} else {
l('no')
}
ovanstående loggar ”nej”.
if (undefined) {
l('yes')
} else {
l('no')
}
loggar också ”nej”.,
båda är primitiva värden
i JS har vi komplexa och primitiva datatyper, null och undefined är bland de primitiva datatyperna:
- null
- undefined
- Symbol
- String
- nummer
- Boolean
primitiva datatyper löses efter värde av referens.
skillnader
null och undefined betyder inget värde men de löser att diff. värden:
l(typeof null)
// objectl(typeof undefined)
// undefined
du förväntade dig atttypeof null skulle returnera ”null”? Rätt?, Detta är en bugg i JS i nästan två decennier, men saken är att det inte kan lösas. Detta beror på att tusentals webbplatser beror på detta buggy beteende, fastställande av det kommer att göra dem bryta.
null är ett tilldelat värde, det måste uttryckligen tilldelas av programmeraren., Om den inte är tilldelad blir variabeln undefined:
var ab = null
var a // undefined
till skillnad från odefinierad som uttryckligen kan tilldelas eller ej tilldelas:
var ab = undefined
var bc l(ab)
// undefinedl(bc)
// undefined
Test för null
vi såg att undefined löser sig till ”undefined” men null löser till ”objekt”.,
vi kan enkelt testa för undefined:
var abif(typeof ab == "undefined") {
// ...
}
för null kan vi inte göra detta:
var ab = nullif(typeof ab == "null") {
// ...
}
typeof null returnerar ”objekt” och vi kan frestas att skriva om ovanstående så här:
var ab = nullif(typeof ab == "object") {
// ...
}
många komplexa datatyper returnerar objekt, typen kan kontrolleras via typeof:
let obj = {}
let arr =
class D {}
const d = new D()l(typeof obj)
l(typeof arr)
l(typeof d)// object
// object
// object
så det skulle misslyckas eftersom en matris eller ett objekt kan vara värdet av AB.,
nu hur testar vi korrekt för null, eftersom null är ett falskt värde kommer vi att kombinera kontrollen med typeof check.
var ab = nullif(!ab && typeof ab == "object") {
// ...
}
Abstrakt/lös och strikt jämlikhet på null och undefined
låt oss se vad som händer när strikt och lös jämlikhet utförs på båda typerna. Men innan dess-en snabb genomgång av den lösa jämlikhetsspecifikationen:
7.2.14 Abstrakt Jämlikhetsjämförelse
jämförelsen x == y, där X och y är värden, ger sant eller falskt., En sådan jämförelse utförs enligt följande:
titta på 2 och 3
- Om x är null och y är odefinierat, returnera sant.
- Om x är odefinierat och y är null, returnera sant.
2 säger att om LHS är null och RHS är odefinierat returneras true., Det är därför som vi gör det här:
log(null == undefined)
det loggar sant
log(null == undefined)
// true
och säger att om LHS är odefinierat och RHS är null, ska det också returnera sant
log(undefined == null)
// true
det betyder att null och odefinierat är löst lika, ja, det är förståeligt eftersom de alla representerar en frånvaro av inget värde, som i ett nyckelvärdespar, är nyckeln närvarande men värdet är inte närvarande/ är frånvarande.
låt oss se om strikt jämlikhet:
7.2.,15 strikt Jämlikhetsjämförelse
jämförelsen x === y, där X och y är värden, ger sant eller falskt. En sådan jämförelse utförs enligt följande:
om man tittar på ovanstående returnerar strikt jämlikhet falskt om RHS-och LHS-typerna är olika
Nu, när det gäller
null === undefined
detta kommer att vara falskt eftersom typerna kommer att vara object och undefined, se till att de är olika så att det kommer att returnera falskt.
log(null === undefined)
Så,
null !== undefined
kommer att vara sant. Varför?, Det beror på att null => object inte är samma typ som undefined => undefined.
null != undefined
det här frågar om LHS inte är lika med RHS. Detta är nej, de är lika eftersom Abstrakt jämlikhet säger att återvända sant (att de är lika) om LHS är antingen null eller undefined och RHS är antingen null eller undefined.,
passerar null och odefinierad som en funktion argument
Vi bör vara försiktiga när deklarera standardargument värde så här:
function defFunc(name = "nnamdi") {
return name
}
denna funktion returnerar bara ett namn skickas till det, se argumentetname har ett standardvärdennamdi, argumentet kommer att tannamdi som värde när funktionen anropas utan parametrar:
log(defFunc())
// nnamdi
det kan sägas så här, när argumentnamnet är odefinierat förutsätter det värdetnnamdi., Så om vi skickar ett odefinierat värde till defFunc kommer namnet att vara nnamdi:
var ab
log(defFunc(ab))
// nnamdi
vad händer om vi null till funktionen? Tror du att det kommer att logga nnamdi eftersom null innebär frånvaron av ett värde eller kommer det att logga null eftersom null är ett värde? Låt oss se:
log(defFunc(null))
// null
Wow!! det loggade null. Det borde bero på att null är ett objekt. Jag skulle säga ett tomt objekt, men fortfarande representerar frånvaron av ett värde(er).,gör så här:
function defFunc(name = "nnamdi") {
if(typeof name == "null")
return "nnamdi"
return name
}
gör så här:
function defFunc(name = "nnamdi") {
if(!name && typeof name == "object")
return "nnamdi"
return name
}
eller så kan du delegera null-kontrollen till en funktion:
function isNull(val) {
return !val && typeof val == "object"
}
Du kan använda
function isNull(val) {
return !val && typeof val == "object"
}
Du kan användaisNull fungera var som helst i ditt program:
function defFunc(name = "nnamdi") {
if(isNull(name))
return "nnamdi"
return name
}
slutsats
jag tror att vi är tydliga på skillnaderna och likheterna mellannullochundefined. Så när nästa du ser det felet, vet du vad du ska göra.