Null vs.Undefined

Ingyenes youtube videó a témában

a JavaScriptnek (és a TypeScript kiterjesztéssel) két alsó típusa van : null és undefined. Ezek különböző dolgokat jelentenek:

• valami nincs inicializálva: undefined.

• valami jelenleg nem érhető el: null.

tény, hogy mindkettővel foglalkoznia kell. Érdekes módon a JavaScriptben a ==null és undefined csak egyenlőek egymással:

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

javasoljuk == null mindkét undefined vagy nullellenőrzéséhez. Általában nem akarsz különbséget tenni a kettő között.

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

azt is megteheti == undefined, de == null hagyományosabb/rövidebb.

egy kivétel, gyökér szint undefined értékek, amelyeket a következőkben tárgyalunk.

A gyökérszint ellenőrzése nem definiált

emlékszel, hogy mondtam, hogy használnod kell == null? Persze, hogy nem (mert én csak azt mondta, hogy^). Ne használja gyökér szintű dolgokra. Szigorú módban, ha a foo és a foo nincs definiálva, akkor a ReferenceError kivételt kap, és az egész hívásköteg feloldódik.

szigorú módot kell használnia … valójában a TS fordító beilleszti az Ön számára, ha modulokat használ … bővebben a könyv későbbi részeiről, így nem kell explicitnek lennie róla 🙂

tehát annak ellenőrzéséhez, hogy egy változó globális szinten van-e meghatározva vagy sem, általában typeof:

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

korlátozza a definiálatlan

explicit használatát, mert a TypeScript lehetőséget ad arra, hogy a struktúrákat az értékektől elkülönítve dokumentálja az olyan dolgok helyett, mint:

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

használjon típusjegyzetet:

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

csomópont stílusú visszahívások

csomópont stílusú visszahívási funkciók (pl. (err,somethingElse)=>{ /* something */ }) általában a err beállítása null ha nincs hiba. Ehhez általában csak egy valódi ellenőrzést használ:

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

saját API-k létrehozásakor nem baj, ha a null ebben az esetben a következetesség érdekében. A saját API-k teljes őszinteségében meg kell néznie az ígéreteket, ebben az esetben valójában nem kell bajlódnia a hiányzó hibaértékekkel (ezeket .then vs. .catch).

ne használj meghatározatlant az érvényesség jelölésére

például egy ilyen szörnyű függvény:

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

sokkal jobban írható így:

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

JSON and serialization

a JSON szabvány támogatja a null kódolást, de nem undefined. Ha JSON-kódol egy objektumot egy attribútummal, amely null, akkor az attribútum a null értékével együtt kerül beillesztésre, míg a undefined értékkel rendelkező attribútum teljesen kizárt.

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

ennek eredményeként a JSON-alapú adatbázisok támogathatják a null értékeket, de nem undefined értékeket. Mivel a null értékre beállított attribútumok kódolva vannak, az attribútum törlési szándékát továbbíthatja úgy, hogy az értékét null értékre állítja, mielőtt kódolja és továbbítja az objektumot egy távoli tárolóba.

az attribútumértékek undefined értékre állítása megtakaríthatja a tárolási és átviteli költségeket, mivel az attribútumnevek nem lesznek kódolva. Ez azonban bonyolíthatja az elszámolási értékek szemantikáját a hiányzó értékekkel szemben.

végső gondolatok

a TypeScript csapat nem használja a null: TypeScript kódolási irányelveket, és nem okozott problémát. Douglas Crockford szerint anull rossz ötlet, és mindannyiunknak csak aundefined – t kellene használnunk.

a nodejs stíluskód alapja azonban anull Hibaérveket használja szabványként, mivel azt jelöliSomething is currently unavailable. Személy szerint nem érdekel különbséget tenni a kettő között, mivel a legtöbb projekt eltérő véleményű könyvtárakat használ, és mindkettőt kizárja a == nullsegítségével.