Essendo uno sviluppatore come inizi a lavorare su un nuovo progetto...??

Per prima cosa raccogli alcuni requisiti di base e poi, in base al requisito, inizi a implementare la funzionalità una per una. Man mano che avanzi con il tuo progetto e impari di più, continui ad aggiungere e modificare il codice nella tua codebase. Successivamente si modifica anche il codice per correggere bug e casi limite.

Ma cosa succede dopo un paio di giorni o mesi…? Come appare il tuo codice...?? È complicato? È difficile da capire? Se sì, allora sicuramente non hai prestato attenzione a migliorare il tuo codice o a ristrutturarlo. Potresti aver scritto del codice duplicato senza guardare il codice esistente o potresti aver scritto metodi/funzioni più lunghi, classi di grandi dimensioni, troppi parametri, nomi di variabili non intuitivi, posizionamento del codice, ecc.

Migliorare o aggiornare il codice senza modificare la funzionalità del software o il comportamento esterno dell'applicazione è noto come refactoring del codice. Riduce i costi tecnici e rende il codice più efficiente e manutenibile. Se non presti attenzione al processo di refactoring del codice in precedenza, pagherai per gli errori nel codice in seguito. Quindi non ignorare la pulizia del codice.

In un processo di sviluppo software, diversi sviluppatori hanno stili di scrittura del codice diversi. Apportano modifiche, mantengono il codice, estendono il codice e la maggior parte delle volte lasciano il codice senza refactoring continuo. Il codice non refactoring tende a farlo marciume del codice: molto di confusione e disordine nel codice come codice duplicato, dipendenze malsane tra classi o pacchetti, cattiva allocazione delle responsabilità delle classi, troppe responsabilità per metodo o classe, ecc. Per evitare tutti questi problemi è importante il refactoring continuo.

Ora la domanda è… quali sono le tecniche per rifattorizzare il codice?

Discuteremo alcune tecniche popolari e comuni per il refactoring del codice, ma prima discutiamo alcuni suggerimenti rapidi...

Suggerimenti:

• È necessario eseguire il refactoring del codice in piccoli passaggi. Apporta piccole modifiche al tuo programma, ciascuna delle piccole modifiche migliora leggermente il tuo codice e lascia l'applicazione in uno stato funzionante.
• Esegui il test TDD e CI dopo aver apportato piccole modifiche nel processo di refactoring. Senza eseguire questi test, corri il rischio di introdurre bug.
• Non creare nuove caratteristiche o funzionalità durante il processo di refactoring. Dovresti effettuare il refactoring del codice prima di aggiungere eventuali aggiornamenti o nuove funzionalità nel codice esistente.
• Il processo di refactoring può influenzare i risultati dei test, quindi è opportuno coinvolgere il team di QA e testing nel processo di refactoring.
• Devi accettare che non sarai completamente soddisfatto del tuo codice. Il tuo codice rifattorizzato diventerà obsoleto nel prossimo futuro e dovrai rifattarlo nuovamente.

Tecniche di refactoring del codice più comuni

Esistono molti approcci e tecniche per effettuare il refactoring del codice. Parliamo di alcuni popolari...

1. Refactoring rosso-verde

Rosso-Verde è la tecnica di refactoring del codice più popolare e ampiamente utilizzata nel processo di sviluppo del software Agile. Questa tecnica segue l'approccio test-first alla progettazione e all'implementazione, gettando le basi per tutte le forme di refactoring. Gli sviluppatori prendono l'iniziativa per il refactoring nel ciclo di sviluppo basato sui test e viene eseguito nelle tre fasi distrettuali.

• ROSSO: Il primo passo inizia con la scrittura del test rosso fallito. Ti fermi e controlli cosa deve essere sviluppato.
• Verde: Nella seconda fase, scrivi il codice sufficientemente semplice e ottieni lo sviluppo che supera il test verde.
• Refactoring: Nell'ultimo e nel terzo passaggio, ti concentri sul miglioramento e sull'ottimizzazione del tuo codice mantenendo il test verde.

