Codul dvs. poate mirosi! Cum de a rezolva problema

A cod miros este o bucată de cod sau model general de codificare care arată că ar putea indica o problemă mai profundă în structura generală și în proiectarea unei baze de date.

Gândiți-vă la un miros de cod ca orice semn care sugerează o secțiune de cod ar trebui să fie refactored. Nu este faptul că codul este buggy sau nefuncțional - de multe ori, codul mirositor rulează foarte bine - dar codul mirositor este adesea greu de întreținut și extins, ceea ce poate duce la probleme tehnice (în special la proiectele mai mari).

În acest articol, vom evidenția 10 dintre cele mai comune mirosuri de cod, ce să căutăm și cum să le deodorăm. Dacă sunteți un nou programator Cum să învățați programarea fără stres Cum să învățați programarea fără stresul Poate ați decis să continuați programarea, fie pentru o carieră, fie ca un hobby. Grozav! Dar poate că începi să te simți copleșit. Nu prea grozav. Iată ajutorul pentru a vă ușura călătoria. Citiți mai multe, evitați aceste și codul dvs. va fi considerabil mai bun!

1. Cuplarea strânsă

Problema
Cuplarea strânsă este atunci când două obiecte sunt atât de dependente de datele și / sau funcțiile celuilalt care modifică una necesită modificarea celeilalte. Când două obiecte sunt prea strâns legate, modificarea codului poate fi un coșmar și este mai probabil să introduceți bug-uri cu fiecare schimbare.

De exemplu:

muncitor clasic biciclete biciclete = biciclete noi (); public void naveta () bike.drive (); 

În acest caz, Worker și Bike sunt strâns cuplate. Ce se întâmplă dacă într-o zi ați vrut să conduceți o mașină în locul unei biciclete pentru naveta dvs.? Va trebui să intrați în clasa Worker și să înlocuiți toate codurile legate de biciclete cu codul legat de mașină. Este dezordonat și predispus la erori.

Soluția
Puteți slăbi cuplajul adăugând un strat de abstractizare. În acest caz, clasa Worker nu dorește doar să conducă biciclete, ci și mașini, și poate camioane, eventual chiar și scutere. Acestea sunt toate Vehiculele, nu-i așa? Deci, creați o interfață Vehicle, care vă permite să introduceți și să înlocuiți diferite tipuri de vehicule după cum doriți:

muncitor clasic vehicul vehicul; public void changeVehicle (vehicul v) vehicul = v;  public void comute () vehicul.drive ();  interfață Vehicle void drive ();  clasa Bike implementeaza vehicul public void drive ()  clasa Aplicatii auto Vehicul public void drive () 

2. Obiectele lui Dumnezeu

Problema
Un obiect al lui Dumnezeu este o clasă / modul masiv care conține prea multe variabile și funcții. Aceasta “știe prea multe” și “face prea mult,” ceea ce este problematic din două motive. Mai întâi, alte clase / module se bazează prea mult pe aceasta pentru date (cuplaj strâns). În al doilea rând, structura generală a programului devine noroioasă, pe măsură ce totul se înghesuie în același loc.

Soluția
Luați un obiect al lui Dumnezeu, separați-i datele și funcțiile în funcție de problemele pe care le au pentru a le rezolva, apoi transformați aceste grupări în obiecte. Dacă aveți un obiect al lui Dumnezeu, ar putea fi mai bine ca o compoziție a multor obiecte mai mici.

De exemplu, să presupunem că aveți o clasă monstruoasă de utilizatori:

utilizator de clasă public String username; parola publică String; adresă publică String; zipcode public String; public int ...; public String getUsername () return nume utilizator;  public void setUsername (String u) username = u; 

Ați putea transforma-o într-o compoziție a următoarelor:

utilizator de clasă credentials credentials; Profil de profil; ... Certificări de clasă public String username; parola publică String; ... public String getUsername () return nume de utilizator;  public void setUsername (String u) username = u; 

Data viitoare când trebuie să modificați procedurile de conectare, nu trebuie să accesați cu crawlere o clasă de utilizatori masivă, deoarece clasa Credentials este mai ușor de gestionat!

3. Funcții lungi

Problema
O lungă funcție este exact ceea ce pare: o funcție care a crescut prea mult. Deși nu există un număr specific pentru câte linii de cod este “prea lung” pentru o funcție, este una dintre acele lucruri în care o știi când o vezi. Este o versiune mai strictă a problemei obiectului lui Dumnezeu - o funcție lungă are prea multe responsabilități.

Soluția
Funcțiile lungi ar trebui să fie împărțite în mai multe sub-funcții, în care fiecare subfuncție este concepută pentru a face față unei singure sarcini sau probleme. În mod ideal, funcția originală lungă se va transforma într-o listă de apeluri sub-funcții, făcând codul mai curat și mai ușor de citit.

