"Hello ulit."
"Hi!"
"Ngayon sasabihin ko sa iyo ang tungkol sa refactoring. Ang refactoring ay binabago ang code sa isang proyekto nang hindi binabago ang functionality nito."
"Ngunit paano ito posible?"
"Buweno, sa pinakasimpleng mga kaso, maaari naming palitan ang pangalan ng mga variable at/o mga pamamaraan. Pagkatapos ng lahat, ang pagpapalit ng pangalan ng isang variable ay hindi gagawing naiiba ang programa, hindi ba?"
"Syempre hindi."
" Maaari mo ring hatiin ang malalaking pamamaraan sa ilang mas maliliit na paraan. "
"Maaari mong hilahin ang paulit-ulit na mga snippet ng code sa isang hiwalay na paraan. "
"Ang ilang mga pag-andar ay maaaring ideklarang static at pagkatapos ay ilipat sa mga klase ng utility."
"Ngunit ito ay isang makitid na interpretasyon ng refactoring."
"Ang refactoring minsan ay nangangahulugan ng muling pagsulat (pagpapabuti) ng arkitektura ng isang proyekto nang hindi nagdaragdag ng bagong functionality. Ito ay refactoring sa malawak na kahulugan ng termino."
"Ang IntelliJ IDEA ay naging pinakasikat na integrated development environment (IDE) partikular dahil ito ang unang nagpakilala ng napakalakas na mga tool sa refactoring."
"Ano ang mga mahiwagang kasangkapan na ito?"
Magic trick #1: Baguhin ang pangalan ng paraan.
"Isipin na ang iyong code ay may isang paraan na tinatawag mula sa 100-500 iba't ibang mga lugar. Napagpasyahan mong baguhin ang pangalan nito sa isang bagay na mas maliwanag. Sabihin nating ito ay run(), at gusto mo itong maging runDownloadTaskAsync(). Gaano kabilis kaya mo ba yun?"
"Buweno, kailangan mo munang baguhin ang pangalan ng pamamaraan, pagkatapos ay hanapin ang lahat ng mga lugar sa programa kung saan tinawag ang pamamaraang iyon, at palitan din ang pangalan doon."
"At paano mo mahahanap ang mga lugar na iyon?"
"Patakbuhin ko lang ang programa at ipapakita sa akin ng IntelliJ IDEA ang lahat ng mga lugar kung saan tinatawag ang isang hindi umiiral na pamamaraan."
"Okay. Ngunit ngayon ipagpalagay na ang bawat pamamaraan ay may isang paliwanag na komento (JavaDoc) na nagpapaliwanag kung ano ang ginagawa ng pamamaraan - at ang lumang pangalan ng pamamaraan ay nakasulat doon."
"Baguhin ko rin ang mga komento."
"Ngunit maaaring mayroon ding mga variable na ang mga pangalan ay nauugnay sa pangalan ng pamamaraan. Mainam na baguhin din ang mga iyon:"
| dati | Pagkatapos |
|---|---|
|
|
"Oo, magandang baguhin din ang mga pangalan ng mga variable na iyon. Hindi masakit."
"Well, lahat ng ito ay magagawa sa loob lamang ng ilang segundo gamit ang IntelliJ IDEA!"
"Ilalagay mo ang cursor sa pangalan ng pamamaraan (o i-click ito gamit ang mouse), at pagkatapos ay pindutin ang Shift+F6 at simulang i-type ang nais na pangalan ng pamamaraan."
"Narito ang isang halimbawa ng pag-edit ng pangalan ng pamamaraan."
"Simulan ang pag-edit:"
"Tumukoy ng bagong pangalan:"
"Ipasok lamang ang isang bagong pangalan, pindutin ang enter, at iyon na. Ang pamamaraang ito ay papalitan ng pangalan saanman ito tinawag sa proyekto."
"Karaniwang nagtatanong din ang IntelliJ IDEA kung gusto mong palitan ang pangalan ng mga variable na pangalan at pangalan ng pamamaraan sa mga komento. I-click lamang ang 'Oo' at babaguhin nito ang lahat."
"Higit pa rito, kung ang proyekto ay pinagsama-sama bago ang refactoring operation na ito, kung gayon ito ay garantisadong mag-compile pagkatapos ng refactoring."
"Sounds very promising."
"Nga pala, maaari mong baguhin ang mga pangalan ng variable sa parehong paraan. Pagkatapos mag-click sa isang pangalan, pindutin lamang ang Shift+F6 — Pagkatapos ay maaari kang magpasok ng bagong pangalan, at babaguhin ng IntelliJ ang pangalan ng variable saanman ito ginagamit. "
"Kung ang variable ay isang field sa isang klase at may getter at setter, ang mga pangalan ng getter at setter ay babaguhin din upang tumugma sa bagong pangalan ng variable."
"Sinubukan ko ito gamit ang mga variable. Lahat ay gumagana tulad ng sinabi mo, Ellie. Ang refactoring ay kahanga-hanga!"
"Sa tingin mo ba hanggang doon lang ang refactoring? Ang refractoring ay napakalawak na paksa — hindi man lang tayo nagkamot."
"Wow. Ano pa bang meron?"
Magic trick #2: Mag-extract ng variable.
"Minsan ang ilang mga expression ay paulit-ulit nang napakadalas sa code na gugustuhin mong ilipat ang mga ito sa isang hiwalay na variable. Halimbawa:"
public void printInfo(User user)
{
System.out.println(user.getProfile().getName());
System.out.println(user.getProfile().getAddress().getState());
System.out.println(user.getProfile().getAddress().getCity());
System.out.println(user.getProfile().getAddress().getStreet());
System.out.println(user.getProfile().getAddress().getHomeNumber());
}public void printInfo(User user)
{
Address address = user.getProfile().getAddress();
System.out.println(user.getProfile().getName());
System.out.println(address.getState());
System.out.println(address.getCity());
System.out.println(address.getStreet());
System.out.println(address.getHomeNumber());
}"Ah."
"At ang code ay maaaring maging mas kumplikado, na may maraming paulit-ulit na bahagi."
"Hindi sinasadya ng mga programmer ang pagsulat nito. Ngunit kadalasan ay kailangan mong magdagdag ng isang bagay sa isang paraan, pagkatapos ay iba pa — at sa paglipas ng panahon ang bilang ng mga pag-uulit ay dumadaan sa bubong."
"Sa pamamagitan ng paglikha ng isang hiwalay na variable, maaari naming bigyan ito ng tamang pangalan at pagbutihin ang pagiging madaling mabasa ng code."
"Halimbawa, sa halimbawa sa itaas, marahil ay hindi namin pinag-uusapan ang tungkol sa isang address ng tahanan. Marahil ay pinag-uusapan natin ang tungkol sa address ng isang emergency contact. Pagkatapos ay maaari mong tawagan ang variable na emergencyContactAddress na ito, sa halip na address lamang. Pagkatapos, isang programmer Kapag nakita mo ang code na ito sa unang pagkakataon, mauunawaan mo kung ano ang nangyayari dito."
"Oo, sumasang-ayon ako. Ang pagdaragdag ng mga ganitong variable ay may katuturan."
"So, paano mo ito gagawin?"
"Ang paglipat ng isang expression sa isang hiwalay na variable ay napakasimple."
Hakbang 1: Gamitin ang mouse upang piliin ang expression.
Hakbang 2: Pindutin ang Ctrl+Alt+V
"Ang isang window ay bubukas kung saan ang IntelliJ IDEA ay nagtatanong sa amin kung gusto naming palitan lamang ang napiling expression o lahat ng mga pagkakataon ng expression (4 na paglitaw)?"
"Piliin ang pangalawang opsyon upang palitan ang lahat ng mga pangyayari (Palitan ang lahat ng 4 na pangyayari)"
Hakbang 3: Pindutin ang Enter.
"Ipo-prompt ka ng IntelliJ IDEA na maglagay ng variable na pangalan. Gagawa rin ito ng sarili nitong mungkahi para sa pangalan. Hindi masama, eh?"
"Uh-huh. Right on. We were also planning on the variable 'address'. Paano nito nalaman?"
"Sa pamamagitan ng paggamit ng pangalan ng huling paraan sa expression, na nagbabalik ng isang address. Kaya, malamang na ang variable ay gagamitin upang mag-imbak ng isang address."
"That worked out really well. Great stuff, Ellie."
Magic trick #3: I-extract ang code sa isang hiwalay na paraan.
"Ngunit maaari tayong gumawa ng iba pa. Maaari tayong magdeklara ng bagong pamamaraan, hal printAddress (), at ilipat ang lahat ng code na ito dito."
"Subukan nating gawin iyon."
Hakbang 1: Piliin ang 4 na linya ng code na gumagamit ng variable ng address:
Hakbang 2: pindutin ang Ctrl+Alt+M
"Tinutukoy ng IntelliJ IDEA kung aling mga variable ang kakailanganin ng pamamaraan, at nagmumungkahi kung ano ang dapat na hitsura nito. "Ang tanging natitira ay maglagay ng pangalan para sa pamamaraan."
Hakbang 3: Ipasok ang printAddress bilang pangalan ng pamamaraan at pindutin ang Enter.
"Paano mo gusto iyan?"
"Ito ay kahanga-hanga. Hindi lamang kinuha ng IntelliJ IDEA ang code sa isang hiwalay na paraan, idinagdag din nito ang lahat ng kinakailangang variable. Higit pa rito, nahulaan nito nang tama ang lahat ng mga pangalan."
GO TO FULL VERSION