Quindi fondamentalmente questa tecnica ha due parti distinte: la prima parte prevede la scrittura di codice che aggiunge una nuova funzione al tuo sistema e la seconda parte riguarda il refactoring del codice che svolge questa funzione. Tieni presente che non dovresti fare entrambe le cose contemporaneamente durante il flusso di lavoro.

2. Refactoring per astrazione

Questa tecnica viene utilizzata principalmente dagli sviluppatori quando è necessario eseguire una grande quantità di refactoring. Principalmente utilizziamo questa tecnica per ridurre la ridondanza (duplicazione) nel nostro codice. Ciò implica eredità di classi, gerarchia, creazione di nuove classi e interfacce, estrazione, sostituzione dell'ereditarietà con la delega e viceversa.

Pull-up/push-down Il metodo è il miglior esempio di questo approccio.

• Metodo Pull Up: Inserisce le parti del codice in una superclasse e aiuta a eliminare la duplicazione del codice.
• Metodo push-down: Prende la parte di codice da una superclasse e la sposta giù nelle sottoclassi.

Estrarre il corpo del costruttore, estrarre la sottoclasse, estrarre la superclasse, comprimere la gerarchia, il metodo del modello di modulo, estrarre l'interfaccia, sostituire l'ereditarietà con la delega, sostituire la delega con l'ereditarietà, spingere verso il basso tutti questi sono gli altri esempi.

Fondamentalmente, in questa tecnica, costruiamo il livello di astrazione per quelle parti del sistema che necessitano di essere rifattorizzate e la controparte che alla fine lo sostituirà. Di seguito sono riportati due esempi comuni...

document.queryselector

• Incapsulato campo: Forziamo il codice ad accedere al campo con metodi getter e setter.
• Tipo generalizzato: Creiamo tipi più generali per consentire la condivisione del codice, sostituire il codice di controllo del tipo con lo stato, sostituire il condizionale con il polimorfismo, ecc.

3. Metodo compositivo

Durante la fase di sviluppo di un'applicazione molte volte scriviamo lunghi metodi nel nostro programma. Questi metodi lunghi rendono il tuo codice estremamente difficile da comprendere e da modificare. In questi casi viene utilizzato soprattutto il metodo compositivo.

In questo approccio, utilizziamo metodi di semplificazione per ridurre la duplicazione nel nostro codice. Alcuni esempi sono: metodo di estrazione, estrazione di una variabile, Temp in linea, sostituzione Temp con Query, metodo in linea, divisione di variabili temporanee, rimozione di assegnazioni ai parametri, ecc.

Estrazione: Suddividiamo il codice in blocchi più piccoli per trovare ed estrarre la frammentazione. Successivamente, creiamo metodi separati per questi blocchi, quindi vengono sostituiti con una chiamata a questo nuovo metodo. L'estrazione coinvolge classi, interfacce e variabili locali.

In linea: Questo approccio rimuove il numero di metodi non necessari nel nostro programma. Troviamo tutte le chiamate ai metodi e poi le sostituiamo tutte con il contenuto del metodo. Successivamente, eliminiamo il metodo dal nostro programma.

inserire nella tastiera

4. Metodi di semplificazione

Ci sono due tecniche coinvolte in questo approccio… discutiamole entrambe.

• Semplificazione del refactoring delle espressioni condizionali: Dichiarazione condizionale nella programmazione diventa più logico e complicato nel tempo. È necessario semplificare la logica del codice per comprendere l'intero programma.
  Esistono tanti modi per rifattorizzare il codice e semplificare la logica. Alcuni di essi sono: consolidare l'espressione condizionale e duplicare i frammenti condizionali, scomporre il condizionale, sostituire il condizionale con il polimorfismo, rimuovere il flag di controllo, sostituire il condizionale nidificato con clausole di guardia, ecc.
