Dì addio alle cattive pratiche di JavaScript

Nov 29 2022

Quando muoviamo i primi passi nel meraviglioso mondo della programmazione, vediamo di persona cosa fa per milioni di persone. È grazie alla programmazione che la vita di tanti è resa più facile, semplicemente premendo alcuni tasti sui loro dispositivi (questa è magia).

La programmazione è un altro tipo di superpotere, ma come disse lo zio Ben a suo nipote, Peter Parker, "Da un grande potere derivano grandi responsabilità". Nel mondo della programmazione, la nostra più grande responsabilità è garantire che il codice che scriviamo sia facilmente testabile e rimanga manutenibile nel tempo.

Ci sono alcune piccole pratiche nella programmazione che possono avere un impatto continuamente negativo sul codice che scriviamo e sul prodotto che creiamo come risultato finale. Ho vissuto questi problemi in prima persona. È importante condividere cosa sono e perché dovresti evitarli a tutti i costi.

1. Usare var invece di let e const

È ora di dire addio all'utilizzo di var.

Dovresti usare solo let e const per questi motivi:

● L'ambito è più chiaro (tra parentesi graffe).

● Non crea oggetti globali.

● Contrassegna gli errori se vengono nuovamente dichiarati.

A meno che tu non stia utilizzando un browser più vecchio come l'amato IE11, è nel tuo interesse lasciare andare var. Let e const saranno i tuoi migliori amici in futuro.

2. Utilizzo dei commenti per spiegare il codice

I commenti sono una parte fondamentale quando costruiamo un software, ci aiutano a capire un po' meglio il codice che stiamo leggendo, ma non dobbiamo cadere nell'errore di spiegare passo dopo passo cosa fa il nostro codice, dobbiamo creare un codice facile da le letture e i commenti dovrebbero solo fornire un contesto.

Ecco alcuni suggerimenti e promemoria per aiutarti a scrivere commenti sul codice come un professionista:

● Evita la ridondanza nei tuoi commenti; non scrivere quello che fai, scrivi perché lo fai.

● I nomi descrittivi di variabile/funzione/classe sono migliori dei commenti descrittivi.

● Riassumi il più possibile; non scrivere paragrafi se non è assolutamente necessario.

● Cerca di utilizzare sempre lo stesso linguaggio e lo stesso stile di commento.

● Nel corso del tempo, i commenti di solito non vengono mantenuti (modificati) il codice lo è.

3. Usare == invece di ===

La prima cosa da capire è che sebbene visivamente siano molto simili, fanno cose diverse: il primo è chiamato operatore di uguaglianza regolare (==) e il secondo è chiamato operatore di uguaglianza rigorosa (===).

L'operatore di uguaglianza regolare (==) controlla solo se gli operandi sono simili, il che può causare spiacevoli sorprese.

L'operatore di uguaglianza rigorosa (===) verifica sempre che gli operandi siano di tipi e valori diversi e che siano esattamente gli stessi.

4. Dimenticare di utilizzare il concatenamento opzionale

L'operatore di concatenamento facoltativo (?), consente di leggere il valore di una proprietà situata in profondità in una catena di oggetti connessi senza dover controllare ogni singolo riferimento nella catena.

Questo ci aiuta a evitare errori quando si tenta di accedere a una proprietà inesistente. Ad esempio, supponiamo di avere un oggetto Pokémon che contiene le informazioni di quel Pokémon.

Quando vogliamo accedere a una proprietà che non è definita, come in questo esempio, l'accesso alla proprietà 'attacco' Javascript genererà un errore e la nostra applicazione si interromperà. Quando si utilizza il concatenamento opzionale (?), Javascript ci dirà che la proprietà non è definita ma non genererà alcun errore. Pensare a questi tipi di errori che a volte sono fuori dal nostro controllo fa una grande differenza a lungo termine.

5. Non usare stringhe magiche e numeri magici

Un numero magico o stringhe magiche sono numeri o stringhe usati direttamente nel codice che spesso non hanno un contesto chiaro ma hanno uno scopo. È meglio assegnare questi valori alle costanti, in quanto possono diventare difficili da comprendere ed eseguire il debug in caso contrario.

6. Gestione impropria degli errori di chiamata API

Dovremmo sempre gestire gli errori con un try/catch nel nostro async/await.

Se non gestiamo gli errori nelle nostre promesse, è molto probabile che la nostra applicazione esploda e, credetemi, non vogliamo che ciò accada.

7. Utilizzo di un oggetto come singolo parametro

Quando si dichiara una funzione in cui sono previsti più valori da un oggetto, è preferibile utilizzare più parametri di input anziché input di un singolo oggetto. Questo ci aiuta con diverse cose:

Innanzitutto, rende il nostro codice più facile da leggere sapendo fin dall'inizio di quali parametri ha bisogno la nostra funzione.

In secondo luogo, rende la funzione più facile da testare e queste due cose insieme aiutano il nostro prodotto a essere manutenibile nel tempo. Inoltre, come plus, migliora le prestazioni della nostra applicazione in quanto evita di raccogliere spazzatura o creare parametri oggetto non necessari.

Un altro vantaggio è che se usi TypeScript e hai diversi parametri, è più facile definire l'interfaccia dei parametri per beneficiare del controllo del tipo e dei suggerimenti automatici che ci fanno evitare errori.

8. Dimenticare il potere delle abbreviazioni

Siamo stati tutti nella posizione di chiederci se esiste una variabile o se contiene un qualche tipo di valore diverso da null o undefined. Per questo motivo, spesso finiamo per eseguire convalide molto lunghe di questo tipo:

Le abbreviazioni ci aiutano a evitare questo problema. In un modo più semplice ed elegante, il codice sopra può essere ridotto solo al seguente:

Conclusione

Scrivere codice pulito sarà sempre nostra responsabilità. Nella mia esperienza come sviluppatore, ho imparato che avere un codice gestibile e di facile lettura farà risparmiare a te e al tuo team molte ore.

Ricorda che passiamo più tempo a leggere il codice che a scriverlo. Spero che questi piccoli suggerimenti facilitino il tuo compito di creare prodotti magici e sorprendenti.