Esempio
Mi sono imbattuto in un codice monolitico che fa "tutto" in un unico posto - caricando i dati dal database, mostrando markup HTML, fungendo da router / controller / azione. Ho iniziato ad applicare SRP spostando il codice del database nel suo file, fornendo una migliore denominazione delle cose, e tutto sembrava a posto, ma poi ho iniziato a dubitare del perché lo stia facendo.
Perché refactor? Qual è lo scopo? È inutile? Qual è il vantaggio? Si noti che ho lasciato per lo più il file monolitico così com'è, ma ho eseguito il refactoring solo della porzione più piccola che era rilevante per l'area in cui avevo bisogno di fare un po 'di lavoro.
Codice originale:
Per fare un esempio concreto, mi sono imbattuto in questo frammento di codice: carica le specifiche del prodotto da un ID prodotto noto o da un ID versione selezionato dall'utente:
if ($verid)
$sql1 = "SELECT * FROM product_spec WHERE id = " . clean_input($verid);
else
$sql1 = "SELECT * FROM product_spec WHERE product_id = " . clean_input($productid) ;
$result1 = query($sql1);
$row1 = fetch_array($result1);
/* html markup follows */
refactoring:
Dal momento che sto facendo un lavoro che mi richiede di cambiare le cose in questa parte specifica del codice, l'ho modificato per utilizzare il modello di repository e l'ho aggiornato per utilizzare le strutture MySQL orientate agli oggetti:
//some implementation details omitted
$this->repository = new SpecRepository($mysql);
if ($verid)
$row1 = $this->repository->getSpecByVersion($verid);
else
$row1 = $this->repository->getSpecByProductId($productid);
/* html markup follows to be refactored or left alone till another time*/
//added new class:
class SpecRepository extends MySqlRepository
{
function getSpecByVersion(int $verid)
{
return $this->getMySql()->paramQuery("
SELECT * FROM product_spec WHERE id = ?
", $verid)->getSingleArray();
}
function getSpecByProductId(int $productid)
{
return $this->getMySql()->paramQuery("
SELECT * FROM product_spec WHERE product_id = ?
", $productid)->getSingleArray();
}
}
Dovrei farlo?
Guardando indietro alle modifiche, il codice è ancora lì, codice con la stessa funzionalità, ma in file diversi, nomi, luoghi diversi, usando uno stile più orientato agli oggetti piuttosto che procedurale. In realtà è divertente notare che il codice refactored sembra molto più gonfio nonostante abbia la stessa funzionalità.
Prevedo alcune risposte che dicono "se non conosci i motivi per cui fai il refactoring, non farlo", e forse potrei essere d'accordo. Le mie ragioni sono di migliorare la qualità del codice nel tempo (e la mia speranza è che lo farò seguendo SRP e altri principi).
Sono abbastanza buone ragioni o sto sprecando il mio tempo a "riorganizzare il codice in giro" in questo modo? Nel complesso il refactoring sembra un po 'come calpestare l'acqua per essere onesti - ci vuole tempo e diventa più "separato" per quanto riguarda la SRP, ma nonostante le mie buone intenzioni non mi sento come se stessi facendo incredibili miglioramenti. Quindi, discutendo se è meglio lasciare il codice come prima e non refactoring.
Perché ho refactoring in primo luogo?
Nel mio caso sto aggiungendo nuove funzionalità per una nuova linea di prodotti, quindi devo seguire la struttura del codice esistente per linee di prodotti simili o scrivere la mia.
select *diventa una "best practice".
Select * from ..può essere considerato un anti-pattern. Vedi stackoverflow.com/q/3639861/31326