4. Parametrii excesivi

Problema
O funcție (sau constructor de clasă) care necesită prea mulți parametri este problematică din două motive. În primul rând, codul devine mai ușor de citit și face mai dificilă testarea. În al doilea rând, și mai important, poate indica faptul că scopul funcției este prea ambiguu și încearcă să se ocupe de prea multe responsabilități.

Soluția
In timp ce “prea multe” este subiectivă pentru o listă de parametri, vă recomandăm să fiți atenți la orice funcție care are mai mult de 3 parametri. Sigur, uneori are sens să existe o singură funcție cu 5 sau chiar 6 parametri, dar numai dacă există un motiv foarte bun pentru aceasta.

De cele mai multe ori, nu există unul și codul ar fi mai bine să rupă această funcție în două sau mai multe funcții diferite. spre deosebire de “Funcții lungi” codul mirosului, acest lucru nu poate fi rezolvat doar prin înlocuirea codului cu sub-funcții - funcția însăși trebuie împărțită și împărțită în funcții separate acoperind responsabilități separate.

5. Identificatori slab denumiți

Problema
Numele variabilelor cu una sau două litere. Numele funcțiilor Nondescript. Nume de clasă prea împodobite. Marcarea denumirilor de variabile cu tipul lor (de ex. B_isControl pentru o variabilă booleană). Și cel mai rău dintre toate, amestecând diferite scheme de numire pe o singură bază de coduri. Toate acestea au ca rezultat cod greu de citit, greu de înțeles și greu de întreținut.

Soluția
Alegerea unor nume bune pentru variabile, funcții și clase este o abilitate învățată. Dacă vă alăturați unui proiect existent, combinați-l și vedeți cum sunt numiți identificatorii existenți. Dacă există un ghid de stil, memorează-l și aderă la el. Pentru proiectele noi, luați în considerare formarea propriului ghid de stil și respectați-l.

În general, numele de variabile ar trebui să fie scurte, dar descriptive. Numele de funcții ar trebui să aibă de obicei cel puțin un verb și ar trebui să fie imediat evident ce funcția are doar din numele său, dar să evite întoarcerea în prea multe cuvinte. Același lucru este valabil și pentru numele claselor.

6. Numerele magice

Problema
Navigați prin intermediul unui cod care (sperăm) a scris altcineva și ați identificat numere de coduri hardcoded. Poate fac parte dintr-o declarație if-or, poate ca parte a unor calcule arcane care nu par să aibă sens. Trebuie să modificați funcția, dar pur și simplu nu puteți înțelege ce semnifică numerele. Cue capul zgârieturi.

Soluția
La scrierea codului, aceste așa-numite “numere magice” ar trebui să fie evitate cu orice preț. Codurile numerelor cu caractere au sens în momentul în care sunt scrise, dar pot pierde rapid orice sens - mai ales când altcineva încearcă să vă mențină codul.

O soluție este de a lăsa comentarii care explică numărul, dar opțiunea mai bună este de a converti numerele magice în variabile constante (pentru calcule) sau enumerări (pentru instrucțiunile condiționale și comenzile de comutare). Dând numere magice un nume, codul devine infinit mai ușor de citit dintr-o privire și mai puțin predispus la schimbări de buggy.

7. Adâncime

Problema
Există două modalități principale de a ajunge la un cod adânc imbricat: bucle și declarații condiționale. Codul adânc imbricat nu este întotdeauna rău, dar poate fi problematic deoarece poate fi greu de analizat (mai ales dacă variabilele nu sunt bine numite) și chiar mai greu de modificat.

Soluția
Dacă vă aflați în scris pentru buclă dublă, triplă sau chiar cvadruplă, atunci codul dvs. încearcă să ajungă prea departe în afara sa pentru a găsi date. În schimb, oferiți o modalitate de solicitare a datelor prin intermediul unei solicitări de funcții pe orice obiect sau modul care conține datele.

Pe de altă parte, afirmațiile condiționate profund adânci sunt adesea un semn că încercați să gestionați prea multă logică într-o singură funcție sau clasă. De fapt, cuiburile adânci și funcțiile lungi tind să meargă mână în mână. Dacă codul dvs. are declarații de comutare masive sau declarații if-then-else imbricate, este posibil să doriți să implementați în schimb un model de stat sau de strategie.

Deep cuiburi este predominant în rândul programatorilor de jocuri neexperimentate 5 Instrumente gratuite de dezvoltare software pentru a vă face propriile jocuri 5 Instrumente gratuite de dezvoltare software pentru jocuri pentru a vă face propriile jocuri Iată cele mai bune programe de dezvoltare gratuită a jocului și uneltele pe care le puteți utiliza pentru a începe să faceți jocul de vis astăzi. Citeste mai mult !

