Null vs. Undefined

gratis youtube-video om emnet

JavaScript (og i forlængelse TypeScript) har to nederste typer : null og undefined. De er beregnet til at betyde forskellige ting:

• noget er ikke initialiseret : undefined.

• noget er i øjeblikket ikke tilgængeligt:null.

faktum er, at du bliver nødt til at håndtere begge dele. Interessant i JavaScript med ==null og undefined er kun lig med hinanden:

// Both null and undefined are only `==` to themselves and each other:
console.log(null == null); // true (of course)
console.log(undefined == undefined); // true (of course)
console.log(null == undefined); // true
// You don't have to worry about falsy values making through this check
console.log(0 == undefined); // false
console.log('' == undefined); // false
console.log(false == undefined); // false

Anbefal == null for at kontrollere for begge undefined eller null. Du ønsker generelt ikke at skelne mellem de to.

function foo(arg: string | null | undefined) {
 if (arg != null) {
 // arg must be a string as `!=` rules out both null and undefined. 
 }
}

Du kan også gøre == undefined, men == null er mere konventionel/kortere.

en undtagelse, rodniveau undefined værdier, som vi diskuterer næste.

kontrol af rodniveau udefineret

husk, hvordan jeg sagde, at du skulle bruge == null? Selvfølgelig gør du det (fordi jeg lige sagde det ^). Brug det ikke til rodniveau ting. I streng tilstand, hvis du brugerfoo ogfoo er udefineret, får du enReferenceError undtagelse, og hele opkaldsstakken afvikles.

Du skal bruge streng tilstand … og faktisk vil TS-kompilatoren indsætte den for dig, hvis du bruger moduler … mere om dem senere i bogen, så du ikke behøver at være eksplicit om det 🙂

så for at kontrollere, om en variabel er defineret eller ikke på globalt plan, bruger du normalt typeof:

if (typeof someglobal !== 'undefined') {
 // someglobal is now safe to use
 console.log(someglobal);
}

begræns eksplicit brug af Undefined

fordi TypeScript giver dig mulighed for at dokumentere dine strukturer adskilt fra værdier i stedet for ting som:

function foo(){
 // if Something
 return {a:1,b:2};
 // else
 return {a:1,b:undefined};
}

Du skal bruge en type annotation:

function foo():{a:number,b?:number}{
 // if Something
 return {a:1,b:2};
 // else
 return {a:1};
}

node style tilbagekaldsfunktioner (f.eks. (err,somethingElse)=>{ /* something */ }) kaldes generelt med err Indstil til null hvis der ikke er en fejl. Du bruger generelt bare en truthy check for dette alligevel:

fs.readFile('someFile', 'utf8', (err,data) => {
 if (err) {
 // do something
 } else {
 // no error
 }
});

Når du opretter dine egne API ‘ er, er det okay at brugenull i dette tilfælde for konsistens. I al oprigtighed for dine egne API ‘ er skal du se på løfter, i så fald behøver du faktisk ikke gider med fraværende fejlværdier (du håndterer dem med .then vs. .catch).

brug ikke udefineret som et middel til at betegne gyldighed

for eksempel en forfærdelig funktion som denne:

function toInt(str: string) {
 return str ? parseInt(str) : undefined;
}

kan skrives meget bedre som dette:

function toInt(str: string): { valid: boolean, int?: number } {
 const int = parseInt(str);
 if (isNaN(int)) {
 return { valid: false };
 }
 else {
 return { valid: true, int };
 }
}

JSON og serialisering

JSON-standarden har understøttelse af kodning null men ikke undefined. Når JSON-koder et objekt med en attribut, der er null, vil attributten blive inkluderet med dens null-værdi, mens en attribut med en undefined værdi udelukkes helt.

JSON.stringify({willStay: null, willBeGone: undefined}); // {"willStay":null}

som følge heraf kan JSON-baserede databaser understøttenullværdier men ikkeundefined værdier. Da attributter indstillet til nuller kodet, kan du overføre hensigten om at rydde en attribut ved at indstille dens værdi til null før kodning og transmission af objektet til en fjernbutik.

Indstilling af attributværdier til undefined kan spare på lager-og transmissionsomkostninger, da attributnavnene ikke kodes. Dette kan dog komplicere semantikken for clearingværdier vs. fraværende værdier.

Endelige tanker

TypeScript team bruger ikkenull : retningslinjer for TypeScript-kodning, og det har ikke forårsaget nogen problemer. Douglas Crockford tænker nuller en dårlig ide, og vi skal alle bare brugeundefined.

NodeJS-stilkodebaser bruger dognull til Fejlargumenter som standard, da det betegnerSomething is currently unavailable. Jeg er personligt ligeglad med at skelne mellem de to, da de fleste projekter bruger biblioteker med forskellige meninger og bare udelukker begge med == null.