Cele mai bune practici TypeScript — Iterație, promisiuni și evaluare

TypeScript este o extensie ușor de învățat a JavaScript. Este ușor să scrii programe care rulează și fac ceva. Cu toate acestea, este greu să țineți cont de toate cazurile de utilizare și să scrieți cod TypeScript robust.

În acest articol, vom analiza cele mai bune practici de urmat atunci când scrieți cod cu TypeScript, inclusiv înlocuirea buclelor for-in cu alternative mai bune.

Codul de promisiune ar trebui să fie, de asemenea, util.

De asemenea, metodele eval nu ar trebui folosite.

Fără iterație peste o matrice cu o buclă for-in

Bucla for-in nu este chiar atât de utilă acum că există bucle for-of și metode pentru a obține cheile obiectelor.

De asemenea, repetă peste prototipurile obiectului nostru, pe care probabil nu le dorim.

Ordinea iterației, de asemenea, nu este garantată.

Prin urmare, nu ar trebui să-l folosim în codul nostru.

In loc sa scriu:

for (const x in [1, 2, 3]) {
  console.log(x);
}

Noi scriem:

for (const x of [1, 2, 3]) {
  console.log(x);
}

Bucla for-in trece peste indici, în timp ce bucla for-of trece peste intrări.

Nu folosiți metode asemănătoare eval

În JavaScript și prin extensie, TypeScript, ambele au metode care preiau șiruri și le rulează ca cod.

Există metoda eval care rulează cod dintr-un șir.

Constructorul Function returnează și o funcție dintr-un șir.

De asemenea, funcțiile setTimeout și setInterval pot rula ambele cod dintr-un șir.

Acest lucru împiedică efectuarea oricărei optimizări, deoarece codul este într-un șir.

De asemenea, creează o mare defecțiune de securitate, deoarece oricine poate introduce un șir cu cod și îl poate rula potențial.

Prin urmare, nu ar trebui să rulăm nicio funcție care ne permite să rulăm cod din șir.

Dacă folosim setTimeout sau setInterval , ar trebui să transmitem un callback în loc de un șir.

De exemplu, în loc să scrieți:

setTimeout('alert(`foo`);', 100);

or:

const add = new Function('a', 'b', 'return a + b');

Noi scriem:

setTimeout(() => {
  alert(`foo`);
}, 100);

or:

setInterval(() => {
  alert(`foo`);
}, 10000);

și nu utilizați celelalte funcții.

Fără declarații de tip explicite pentru variabile sau parametri Inițializați la un număr, șir sau boolean

Nu avem nevoie de tipuri pentru nimic căruia i s-a atribuit în mod explicit un număr, șir sau boolean.

Acest lucru se datorează faptului că din cod este evident ce sunt acestea.

Prin urmare, în loc să scrieți:

const a: number = 10;

Noi scriem:

const a = 10;

Acest lucru se aplică oricăror alte valori primitive, cum ar fi șir sau boolean.

Dacă tipul de returnare este evident, atunci putem sări peste adnotarea tipului.

Deci, în loc să scriu:

const a: number = Number('1');

Noi scriem:

const a = Number('1');

Acest lucru este valabil și pentru regexe. Dacă avem un literal regex, atunci nu avem nevoie de adnotare.

In loc sa scrii:

const a: RegExp = /foo/;

Noi scriem:

const a = /foo/;

Utilizați new și constructor în moduri valide

Ar trebui să folosim new și constructor în moduri valide.

Prin urmare, nu ar trebui să le folosim pentru a crea noi instanțe de clasă sau, respectiv, ca funcții de constructor.

De exemplu, în loc să scrieți:

class C {
  new(): C;
}

Noi scriem:

class C {
  constructor(){
    //...
  }
}
const c = new C();

Constructorii ar trebui să fie doar în clase.

De asemenea, putem specifica new ca semnătură în interfețe:

interface I {
  new (): C;
}

Nu folosiți promisiuni în locuri care nu sunt concepute pentru a le gestiona

Nu ar trebui să folosim promisiuni în locuri care nu sunt concepute pentru a le face față.

De exemplu, nu ar trebui să le punem în instrucțiuni sau bucle if.

Deci, în loc să scriu:

const promise = Promise.resolve('foo');

if (promise) {
  // Do something
}

or:

const promise = Promise.resolve('foo');

while (promise) {
  // Do something
}

or:

[1, 2, 3].forEach(async value => {
  await foo(value);
});

or:

new Promise(async (resolve, reject) => {
  await doSomething();
  resolve();
});

Ar trebui să scriem:

const promise = Promise.resolve('foo');

if (await promise) {
  // Do something
}

or:

const promise = Promise.resolve('foo');
while (await promise) {
  // Do something
}

or:

for (const value of [1, 2, 3]) {
  await foo(value);
}

Trebuie să punem await în locurile potrivite, astfel încât să obținem valoarea rezolvată în mod corespunzător.

De asemenea, următoarele nu sunt valabile:

new Promise(async (resolve, reject) => {
  await doSomething();
  resolve();
});

pentru că este redundant să ai o promisiune în cadrul unei promisiuni.

Putem muta await doSomething() în afara promisiunii noastre.

Concluzie

Promisiunile ar trebui folosite într-un mod util sau nu ar trebui să fie folosite deloc.

funcțiile de tip eval nu ar trebui folosite pentru că sunt periculoase.

buclele for-in ar trebui înlocuite cu alternative mai bune.