null vs.nedefinit

Video youtube gratuit pe această temă

JavaScript (și prin extensie TypeScript) are două tipuri de fund : null și undefined. Ele sunt destinate să însemne lucruri diferite:

• ceva nu a fost inițializat:undefined.

• ceva nu este disponibil momentan:null.

faptul este că va trebui să vă ocupați de ambele. Interesant în JavaScript cu ==null și undefined sunt doar egale între ele:

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

recomanda == null pentru a verifica ambele undefined sau null. În general, nu doriți să faceți o distincție între cele două.

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

ai putea face, de asemenea,== undefined, dar== null este mai convențional/mai scurt.

o excepție, nivelul rădăcinăundefined valorile pe care le vom discuta în continuare.

Verificarea nivelului de root nedefinit

amintiți-vă cum am spus că ar trebui să utilizați== null? Bineînțeles că da (pentru că tocmai am spus-o^). Nu-l utilizați pentru lucruri de nivel rădăcină. În modul strict dacă utilizațifoo șifoo este nedefinit obțineți oReferenceError excepție și întreaga stivă de apeluri se derulează.

ar trebui să utilizați modul strict … și, de fapt, compilatorul TS îl va insera pentru dvs. dacă utilizați module … mai multe despre cele de mai târziu în carte, astfel încât să nu trebuie să fie explicit despre asta 🙂

deci, pentru a verifica dacă o variabilă este definită sau nu la nivel global utilizați în mod normal typeof:

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

limita utilizarea explicită a nedefinit

deoarece typescript vă oferă posibilitatea de a documenta structurile separat de valori în loc de chestii de genul:

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

ar trebui să utilizați o adnotare tip:

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

Callback Stil nod

funcții de apel invers Stil nod (de exemplu, (err,somethingElse)=>{ /* something */ }) Sunt în general numite cu err setat la null dacă nu există o eroare. În general, utilizați un cec adevărat pentru acest lucru oricum:

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

atunci când creați propriile API-uri, este în regulă să utilizați null în acest caz pentru consecvență. Cu toată sinceritatea pentru propriile API-uri, ar trebui să vă uitați la promisiuni, în acest caz nu trebuie să vă deranjați cu valori de eroare absente (le gestionați cu .then vs. .catch).

nu folosiți nedefinit ca mijloc de denotare a valabilității

de exemplu, o funcție îngrozitoare ca aceasta:

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

poate fi mult mai bine scrisă astfel:

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

JSON și serializare

standardul JSON are suport pentru codificarenull dar nuundefined. Când JSON-codifică un obiect cu un atribut care este null, atributul va fi inclus cu valoarea sa nulă, în timp ce un atribut cu undefined valoarea va fi exclusă în întregime.

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

ca urmare, bazele de date bazate pe JSON pot suporta null valori, dar nu undefined valori. Deoarece atributele setate la null sunt codificate, puteți transmite intenția de a șterge un atribut setând valoarea acestuia la null înainte de a codifica și transmite obiectul într-un magazin la distanță.

setarea valorilor atributelor la nedefinit poate economisi costurile de stocare și transmisie, deoarece numele atributelor nu vor fi codificate. Cu toate acestea, acest lucru poate complica semantica valorilor de compensare vs.valori absente.

Gânduri finale

echipa TypeScript nu foloseștenull : linii directoare de codificare TypeScript și nu a cauzat probleme. Douglas Crockford crede că null este o idee proastă și ar trebui să folosim cu toții undefined.

cu toate acestea, bazele de cod de stil NodeJS utilizează null pentru argumente de eroare ca standard, deoarece denotă Something is currently unavailable. Eu personal nu-mi pasă să se facă distincția între cele două ca cele mai multe proiecte folosesc biblioteci cu opinii diferite și doar exclude ambele cu == null.