8. Excepții nefolosite

Problema
Excepțiile sunt puternice, dar ușor abuzate. Programatorii leneși care utilizează incorect declarații de aruncare-printare pot face mai greu exponențial depanarea, dacă nu chiar imposibil. De exemplu, ignorarea sau îngroparea a prins excepții.

Soluția
În loc să ignorați sau să îngropați excepțiile prinse, cel puțin să imprimați următoarea stivă a excepției, astfel încât debuggerii să aibă de lucru cu ei. Permiterea programului tău să nu funcționeze în tăcere este o rețetă pentru durerile de cap viitoare, garantată! De asemenea, preferați să prindeți excepții specifice față de excepțiile generale. Aflați mai multe în articolul nostru cu privire la modul de tratare a excepțiilor modul corect Cum să se ocupe de excepțiile Java pe calea cea bună Cum să se ocupe de excepțiile Java în modul corect În acest articol, veți afla ce excepții Java sunt, de ce sunt importante, cum să folosiți-le și greșeli comune de evitat. Citeste mai mult .

9. Cod duplicat

Problema
Executați aceeași logică exactă în mai multe zone care nu au legătură cu programul dvs. Mai târziu, îți dai seama că trebuie să modifici acea logică, dar nu-ți amintești toate locurile unde l-ai implementat. În cele din urmă se schimbă în numai 5 din cele 8 locuri, ceea ce duce la comportamente greșite și inconsecvente.

Soluția
Codul duplicat este un candidat prim pentru a fi transformat într-o funcție. De exemplu, să presupunem că dezvoltați o aplicație de chat și scrieți aceasta:

String queryUsername = getSomeUsername (); boolean isUserOnline = false; pentru (nume de utilizator String: onlineUsers) if (username.equals (queryUsername)) isUserOnline = true;  dacă (isUserOnline) ...

Undeva în cod, îți dai seama că trebuie să faci același lucru “este acest utilizator on-line?” Verifica. În loc să copiați bucla, puteți să-l trageți într-o funcție:

public boolean isUserOnline (String queryUsername) pentru (nume de utilizator String: onlineUsers) if (username.equals (queryUsername)) return true;  return false; 

Acum, oriunde în codul dvs., puteți utiliza verificarea isUserOnline (). Dacă vreodată trebuie să modificați această logică, puteți modifica metoda și se va aplica oriunde se numește.

10. Lipsa de comentarii

Problema
Codul nu are absolut nici un comentariu nicăieri. Nu există blocări de documentație pentru funcții, nici o prezentare generală a utilizării pentru clase, nici explicații despre algoritmi etc. Se poate argumenta că un cod bine scris nu are nevoie de comentarii, dar adevărul este că chiar și codul cel mai bine scris necesită mai multă energie mentală înțelegeți decât engleza.

Soluția
Scopul unei baze de date ușor de întreținut ar trebui să fie un cod care să fie scris suficient de bine încât să nu facă acest lucru nevoie comentarii, dar le are încă. Și când scrieți comentarii, încercați să explicați comentariile De ce un fragment de cod există în loc de a explica ce face. Comentariile sunt bune pentru suflet și sănătate. Nu le neglija.

Cum se scrie un cod care nu miroase

Oricât de evident ar părea, cele mai multe mirosuri ale codului provin din neînțelegerea sau neglijarea principiilor și modelelor bune de programare 10 Principii de bază de programare Fiecare programator trebuie să urmeze 10 principii de bază de programare Fiecare programator trebuie să urmeze Întotdeauna scrie cod care poate fi întreținut de oricine se poate termina până când lucrați la software-ul dvs. În acest scop, iată câteva principii de programare care vă ajută să vă curățați actul. Citeste mai mult . De exemplu, o adeziune solidă la principiul DRY elimină majoritatea duplicării codului, în timp ce stăpânirea principiului responsabilității unice face aproape imposibilă crearea obiectelor monstruoase ale lui Dumnezeu.

De asemenea, vă recomandăm să citiți articolul despre cum să scrieți un cod mai curat 10 Sfaturi pentru scrierea unui program mai curat și mai bun 10 Sfaturi pentru scrisul mai curat și codul mai bun Codul de scriere curat pare mai ușor decât este de fapt, dar beneficiile merită. Iată cum puteți începe să scrieți un cod mai curat astăzi. Citiți mai multe, care se referă la o parte mai practică a programării. Dacă nu puteți să citiți propriul cod și să îl înțelegeți dintr-o privire, cum va mai fi altcineva? Codul curat este un cod inodor.

Ce luptați cel mai mult atunci când vine vorba de programare? Trimiteți-ne cu noi în comentariile de mai jos!

Credit de imagine: SIphotography / Depositphotos

Explorați mai multe despre: Programare.