Null vs. Undefined

ilmainen youtube-video aiheesta

JavaScript (and by extension TypeScript) on kahta alatyyppiä : null ja undefined. Niiden on tarkoitus tarkoittaa eri asioita:

• jotain ei ole alustettu : undefined.

• jotain ei ole tällä hetkellä saatavilla: null.

fakta on, että sinun on käsiteltävä molemmat. Mielenkiintoista Javascriptissä on, että ==null ja undefined ovat vain yhtä keskenään:

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

suosittele == null tarkistaa molemmat undefined tai null. Et yleensä halua tehdä eroa näiden kahden välillä.

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

voisi tehdä myös == undefined, mutta == null on tavanomaisempi / lyhyempi.

yksi poikkeus, juuritaso undefined arvot, joista keskustellaan seuraavaksi.

Tarkista juuritason määrittelemätön

Muistatko, miten sanoin, että == null? Tietenkin teet (koska juuri sanoin sen^). Älä käytä sitä juuritason juttuihin. Tiukassa tilassa jos käytät foo ja foo on määrittelemätön, saat ReferenceError poikkeuksen ja koko kutsupino purkautuu.

kannattaa käyttää tiukkaa moodia … ja itse asiassa TS kääntäjä lisää sen sinulle, jos käytät moduuleja … lisää niistä myöhemmin kirjassa, joten sinun ei tarvitse olla eksplisiittinen 🙂

joten tarkistaaksesi, onko muuttuja määritelty tai ei ole globaalilla tasolla normaalisti käytät typeof:

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

Rajoita määrittelemättömän

eksplisiittisen käytön rajoittamista, koska konekirjoitus antaa mahdollisuuden dokumentoida rakenteensa erillään arvoista esimerkiksi:

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

kannattaa käyttää tyyppimerkintää:

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

Node style callbacks

Node style callbacks ode style callbackfunktioita (esim. (err,somethingElse)=>{ /* something */ }) kutsutaan yleensä errset to null jos ei ole virhettä. Yleensä tähän käytetään vain totuudenmukaista tarkistusta joka tapauksessa:

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

kun luot omia sovellusliittymiä, on OK käyttää null tässä tapauksessa johdonmukaisuuden vuoksi. Täysin vilpittömästi omia sovellusliittymiä varten kannattaa katsoa lupauksia, silloin ei oikeastaan tarvitse vaivautua puuttuvilla virhearvoilla (niitä käsitellään .then vs. .catch).

Älä käytä määrittelemätöntä merkinantovälineenä

esimerkiksi tällaista hirveää funktiota:

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

voidaan kirjoittaa paljon paremmin näin:

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

JSON ja sarjatuotanto

JSON-standardilla on tuki koodaukselle null mutta ei undefined. Kun JSON-koodaa objektin, jonka attribuutti on null, attribuutti sisällytetään sen nollaarvoon, kun taas attribuutti, jonka undefined – arvo jätetään kokonaan pois.

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

tämän seurauksena JSON-pohjaiset tietokannat voivat tukea null arvoja, mutta eivät undefined arvoja. Koska attribuutit, jotka on asetettu null, on koodattu, voit lähettää attribuutin tyhjennysaikeen asettamalla sen arvoksi null ennen kuin koodaat ja lähetät kohteen etäkauppaan.

attribuuttiarvojen asettaminen määrittelemättömille voi säästää varastointi-ja siirtokustannuksissa, koska attribuuttien nimiä ei koodata. Tämä voi kuitenkin vaikeuttaa selvitysarvojen vs. poissaoloarvojen semantiikkaa.

Final thoughts

TypeScript team ei käytä null : TypeScript coding guidelines ja se ei ole aiheuttanut ongelmia. Douglas Crockfordin mielestä null on huono idea ja meidän kaikkien pitäisi vain käyttää undefined.

NodeJS style code bases käyttää kuitenkin null Virheargumenteille standardina, koska se tarkoittaa Something is currently unavailable. Itse en välitä erottaa näitä kahta toisistaan, sillä useimmat projektit käyttävät kirjastoja, joilla on eriäviä mielipiteitä ja vain sulkevat pois molemmat == null.