Kapag sumisid tayo sa mundo ng pag-unlad, napakadaling mahulog sa tukso ng pagsulat ng code na "gumagana" lang. Gayunpaman, mayroong malaking pagkakaiba sa pagitan ng isang programang tumatakbo at isa na... maayos ang pagkakabalangkas upang mapanatili Sa pangmatagalan. Ang konsepto ng malinis na kodigo, na pinasikat ng maalamat na si Robert C. Martin, ay hindi tungkol sa pagsunod sa mahigpit na mga patakaran, kundi tungkol sa pag-aampon ng isang kaisipan kung saan ang kalinawan at pagiging simple ang siyang lubos na prayoridad.
Ang pagsusulat sa ganitong paraan ay isang matalinong pamumuhunan. Hindi lamang nito mapapadali ang iyong buhay kapag binalikan mo muli ang proyekto pagkalipas ng ilang buwan, kundi nag-o-optimize ng kolaborasyon ng koponan at lubhang nakakabawas ng mga error. Sa huli, ang software ay isang buhay at umuunlad na entidad, at kung ang pundasyon ay magulo, ang anumang maliit na pagbabago ay maaaring maging isang teknikal na bangungot.
Mga Pangunahing Haligi ng Clean Code
Para simulan ang paglilinis ng ating code, dapat tayong tumuon sa pagiging madaling mabasa at simpleAng ideya ay ang sinumang developer, anuman ang kanilang antas ng karanasan, ay maaaring maunawaan ang layunin ng isang function o klase sa isang sulyap, nang hindi kinakailangang intindihin ang mga lohikal na puzzle o magbasa ng mga pahina ng panlabas na dokumentasyon.
Isang kritikal na punto ay ang naglalarawang katawaganKalimutan ang paggamit ng mga baryabol tulad ng "x", "data", o "temp". Dapat malinaw na maipahayag ng mga pangalan ang layunin ng object. Halimbawa, sa halip na tawagin ang isang baryabol na "lv_zlsch", mas natural na gamitin ang "viaPago". Kung kailangan ng isang function ng mahabang pangalan para maging malinaw, ayos lang iyon; mas mainam ang mahabang pangalan kaysa sa maikli. hindi kinakailangang komento upang ipaliwanag kung ano ang ginagawa ng tungkulin.
Ang isa pang mahalagang prinsipyo ay ang TUYO (Huwag Ulitin ang Iyong SariliAng pagdoble ng code ang pangunahing kaaway ng pagpapanatili. Kung nasusumpungan mo ang iyong sarili na nagsusulat ng parehong lohika sa dalawang magkaibang lugar, oras na para kunin ang functionality na iyon sa isang magagamit muli na function o klase. Pipigilan ka nito na makalimutang i-update ang isa sa mga punto kapag gumagawa ng pagbabago, na... pinipigilan ang mamahaling pagkakamali sa produksyon.
Dapat din nating ilapat ang Panuntunan ng Boy ScoutGawing mas malinis nang kaunti ang code kaysa sa pagkakakita mo rito. Kung, habang ginagawa ang isang feature, may makita kang hindi nakakatugon sa mga pamantayan ng kalidad, ayusin ito kahit na hindi ito bahagi ng iyong kasalukuyang gawain. Nilalabanan nito ang... teorya ng sirang bintanapinipigilan ang pagkalat ng pagkasira ng code sa buong proyekto.
Disenyo ng tungkulin at organisasyon ng klase
Tungkol sa mga tungkulin, ang ginintuang tuntunin ay gawin mo lang ang isang bagay at gawin ito nang maayos. Ang isang napakahabang function ay isang pulang bandila. Kung ang code ay lumampas sa 20 linya o nangangailangan ng pag-scroll upang makita ito nang buo, malamang na oras na para hatiin ito sa mas maliliit na piraso. Hindi lamang nito ginagawang mas madaling basahin ang code, kundi pati na rin Malaki ang naitutulong nito sa pagsusuri unitaryo.
Tungkol sa mga parametro, mainam na panatilihin mo ang isang maximum na tatlong argumentoKung kailangan mo pa ng higit, mas mainam sigurong magpasa ng isang bagay o isang istruktura. Bukod pa rito, ipinapayong iwasan ang labis na paggamit ng "else," na inuuna ang mga maagang pagbabalik o paggamit ng mga ternary operator para sa mga simpleng kondisyon, na ginagawang mas mahusay ang daloy ng programa. mas linear at direkta.
Kapag nag-oorganisa ng klase, mahalagang sundin ang lohikal na pagkakasunod-sunod. Inirerekomenda na magsimula sa mga katangian ng static at instance (sinusundan ang pagkakasunod-sunod: pribado, protektado, at pampubliko), na sinusundan ng mga constructor at panghuli ay mga metodo, na inayos ayon sa kanilang kahalagahan. Ang pag-iwan ng mga getter at setter hanggang sa huli ay makakatulong sa mambabasa na unang magpokus sa pangunahing lohika sa negosyo.
Pamamahala ng teknikal na utang at refactoring
Ang teknikal na utang ay ang "interes" na binabayaran natin para sa mga shortcut habang nagde-develop. Maaari itong maging walang ingat (pagkopya ng code mula sa internet nang hindi ito naiintindihan) o maingat (Alam na hindi ito ang pinakamainam na solusyon ngunit inuuna ang paghahatid). Anuman ang uri, ang paraan upang malutas ito ay sa pamamagitan ng patuloy na refactoring.
Ang refactoring ay kinabibilangan ng pagpapabuti ng panloob na istruktura ng code nang hindi binabago ang panlabas na pag-uugali nito. Upang magawa ito nang ligtas, mahalagang magkaroon ng awtomatikong pagsubok (TDD)Ang test-driven development ay nagbibigay-daan sa atin na tukuyin ang inaasahang pag-uugali bago isulat ang lohika, na lumilikha ng isang safety net na nagbibigay-daan sa amin na linisin ang code nang walang takot na masira ang anuman.
Mahalagang matukoy ang Mga amoy ng Code o “masasamang amoy.” Ito ang mga indikasyon na may mali: mga klaseng “God” na gumagawa ng lahat, mga variable na may malabong pangalan, o mga patay na snippet ng code na hindi na ginagamit. Ang pagtukoy at pag-aalis ng mga amoy na ito ay susi upang maiwasan ang sistema na maging matigas at imposibleng umakyat.
Pag-aangkop ayon sa wikang pamprograma
Bagama't unibersal ang mga prinsipyo, ang bawat wika ay may kanya-kanyang natatanging katangian. C#Halimbawa, mahalagang gumamit ng mga katangian sa halip na mga pampublikong patlang upang mapanatili ang encapsulation at gamitin ang LINQ upang makagawa ng mas deklaratibo at mas malinis na mga query sa data.
Sa ecosystem ng JavaScriptMahalagang iwasan ang paggamit ng "var" at palitan ito ng "let" at "const" upang mas mahusay na makontrol ang saklaw ng mga baryabol. Gayundin, hinihikayat ang paglikha ng puro function At ang modularisasyon ng code ay nakakatulong upang maiwasan ang mga hindi mahuhulaang epekto na tipikal ng wikang ito.
Bukod dito, Sawa Mas inuuna na nito ang pagiging simple, ngunit mahalagang sundin ang mga alituntunin ng PEP 8 upang mapanatili ang pagkakapare-pareho ng biswal. Ang paggamit ng mga pag-unawa sa listahan ay isang makapangyarihang kasangkapan para sa pagsulat ng code. mas maigsi at elegante nang hindi nawawala ang kalinawan.
Sa wakas, sa JavaInirerekomenda na unahin ang komposisyon kaysa sa pagmamana upang makakuha ng kakayahang umangkop. Kapag sinusuri ang Paghahambing sa pagitan ng Kotlin at JavaNakikita namin na ang paggamit ng Stream API at mga anotasyon ay nagbibigay-daan sa amin upang mabawasan ang paulit-ulit na code, na ginagawang mas mahusay ang pagproseso ng data. mas makahulugan at mas mahusay.
Balanse sa pagitan ng kalinisan at pagganap
May maling paniniwala na ang malinis na code ay nagpaparusa sa performance. Malayong-malayo ito sa katotohanan. Ang maagang pag-optimize ay kadalasang humahantong sa kumplikado at hindi mabasang code. Sa isip, dapat ka munang magsulat ng malinis na code at pagkatapos, batay doon... totoong datos ng pag-profileI-optimize lamang ang mga partikular na bottleneck.
Ang pagpili ng tamang istruktura ng datos ay hindi lamang nagpapabilis kundi nagdudulot din ng kalinawan. Ang layunin ay makahanap ng gitnang landas kung saan ang software ay mahusay sa pagpapatupad ngunit nananatiling mauunawaan ng sinumang taong magbabasa nito, iniiwasan ang mga walang kabuluhang pag-optimize na nagdaragdag lamang ng biswal na ingay.
Ang pag-aampon ng mga disiplinang ito ay nagbabago sa kalidad ng pang-araw-araw na gawain, na nagpapahintulot sa software na lumago nang malusog at napapanatili. Sa pamamagitan ng pagbibigay-priyoridad sa kalinawan kaysa sa agarang bilis, nababawasan ang oras ng pagpapanatili at tumataas ang pangkalahatang produktibidad ng koponan, na ginagawang isang... ehersisyo sa digital na paggawa ng mga kagamitan propesyonal at maaaring i-scalable.
