JavaScript è un linguaggio molto tollerante. È facile scrivere codice che viene eseguito ma contiene errori.

In questo articolo, esaminiamo alcuni errori che le persone fanno con condizionali e blocchi di codice.

Condizioni duplicate nelle catene if-else-if

Dobbiamo fare attenzione a non avere 2 o più else ifblocchi con la stessa condizione. Questo porta a confusione ed è quasi sempre un errore. Valuteranno tutti lo stesso valore di verità e quelli successivi non verranno mai eseguiti.

Ad esempio, se abbiamo:

let x;
const a = false;
const b = true;
if (a) {
  x = 0;
} else if (b) {
  x = 1;
} else if (b) {
  x = 2;
}

Pertanto, dovremmo sempre avere condizioni diverse per ogni else ifblocco. Ad esempio, dovremmo scrivere:

let x;
const a = false;
const b = false;
const c = true;
if (a) {
  x = 0;
} else if (b) {
  x = 1;
} else if (c) {
  x = 2;
}

let x;
const a = false;
const b = true;
if (a) {
  x = 0;
} else if (b) {
  x = 1;
} else if (a || b) {
  x = 2;
}

Chiavi duplicate in valori letterali oggetto

Le chiavi duplicate non dovrebbero mai essere in valori letterali oggetto. È più digitando che non serve a niente.

Ad esempio, il seguente oggetto:

const foo = {
  bar: 1,
  bar: 2
};

const foo = {
  bar: 1,
  'bar': 2
};

const foo = {
  1: 'foo',
  '1': 'bar'
};

Non dovremmo avere caseetichette duplicate nelle nostre switchdichiarazioni. Ad esempio, se abbiamo:

const a = 1;
let foo = '';
switch (a) {
  case 1:
    foo = 'a';
    break;
  case 2:
    foo = 'b';
    break;
  case 1:
    foo = 'c';
    break;
  default:
    break;
}

Pertanto, l' caseetichetta duplicata è inutile. Invece, dovremmo scrivere:

const a = 1;
let foo = '';
switch (a) {
  case 1:
    foo = 'a';
    break;
  case 2:
    foo = 'b';
    break;
  default:
    break;
}

Le istruzioni di blocco vuote sono inutili. Pertanto, non dovremmo includerli. Per esempio:

if (x === 1) {}

Classe di caratteri vuota in Regex

Una classe di caratteri vuota in regex non corrisponde a nulla, quindi probabilmente non dovrebbe essere nel codice. Ad esempio, scriviamo:

const foo = /^foo[]/;

Riassegnazione delle eccezioni nelle clausole catch

Non dovremmo riassegnare l'oggetto eccezione passato da catcha qualcos'altro poiché oscura la fonte dell'errore originale. Se lo assegnassimo a qualcos'altro, non saremmo in grado di determinare l'origine dell'errore da questo punto in poi.

Ad esempio, se scriviamo:

try {
  // ...
} catch (e) {
  e = 'foo';
}

Invece, dovremmo assegnare 'foo'a un'altra variabile come segue:

try {
  // ...
} catch (e) {
  let foo = 'foo';
}

Conclusione

Non dovremmo mai avere condizioni duplicate in più else-ifblocchi poiché solo il primo nel gruppo di duplicati farà qualcosa. Questo vale anche per le caseetichette.

Anche i valori letterali della chiave dell'oggetto non devono essere duplicati poiché rimarrà solo il valore dell'ultimo.

Altri codici inutili includono blocchi di codice vuoti e classi regex vuote.

Infine, non dovremmo riassegnare il parametro di eccezione a un altro valore poiché il valore di eccezione originale inizierà. Invece, dovremmo creare una nuova variabile e assegnarle quello che vogliamo.