november 19, 2021

Null vs.Undefined

Gratis youtube-video over het onderwerp

JavaScript (en bij uitbreiding TypeScript) heeft twee onderste types : null en undefined. Ze zijn bedoeld om verschillende dingen te betekenen:

  • iets is niet geïnitialiseerd : undefined.

  • iets is momenteel niet beschikbaar: null.

feit is dat u beide moet behandelen. Interessant is dat in JavaScript met ==null en undefined zijn alleen gelijk zijn aan elkaar:

// 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

Aanbevelen == null om te controleren voor zowel undefined of null. Over het algemeen wil je geen onderscheid maken tussen de twee.

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

u kunt ook== undefineddoen, maar== nullis conventioneler/korter.

Eén uitzondering, rootniveau undefined waarden die we hierna bespreken.

controle op rootniveau ongedefinieerd

Weet je nog hoe ik zei dat je== nullzou moeten gebruiken? Natuurlijk doe je dat (want ik zei het net ^). Gebruik het niet voor root-niveau dingen. In de strikte modus als u foo gebruikt en foo is ongedefinieerd, krijgt u een uitzondering ReferenceError en de hele call stack afwikkelt.

gebruik de strikte modus … en in feite zal de TS compiler het voor je invoegen als je modules gebruikt … meer over die later in het boek, zodat je er niet expliciet over hoeft te zijn 🙂

om te controleren of een variabele is gedefinieerd of niet op een globaal niveau gebruikt u gewoonlijk typeof:

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

Limit expliciet Gebruik van Undefined

omdat TypeScript u de mogelijkheid geeft om uw structuren apart te documenteren van waarden in plaats van dingen als:

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

u moet een type annotatie gebruiken:

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

node style callbacks

Node style callbacks (bijv. (err,somethingElse)=>{ /* something */ }) worden over het algemeen aangeroepen meterringesteld opnullals er is geen fout. Over het algemeen gebruik je hiervoor gewoon een truthy check:

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

bij het maken van je eigen API ‘ s is het goed om null te gebruiken in dit geval voor consistentie. In alle oprechtheid voor uw eigen API ‘ s moet u kijken naar Beloften, in dat geval hoeft u zich eigenlijk geen zorgen te maken over ontbrekende foutwaarden (u behandelt ze met .then vs. .catch).

gebruik geen undefined als een middel om validiteit aan te geven

bijvoorbeeld een vreselijke functie als deze:

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

kan veel beter zo geschreven worden:

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

JSON en serialisatie

de JSON-standaard heeft ondersteuning voor codering null maar niet undefined. Wanneer JSON-encoding een object met een attribuut dat is null, zal het attribuut worden opgenomen met zijn null waarde, terwijl een attribuut met een undefined waarde volledig zal worden uitgesloten.

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

als gevolg hiervan kunnen op JSON gebaseerde databases null waarden ondersteunen, maar niet undefined waarden. Aangezien attributen ingesteld op null gecodeerd zijn, kunt u de intentie om een attribuut te wissen doorgeven door de waarde ervan in te stellen op null voordat u het object codeert en naar een extern archief verzendt.

het instellen van attribuutwaarden op ongedefinieerd kan besparen op opslag-en transmissiekosten, omdat de attribuutnamen niet gecodeerd zullen worden. Dit kan echter de semantiek van clearing waarden Versus afwezige waarden compliceren.

Final thoughts

TypeScript team gebruikt null : TypeScript codering richtlijnen en het heeft geen problemen veroorzaakt. Douglas Crockford vindt null een slecht idee en we moeten allemaal gewoon undefinedgebruiken.

echter, NodeJS-stijlcodebasissen gebruiken null voor Foutargumenten als standaard aangezien het Something is currently unavailableaanduidt. Persoonlijk maak ik geen onderscheid tussen de twee omdat de meeste projecten bibliotheken met verschillende meningen gebruiken en beide uitsluiten met == null.

Auteur:
Gearchiveerd onder: Articles

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.