Null vs. Nedefinováno

Free youtube video na toto téma

JavaScript (a potažmo Strojopis) má dvě spodní typů : nullundefined. Mají znamenat různé věci:

• něco nebylo inicializováno: undefined.

• něco není momentálně k dispozici: null.

faktem je, že se budete muset vypořádat s oběma. Zajímavé je v Javascriptu ==nullundefined jsou pouze navzájem rovné:

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

Doporučujeme == null zkontrolovat undefined nebo null. Obecně nechcete rozlišovat mezi těmito dvěma.

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

můžete také udělat == undefined, ale na == null je více konvenční/kratší.

jedna výjimka, kořenová úroveň undefined hodnoty, o kterých budeme diskutovat dále.

kontrola kořenové úrovně nedefinované

nezapomeňte, jak jsem řekl, že byste měli použít == null? Samozřejmě, že ano (protože jsem to právě řekl^). Nepoužívejte jej pro věci na úrovni kořenů. V přísném režimu, pokud používáte foofoo je definován dostanete ReferenceError výjimkou a celý zásobník volání odvíjí.

měli byste použít přísný režim … a ve skutečnosti jej kompilátor TS vloží, pokud používáte moduly … více na ty později v knize, takže nemusíte být explicitní o to 🙂

Takže chcete zkontrolovat, zda je proměnná definována, nebo ne na globální úrovni, které běžně používáte typeof:

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

Limit explicitní použití nedefinováno

Strojopis, Protože vám dává příležitost k dokumentu své struktury odděleně od hodnot místo toho, věci, jako:

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

byste měli použít typ anotace:

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

Uzel styl zpětná volání

Uzlu styl funkce zpětného volání (např. (err,somethingElse)=>{ /* something */ }) se obecně nazývají se errnull pokud tam není chyba. Obvykle stačí použít pravdivý podívejte se na to tak jako tak:

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

Při vytváření své vlastní Api, je to v pořádku používat null v tomto případě pro konzistenci. Ve vší upřímnosti pro své vlastní Api, měli byste se podívat na sliby, v tom případě skutečně nemusíte obtěžovat s chybí chybové hodnoty (ty s nimi zacházet s .then vs. .catch).

nepoužívejte definován jako prostředek označující platnost

například strašně funkce, jako je tento:

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

může být mnohem lepší napsáno takto:

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

JSON a serializace

JSON standard má podporu pro kódování nullundefined. Když JSON-encoding objekt, atribut, který je null, atribut bude součástí jeho hodnotu null, vzhledem k tomu, že atribut s undefined hodnota bude zcela vyloučen.

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

Jako výsledek, JSON-based databáze může podporovat null hodnoty, ale není undefined hodnoty. Protože atributy nastaven na null jsou kódovány, můžete přenášet záměr jasný atribut, podle nastavení jeho hodnotu na null před kódování a přenos objektu do vzdáleného úložiště.

nastavení hodnot atributů na nedefinované může ušetřit náklady na ukládání a přenos, protože názvy atributů nebudou kódovány. To však může komplikovat sémantiku zúčtovacích hodnot oproti chybějícím hodnotám.

závěr

Strojopis tým nepoužívá null : Strojopis kódování pokyny, a to nezpůsobilo žádné problémy. Douglas Crockford si myslí, že null je špatný nápad a všichni bychom měli používat undefined.

nicméně NodeJS style code bases používá null pro chybové argumenty jako standard, protože označuje Something is currently unavailable. Osobně se nestarám rozlišovat mezi těmito dvěma, protože většina projektů používá knihovny s odlišnými názory a jen vylučuje oba s == null.