10 principi di programmazione di base che ogni programmatore deve conoscere

È facile scrivere codice. È difficile scrivere un buon codice.
Il codice errato è disponibile in molte forme. Codice disordinato, enormi catene if-else, programmi che si rompono con una regolazione, variabili che non hanno senso. Il programma potrebbe funzionare una volta ma non reggerebbe a nessun controllo.
Non accontentarti di scorciatoie. Cerca di scrivere codice facile da mantenere. Facile da mantenere e facile da mantenere per qualsiasi altro sviluppatore del tuo team. Come si scrive un codice efficace? Scrivi buon codice essendo disciplinato dai principi di programmazione.
Ecco 10 principi di programmazione che ti renderanno un programmatore migliore.
1. Keep It Simple, Stupid (KISS)
Sembra un po 'duro, ma è un principio di codifica per vivere. Cosa significa questo?
Significa che dovresti scrivere il codice nel modo più semplice possibile. Non lasciarti sorprendere dal tentativo di essere eccessivamente intelligente o esibirti con un paragrafo di codice avanzato. Se riesci a scrivere uno script in una riga, scrivilo in una riga.
Ecco una semplice funzione:
function addNumbers(num1,num2){ return num1 + num2; }
Abbastanza semplice. È facile da leggere e sai esattamente cosa sta succedendo.
Usa nomi di variabili chiari. Approfitta delle librerie di codifica per utilizzare gli strumenti esistenti. Rendi facile tornare dopo sei mesi e tornare subito al lavoro. Mantenerlo semplice ti farà risparmiare il mal di testa.
2. Scrivi il codice DRY
Il principio Don't Repeat Yourself (DRY) significa chiaramente non ripetere il codice. È un errore di codifica comune . Durante la scrittura di codice, evitare la duplicazione di dati o logica. Se hai mai copiato e incollato il codice all'interno del tuo programma, non è il codice DRY.
Dai un'occhiata a questo script:
function addNumberSequence(number){ number = number + 1; number = number + 2; number = number + 3; number = number + 4; number = number + 5; return number; }
Invece di duplicare le righe, prova a trovare un algoritmo che utilizza l'iterazione. Per i loop e mentre i loop sono modi per controllare il codice che deve essere eseguito più volte.
Il codice DRY è facile da mantenere. È più facile eseguire il debug di un loop che gestisce 50 ripetizioni rispetto a 50 blocchi di codice che gestiscono una ripetizione.
3. Aperto / Chiuso
Questo principio significa che dovresti mirare a rendere il tuo codice aperto all'estensione ma chiuso alla modifica. Questo è un principio importante quando si rilascia una libreria o un framework che altri useranno.
Ad esempio, supponiamo di mantenere un framework GUI. È possibile rilasciare per i programmatori di modificare e integrare direttamente il codice rilasciato. Ma cosa succede quando si rilascia un aggiornamento importante quattro mesi dopo?
Il loro codice si romperà. Ciò renderà gli ingegneri infelici. Non vorranno usare la tua biblioteca più a lungo, non importa quanto utile possa essere.
Rilascia invece il codice che impedisce la modifica diretta e incoraggia l'estensione. Ciò separa il comportamento di base dal comportamento modificato. Il codice è più stabile e più facile da mantenere.
4. Composizione sopra l'ereditarietà
Se scrivi codice usando una programmazione orientata agli oggetti, troverai questo utile. La composizione rispetto al principio di ereditarietà afferma: gli oggetti con comportamenti complessi dovrebbero contenere istanze di oggetti con comportamenti individuali. Non dovrebbero ereditare una classe e aggiungere nuovi comportamenti.
Affidarsi all'eredità causa due problemi principali. Innanzitutto, la gerarchia ereditaria può diventare disordinata in fretta. Hai anche meno flessibilità per definire comportamenti speciali. Supponiamo che tu voglia implementare comportamenti da condividere:
La programmazione della composizione è molto più pulita da scrivere, più facile da mantenere e consente flessibilità nella definizione dei comportamenti. Ogni comportamento individuale è la sua classe. È possibile creare comportamenti complessi combinando comportamenti individuali.
5. Responsabilità unica
Il principio della singola responsabilità afferma che ogni classe o modulo in un programma dovrebbe fornire solo una funzionalità specifica. Come afferma Robert C. Martin, "Una classe dovrebbe avere solo una ragione per cambiare".
Classi e moduli spesso iniziano in questo modo. Fai attenzione a non aggiungere troppe responsabilità man mano che le lezioni diventano più complicate. Rifattorizza e suddividili in classi e moduli più piccoli.
La conseguenza delle classi di sovraccarico è duplice. Innanzitutto, complica il debug quando si tenta di isolare un determinato modulo per la risoluzione dei problemi. In secondo luogo, diventa più difficile creare funzionalità aggiuntive per un modulo specifico.
6. Separazione delle preoccupazioni
Il principio di separazione delle preoccupazioni è una versione astratta del principio della responsabilità unica. Questa idea afferma che un programma dovrebbe essere progettato con contenitori diversi e questi contenitori non dovrebbero avere accesso l'uno all'altro.
Un esempio ben noto di ciò è il design del modello-view-controller (MVC). MVC separa un programma in tre aree distinte: i dati (modello), la logica (controller) e ciò che la pagina visualizza (visualizza). Le variazioni di MVC sono comuni nei framework Web più popolari di oggi.
Ad esempio, il codice che gestisce il database non deve sapere come eseguire il rendering dei dati nel browser. Il codice di rendering accetta input dall'utente, ma il codice logico gestisce l'elaborazione. Ogni parte di codice è completamente indipendente.
Il risultato è un codice facile da eseguire il debug. Se hai mai bisogno di riscrivere il codice di rendering, puoi farlo senza preoccuparti di come i dati vengono salvati o la logica viene elaborata.
7. Non ne avrai bisogno (YAGNI)
Questo principio significa che non dovresti mai codificare per funzionalità sulla possibilità che potresti aver bisogno in futuro. Non cercare di risolvere un problema che non esiste.
Nel tentativo di scrivere codice DRY, i programmatori possono violare questo principio. Spesso i programmatori inesperti cercano di scrivere il codice più astratto e generico possibile. Troppa astrazione provoca codice gonfio che è impossibile da mantenere.
Applicare il principio DRY solo quando è necessario. Se noti blocchi di codice scritti ripetutamente, quindi sottratti. Non pensare troppo a spese del tuo attuale batch di codice.
8. Documenta il tuo codice
Qualsiasi sviluppatore senior sottolineerà l'importanza di documentare il codice con commenti appropriati. Tutte le lingue li offrono e dovresti prendere l'abitudine di scriverli. Lascia i commenti per spiegare gli oggetti, migliorare le definizioni delle variabili e semplificare la comprensione delle funzioni.
Ecco una funzione JavaScript con commenti che guidano l'utente attraverso il codice:
//This function will add 5 to the input if odd, or return the number if even function evenOrOdd(number){ //Determine if the number is even if(number % 2 == 0){ return number; } //If the number is odd, this will add 5 and return else { return number + 5; } }
Lasciare commenti è un po 'più di lavoro mentre stai programmando e capisci abbastanza bene il tuo codice, giusto?
Lascia comunque commenti!
Prova a scrivere un programma, lasciandolo solo per sei mesi e torna a modificarlo. Sarai felice di aver documentato il tuo programma invece di dover scorrere ogni funzione per ricordare come funziona. Lavori in un team di programmazione? Non frustrare i tuoi colleghi sviluppatori costringendoli a decifrare la tua sintassi.
9. Refactor
È difficile da accettare, ma il tuo codice non sarà perfetto la prima volta. Rifattorizzare il codice significa rivedere il codice e cercare modi per ottimizzarlo. Renderlo più efficiente mantenendo i risultati esattamente gli stessi.
Le codebase sono in continua evoluzione. È del tutto normale rivisitare, riscrivere o persino riprogettare interi blocchi di codice. Ciò non significa che non hai avuto successo la prima volta che hai scritto il tuo programma. Conoscerai un progetto nel tempo. Usa questa conoscenza per adattare il tuo codice esistente a SECCO, o seguendo il principio KISS.
10. Codice pulito a tutti i costi
Lascia il tuo ego alla porta e dimentica di scrivere codice intelligente. Il tipo di codice che assomiglia più a un indovinello che a una soluzione. Non stai programmando per impressionare gli estranei.
Non cercare di racchiudere una tonnellata di logica in una riga. Lascia istruzioni chiare nei commenti e nella documentazione. Se il tuo codice è facile da leggere, sarà facile da mantenere.
Buoni programmatori e codice leggibile vanno di pari passo. Lasciare commenti quando necessario. Aderisci alle guide di stile, dettate da una lingua o dalla tua azienda.
Cosa rende un buon programmatore?
Imparare come essere un buon programmatore richiede parecchio lavoro! Questi 10 principi di codifica sono una tabella di marcia per diventare un programmatore professionista.
Un buon programmatore capisce come rendere le loro app facili da usare, funziona bene all'interno di un team e termina i progetti secondo le specifiche e in tempo. Seguendo questi principi ti preparerai per il successo nella tua carriera di programmatore. Prova questi 10 progetti di programmazione per principianti e rivedi il tuo codice. Vedi se stai rispettando questi principi. In caso contrario, mettiti alla prova per migliorare il tuo codice.
Leggi l'articolo completo: 10 principi di programmazione di base che ogni programmatore deve conoscere