• Semplificazione del metodo di chiamata al refactoring: In questo approccio, rendiamo le chiamate ai metodi più semplici e facili da comprendere. Lavoriamo sull'interazione tra le classi e semplifichiamo le loro interfacce.
  Gli esempi sono: aggiunta, rimozione e introduzione di nuovi parametri, sostituzione del parametro con il metodo esplicito e la chiamata al metodo, parametrizzazione del metodo, creazione di una query separata dal modificatore, conservazione dell'intero oggetto, rimozione del metodo di impostazione, ecc.

5. Spostamento di elementi tra oggetti

In questa tecnica creiamo nuove classi e spostiamo la funzionalità in modo sicuro tra le vecchie e le nuove classi. Nascondiamo i dettagli di implementazione dall'accesso pubblico.

Ora la domanda è... quando spostare le funzionalità tra le classi o come identificare che è il momento di spostare le funzionalità tra le classi?

Quando scopri che una classe ha così tante responsabilità e stanno succedendo troppe cose o quando scopri che una classe non è necessaria e non fa nulla in un'applicazione, puoi spostare il codice da questa classe a un'altra classe ed eliminarla del tutto.

Gli esempi sono: spostare un campo, estrarre una classe, spostare un metodo, una classe in linea, nascondere un delegato, introdurre un metodo estraneo, rimuovere un intermediario, introdurre un'estensione locale, ecc.

6. Refactoring preparatorio

Questo approccio è preferibile quando si nota la necessità di refactoring durante l'aggiunta di alcune nuove funzionalità in un'applicazione. Quindi fondamentalmente fa parte di un aggiornamento software con un processo di refactoring separato. Ti risparmierai con futuri debiti tecnici se noti che il codice deve essere aggiornato durante le prime fasi di sviluppo delle funzionalità.

L'utente finale non può vedere negli occhi tali sforzi del team di ingegneri, ma gli sviluppatori che lavorano sull'applicazione scopriranno il valore del refactoring del codice durante la creazione dell'applicazione. Possono risparmiare tempo, denaro e altre risorse se dedicano un po' di tempo all'aggiornamento anticipato del codice.

È come se volessi andare 100 miglia a est ma invece di vagabondare semplicemente attraverso i boschi, guiderò per 20 miglia a nord fino all'autostrada e poi andrò per 100 miglia a est a una velocità tre volte superiore a quella che potrei avere se Sono andato direttamente lì. Quando le persone ti spingono ad andare direttamente lì, a volte devi dire: 'Aspetta, devo controllare la mappa e trovare il percorso più veloce'. Il refactoring preparatorio lo fa per me.

Jessica Kerr (Sviluppatore di software)

7. Refactoring dell'interfaccia utente

Puoi apportare semplici modifiche all'interfaccia utente e rifattorizzare il codice. Ad esempio: allinea il campo di immissione, applica il carattere, riformula con la voce attiva indica il formato, applica la dimensione comune del pulsante e aumenta il contrasto del colore, ecc.

Parole finali

È necessario considerare il processo di refactoring del codice come una sorta di pulizia della casa ordinata. Il disordine inutile in una casa può creare un ambiente caotico e stressante. Lo stesso vale per il codice scritto. Un codice pulito e ben organizzato è sempre facile da modificare, facile da comprendere e facile da mantenere. Non incontrerai difficoltà in seguito se presti attenzione al processo di refactoring del codice in precedenza.

Due degli sviluppatori di software più influenti Martin Fowler E Kent Beck hanno dedicato il loro tempo a spiegare il processo di refactoring del codice e le relative tecniche. Hanno anche scritto un libro completo su questo argomento Refactoring: migliorare la progettazione del codice esistente . Questo libro descrive varie tecniche di refactoring con una chiara spiegazione di come lavorare su questi processi di refactoring. Ti consigliamo di leggere questo libro se desideri approfondire il processo di refactoring del codice.