Jeg liker refaktorisering. Nei ikke slik. Jeg elsker refaktorisering. Nei, ikke engang det. Jeg faen Jeg elsker refaktorisering.
Jeg tåler ikke dårlig kode og dårlig arkitektur. Jeg grøsser når jeg skriver en ny funksjon, og neste time er et komplett rot. Jeg kan bare ikke se på de dessverre navngitte variablene. Noen ganger før jeg legger meg, lukker jeg øynene og ser for meg hva som kan forbedres i et prosjekt. Noen ganger våkner jeg klokken tre om morgenen og går til den bærbare datamaskinen min for å fikse noe. Jeg vil at koden ikke bare skal være kode på ethvert utviklingsstadium, men et kunstverk som er behagelig å se på og behagelig å jobbe med.

Hvis du deler følelsene mine litt, så har vi noe å snakke om. Faktum er at over tid begynte noe inni meg å fortelle meg at det ikke var den beste ideen å refaktorere alt, overalt og hele tiden. Misforstå meg rett, koden skal være bra (og det ville vært bedre om den var perfekt), men i den harde virkeligheten er det ikke alltid lurt å hele tiden forbedre koden. Jeg har kommet opp med flere regler for meg selv om aktualitet ved refactoring. Hvis jeg begynner å klø etter å forbedre noe, så ser jeg tilbake på disse reglene og begynner å tenke: "Er det virkelig på tide å refaktorere nå?" La oss tenke på i hvilke tilfeller refaktorering er hensiktsmessig, og i hvilke tilfeller er det ikke så mye.

Ansvarsfraskrivelse. Mest sannsynlig, etter å ha lest innlegget, vil mange umiddelbart si: "Ja, dette har allerede blitt diskutert 600 ganger!" eller "Dette er så åpenbart, hvorfor skrive om det?" Du har kanskje rett, men her er tingen: kaos pågår fortsatt i verden rundt oss. Det ser ut til at alt er klart for alle, men i virkeligheten viser det seg at det ikke er så klart. Derfor tror jeg det ikke vil være for skadelig å ta en ny titt på dette emnet. Men hvis du spesifikt ikke har noen problemer med refactoring, kan du bare hoppe over dette innlegget, du har det allerede bra.

Refaktorer for tidlig

Kan du huske sist du hadde en permanent arbeidserklæring som ikke endret seg på flere måneder? Jeg er ikke så flink til å huske dette. Vi lever i den virkelige verden, kravene endres hele tiden. Dessuten er dette ikke nødvendigvis eksterne krav – dette kan være dine egne krav til prosjektet. La meg forklare ideen med et eksempel: la oss si at du tok på deg et middels stort problem i en eller to dager. De første klassene er allerede skrevet, men det er ingenting å lansere ennå – prosessen med å skrive den tøffe arkitektoniske delen er i gang. Og så legger du merke til at en av delene av prosjektet ikke er skrevet på en spesielt universell måte: "Men hvis du trenger å gjøre X om seks måneder, vil alle lide." Det er fornuftig at du ikke vil sende inn drittkode til depotet og få andre utviklere til å tenke på deg som et dårlig navn. Og du begynner å refaktorere ennå ikke klar funksjon. Noen ganger er dette berettiget, men på en slik sti bør det være et "FARE"-skilt. Så du fikser en ting, så en annen, så en tredje. En uke har gått, funksjonen starter fortsatt ikke, og du sier: «På en eller annen måte ble alt gjort feil. Men nå jeg Jeg forsto nøyaktig hvordan gjøre det. Nå skal jeg raskt skrive om alt fra bunnen av.» Hovedproblemet er at tilbakemelding på funksjonen ennå ikke er mottatt, og du har allerede begynt å jobbe med å forbedre kodebasen. Denne tilnærmingen fører sjelden til suksess. Jeg vet ikke om deg, men det skjer ofte med meg at etter å ha implementert en funksjon, begynner jeg å forstå at alt burde fungere litt annerledes. Og det er ikke fordi jeg er så dum og ikke klarte å tenke gjennom det ordentlig på forhånd. Du trenger bare å "røre" noen funksjonalitet for å forstå hvordan alt skal være i utgivelsen. Noen ganger trenger du en liten prototype (selv med dårlig kode og feil) for å diskutere en funksjon med kolleger. Noen ganger må du vise noe til kunden slik at han kan si: «Nei, vel, det var ikke det jeg ville, alt skulle være omvendt.» Noen ganger liker ikke brukere innovasjoner de vil ha alt som det var. Problemet med nye funksjoner er at det er vanskelig å forutsi deres skjebne. Det hender ofte at all utviklingen blir kastet i søpla, for etter å ha diskutert den første versjonen bestemte teamet seg for å gjøre alt annerledes. Generell konklusjon: du bør ikke refaktorere kode for tidlig, spesielt hvis du ikke er sikker på at denne koden vil forbli 100 % i prosjektet.

Refaktorering uten mål

Mest sannsynlig har du en utviklingsplan for nær fremtid. Det er sannsynlig at du har tidsfrister (selv om du setter dem selv). Utgivelser må gjøres i tide; utviklingen bør ikke forsinkes. Du må kontrollere deg selv, du må gjøre de tingene som er en del av dine umiddelbare mål. La oss si at du har en kode som ser ut som komplett... Vel, den ser dårlig ut. Men la oss fortsette vår antagelse, du jobber ikke med ham nå. Denne dårlige kodebiten er stabil, gjør jobben sin vellykket, og har ingenting å gjøre med din nåværende oppgave. Vel, ikke rør ham! Ja, du kan være ekstremt trist over det faktum at i den andre enden av prosjektet alt er veldig dårlig. Men legg merke til at akkurat nå plager dette deg ikke på noen måte. Du har aktuelle oppgaver, takle dem. Selvfølgelig er det oppgaver for å forbedre kodebasen, men ikke ofte – ofte er det viktigere å legge til ny funksjonalitet eller fikse feil. Konsentrer deg om oppgavene og ikke gi opp på dem fordi noe er galt et sted.

Refaktorering for refaktoriseringens skyld

Ok, du har kommet til den konklusjonen at du definitivt må omstrukturere deler av prosjektet. Ok, la oss refaktorere. Det ser ut til at de planlagte forbedringene er gjennomført, men så dukker tanken opp: «Hva annet kan jeg forbedre? Ja, den tingen der borte.» Og etter den tingen vil denne tingen dukke opp, og så en til, og så en til, osv. Du må forstå at det er dårlig kode, det er god kode, det er ideell kode. Du vil aldri ha det siste i et stort prosjekt. Dette betyr ikke at du ikke skal strebe etter det, men du må forstå at det er uoppnåelig. Vanligvis er målet å skrive god kode, ikke perfekt kode. La oss si at du etter refactoring har en fullstendig lesbar kode som fungerer på en mer eller mindre åpenbar måte, der det ikke er krykker og som ikke er så vanskelig å bruke. Still deg selv spørsmålet: "Kanskje det er på tide å slutte?" Ja, koden kan forbedres. Dessuten, i et stort nok prosjekt kan det forbedres i det uendelige. Men akkurat nå takler den funksjonene, den er praktisk å bruke, og den forårsaker praktisk talt ikke noe ubehag. Det er veldig viktig å bestemme selv akseptabel kvaliteten på koden, hvoretter du slutter å forbedre den (til akseptabilitetsegenskapen går tapt). Husk at det fortsatt er så mange forskjellige kule ting du kan legge til. Det er ikke nødvendig å refaktorere for å refaktorere seg selv, for perfekt kodes skyld. Må refaktorere når du har overbevisendeårsaker til dette: koden er vanskelig å lese, koden er vanskelig å vedlikeholde, koden er vanskelig å utvikle, koden er vanskelig å bruke, osv. Hvis ingen "vansker" oppstår, så overbevisende Det er ingen grunn for deg å kaste bort tid på refaktorisering.

Refaktorisering dagen før utgivelse

Det hender at utgivelsen er i overmorgen/i morgen/i dag/skulle vært i går (understrek etter behov). Dette er et viktig øyeblikk i prosjektets liv. Det er nødvendig å være spesielt oppmerksom på testing, fikse kritiske feil og endelige forbedringer. Tro meg, det er en veldig dårlig idé å omarbeide kodebasen (og enda verre, omarbeide den godt) i det øyeblikket du må sende prosjektet til produksjon. Erfaren praksis tilsier at du må slippe den, og deretter forbedre koden rolig med god samvittighet. Noen vil spørre: "Hvorfor?" Hvis dette spørsmålet har oppstått, har du sannsynligvis ikke måttet gjøre kompleks refaktorering ennå. Jeg skal gi deg et hint: Når du skriver om koden, blir det ikke alltid bedre – noen ganger kan det gå i stykker. Hvorfor er det komplisert refactoring - noen ganger korrigerer du én metode med fem linjer, klarer ikke å holde styr på noen avhengighet, og i den andre enden av prosjektet kommer det en feil som dine favorittbrukere umiddelbart vil møte. Det virker som om du ikke gjør noe galt, og plutselig angriper udyret "Det var ikke åpenbart" deg og drukner deg i en dam med en falsk innledende vurdering. Selv om det kanskje bare er det at jeg er en så dårlig programmerer - jeg liker å bryte ting. Det er godt mulig at du alltid refaktoriserer alt helt riktig og med full kontroll over hele prosjektet. I dette tilfellet kan jeg gratulere deg, men jeg vil fortsatt ikke avslå rådet om å forby refaktorisering før utgivelsen. Tro meg, refactoring vil ikke forsvinne på noen dager, og hele teamet vil sove litt roligere.

Refaktorerer veldig gammel kode

Spørsmålet er vanskelig, veldig vanskelig. Situasjon: det er et stort antall forferdelige linjer med kode du har arvet fra gamle utviklere (kanskje disse gamle utviklerne var deg for flere år siden, selv før du lærte å skrive alt riktig og på en gang). Koden må vedlikeholdes. Her og der oppstår krykker og dupliseringer, entropien vokser. Hver dag vil jeg mer og mer kaste alt ut og skrive det om fra bunnen av. I et slikt øyeblikk er det nødvendig Veldig bra tenke på risikoen. Ja, det er sannsynlig at slike aktiviteter vil være nyttige i fremtiden. Men i hvilket perspektiv og hvor nyttig? Mest sannsynlig, i prosessen med en stor refaktorisering eller omskrivning av visse deler, vil du erstatte den gamle arbeidskoden med ny, perfekt skrevet kode, men med feil. Og slett ikke fordi du er en dårlig programmerer og skriver dårlig. Du kjenner kanskje ikke denne koden tilstrekkelig. Du vet kanskje ikke hvorfor forfatteren skrev alt på denne måten, men det kan være grunner. Noen ganger må du skrive veldig merkelig og skjev kode. Jeg kan komme med mange eksempler: undertrykke vanskelige prosessoroptimaliseringer, justering for feil i et tredjepartsbibliotek, undertrykke noen flertrådede jambs, osv. Jeg sier ikke at alle disse problemene ikke kan løses normalt. Det er bare det at noen ganger når du skriver om tilsynelatende absurd kode til normal kode, dukker det opp feil. Ja, det var mulig å gjøre alt normalt, men du kan rett og slett ikke innse storheten av en hytte laget av krykker i stedet for pinner hvis du ikke finner ut av forfatteren av koden hvorfor han skrev det på denne måten (og en slik mulighet er ikke alltid gitt). Vær forsiktig når du skriver om gammel kode som du ikke helt forstår (og spesielt hvis du tror det ikke er noe å forstå).

Når bør du refaktorere?

Jeg beklager hvis denne artikkelen gir deg inntrykk av at refaktorering ikke er annet enn problemer. Jeg insisterer fortsatt på at koden skal være lesbar og vakker, den skal være enkel å bruke, og den skal være enkel å utvikle. En positiv tilnærming er bedre enn en negativ, så behandle refactoring ikke som en kilde til problemer, men som en veldig god venn som vil hjelpe deg i vanskelige tider. Dessuten kan denne vennen sørge for at det er færre vanskelige øyeblikk i din lyse fremtid. Avslutningsvis vil jeg trekke frem noen punkter når refaktorering er virkelig hensiktsmessig.

• Ingenting å gjøre. Det er stille tider med nedetid, når alle viktige oppgaver er stengt, og nye ennå ikke er tildelt. Vel, det er ikke det at det absolutt ikke er noe å gjøre, men det er en viss mengde fritid. Bruk den på å forbedre koden din. Gi enheter klare navn, bli kvitt duplisering, omskriv et dårlig stykke arkitektur. Selv om ingen ny funksjonalitet er lagt til, bidrar du til tryggheten til utviklerne som skal fortsette prosjektet. Tro meg, dette er viktig.
• Hverdagslidelser. Og det hender at det er en del av prosjektet som får deg til å sukke tungt hver dag. Og fra nabobordene kan du høre de tunge sukkene fra kollegene dine. Selv om utgivelsen ikke er i morgen, er det selvfølgelig nok viktige oppgaver. Uke etter uke går imidlertid, og å se på denne delen av prosjektet blir mer og mer trist. Fortell deg selv: "Slutt å tåle dette!" Hvis forretningsplanen er skrevet av sjefen din, så forklar ham at denne koden bare må skrives om. Hvis du jobber for en kunde, så overbevis ham om at en uke brukt på refaktorisering vil spare mye utviklingstid i fremtiden. Hvis du jobber for brukere, så bestem deg for at det ville være bedre for disse brukerne å vente en uke mer på utgivelsen denne gangen, men deretter nyte stabil programvare og regelmessige oppdateringer. Ja, det er ikke alltid lett å komme til enighet med alle og med deg selv, men prøv.
• Problemet med sen refaktorering. Regelen om refaktorisering for tidlig bør ikke gjøres absolutt. Noen tenker slik: "Nå forbedrer jeg noe, men det vil ikke være nyttig - det vil være synd." Du må forstå at det godt kan være viktige deler i kjernen av programmet som ville vært bedre skrevet godt. Husk at jo senere du refaktorerer, jo høyere blir kostnadene, fordi du vil bruke mer tid og krefter på å omskrive. Det kritiske grunnleggende (de som brukes gjennom hele prosjektet) må til enhver tid være i best mulig form. Det vil bare være flott om oppgaven fungerer i teamet ditt «Refaktorering er ikke sent. Han kommer strengt tatt når han finner det passende.».
• Møte med et monster. Du begynner å kutte ny funksjonalitet som skal bruke en gammel del av prosjektet som ser ut som et ekte monster: du blir redd akkurat når du ser på det eksterne grensesnittet. Hvis tiden tillater det, fikser du den grunnleggende delen av koden først, slik at du deretter kan fokusere på den nye funksjonaliteten og ikke bli distrahert av å hamre inn krykker for å gjenbruke koden.
• Smart perfeksjonisme. Har du lagt merke til en dårlig kode? Vil du fikse det? Vil du virkelig fikse det? Vel, hvis du virkelig vil, så kan du. Men legg merke til ordet "rimelig". Balanser tiden brukt på refaktorisering med fordelen ved å forbedre koden. Ikke gå glipp av tidsfrister og bli fast i endeløse forbedringer. Men hvis du refaktorerer på en rettidig og rimelig måte, vil prosjektet bare bli bedre.

I stedet for en konklusjon

Alt det ovennevnte er en rent subjektiv generalisering av erfaring fra en rekke prosjekter. Jeg har selvfølgelig ikke dekket alle livssituasjoner. Hvert team har sine egne kodekrav, sin egen forretningsplan og sine egne regler. Jeg er sikker på at mange mennesker har fem historier fra serien "Men jeg hadde en sak da alle disse tipsene ikke fungerte." Dette er helt normalt, som det skal være. Det er ingen universell sølvkule for å bestemme mengden innsats for å forbedre koden ("Vi refaktorerer hver dag i 47 minutter og 23 sekunder og alt vil bli bra"). Du må, basert på din egen erfaring i ditt spesifikke prosjekt, i ditt spesifikke team, prøve å finne en mellomting mellom å skrive ny kode og forbedre den gamle. Jeg tar bare til orde for en rasjonell holdning til alt uten fanatisme ("Hvorfor forbedre koden, ny funksjonalitet vil ikke dukke opp fra dette" / "Vi trenger snarest å gjøre all koden perfekt slik at vi senere kan jobbe med den normalt"). Vær smart med å bruke tiden din til å jobbe med eksisterende kode, så går det bra.

Eventuelle ytterligere tanker om når du bør eller ikke bør refaktorisere er velkomne. En av de mest verdifulle tingene på dette feltet er erfaringen til ekte utviklere på ekte prosjekter.

Refaktorering Koding er prosessen med å endre kildekoden til et program uten å påvirke dets oppførsel og sikte på å gjøre det lettere å forstå og/eller forenkle dets ytterligere støtte. Refaktorering av et hvilket som helst program innebærer vanligvis å gjøre små endringer i koden, som hver ikke endrer oppførselen til selve programmet, men på en eller annen måte forenkler og/eller forbedrer koden. Samtidig er det svært viktig at refaktoreringen utføres i små deler, pga når en programmerer endrer en liten del av koden, er det mye lettere for ham å overvåke riktigheten av endringene og ikke gjøre feil. Hvis du refaktorerer store deler av koden på en gang, er det en veldig stor sannsynlighet for å gjøre feil, som et resultat av at programmet kan slutte å fungere helt. Det faktum at redigeringene skal være små betyr riktignok ikke at refactoring bare er å erstatte variabelnavn eller flytte små deler av kode fra ett sted i programmet til et annet - refactoring lar deg omarbeide hele programmet fullstendig, inkludert logikken i dets oppførsel, det viktigste er - gjør endringer i små deler og så vil alt være bra.

Refaktorering av mål

Du vil sikkert spørre meg hvorfor jeg skriver dette likevel? Og til det faktum at hvis du ser nøye på kildekoden, for eksempel kildetekster for hver leksjon, har du sikkert lagt merke til at jeg ofte endrer noe i koden, noen ganger på små måter, og noen ganger ganske merkbart. Det er fordi Jeg bruker selv refactoring og jeg vil at dette skal bli en vane for deg også.

Som jeg allerede har sagt - hovedformålet med refaktorisering Dette for å gjøre koden enklere og tydeligere. Hvis koden ikke blir bedre og tydeligere etter omarbeiding, betyr det at du enten ikke refaktorerte, eller så mislyktes. Men ikke forveksle konseptet refaktorering med optimalisering. Som et resultat av optimalisering blir koden raskere, men ikke nødvendigvis enklere og tydeligere, refactoring tjener nettopp til å forenkle og forbedre kodelesbarheten.

Hvilken kode må refaktoreres

Du kan og må ofte refaktorere hvilken som helst kode - oftest trenger du bare å stole på instinktet ditt, hvis en eller annen kode ikke virker veldig vellykket for deg, eller det ser ut for deg at du allerede om en uke vil glemme hva denne eller den delen av kode gjør det - mest sannsynlig trenger denne koden refaktorisering. Jeg vil prøve å formulere de grunnleggende reglene, basert på hvilke du kan forstå at koden din krever omarbeiding:

Hvis programmet ditt har kodeduplisering, er refaktorering nesten helt sikkert nødvendig. Duplikatkode i et program er hovedkilden til feil. Hvis det i programmet ditt utføres en handling på flere forskjellige steder, men med samme kode, setter du ganske enkelt denne koden inn i en egen funksjon og kaller den. Ellers er det stor sannsynlighet for at du en dag redigerer kildekoden på ett sted, men glemmer å korrigere tilsvarende kode på et annet, så vil det oppstå feil.

Programmet ditt har svært lange metoder/funksjoner. Som regel kan en person ikke fullt ut oppfatte og evaluere riktigheten av koden hvis denne koden tar mer enn 2-3 dusin linjer. Slike metoder og funksjoner bør deles inn i flere mindre og det bør lages én felles funksjon som sekvensielt kaller disse metodene. Prøv aldri å redusere lengden på koden din ved å skrive flere utsagn på én linje!!! Dette er et av de verste alternativene for å organisere et program, og jeg gir deg en 100% garanti for at slik kode til slutt vil føre til feil!

Lang liste over funksjon/metode/konstruktørparametere. Et stort antall parametere gjør det vanligvis ikke bare vanskelig å forstå hva en metode eller funksjon gjør, men gjør det også vanskelig å forstå koden som bruker disse funksjonene. Hvis du virkelig trenger en funksjon for å ta mange parametere, bare legg disse parameterne i en egen struktur (eller klasse), gi denne strukturen et rimelig og forståelig navn, og send funksjonen en lenke (eller peker) til et objekt av dette struktur eller klasse.

Store klasser krever også refaktorisering. Hvis du har en eller flere store (mer enn et par dusin kodelinjer) klasser i programmet ditt, bør du umiddelbart dele dem inn i mindre og inkludere objekter av disse klassene i en felles klasse. Årsaken til dette er den samme som i forrige avsnitt.

For mange midlertidige variabler er også et tegn på dårlig kode som må refaktoreres. Som regel finnes mange midlertidige variabler i altfor "oppblåste" funksjoner - når du refaktoriserer slike funksjoner, vil mest sannsynlig antall midlertidige variabler i hver av dem bli mindre og koden vil bli mye klarere og mer praktisk

Det er mye "rotete" lagret data som er logisk koblet sammen og kan kombineres til en struktur eller klasse. Logisk relaterte data skal alltid lagres i strukturer/klasser, selv om det kun er 2-3 variabler - dette vil ikke gjøre noen dårligere, men koden vil bli mye klarere.

Hvis objekter av en klasse får tilgang til (refererer til) data til et annet objekt for mye/hyppig, bør du revurdere funksjonaliteten til objektene. Kanskje du tok feil arkitektonisk avgjørelse, og du må endre den så snart som mulig, før denne feilen sprer seg gjennom hele koden.

Prøv å ikke lagre for mange globale variabler. Hvis du virkelig trenger akkurat så mange og ikke mindre globale objekter - prøv i det minste å gruppere dem i strukturer/klasser, eller i det minste bare sette dem i et eget navneområde - så er det en sjanse for at du ved et uhell bruker en eller annen variabel ved en feil. blitt betydelig lavere.

Refaktorering av kode

Målet med arbeidet: lær å omorganisere programkode basert på refaktoriseringsmønstre.

Arbeids prosess

1. Studer teoretisk informasjon.
2. Utfør kodeanalyse av programvaren som utvikles og enhetstester for å identifisere dårlig organisert kode.
3. Ved å bruke refactoring maler, reorganiser programkoden til programvaren som utvikles og enhetstester.
4. Bekreft at alle enhetstester kjører vellykket.
5. Fullfør en beskrivelse av refactoring-operasjonene som er utført (was-was-refactoring-mønsteret).
6. Juster om nødvendig designdokumentasjonen (klassediagrammer, sekvensdiagrammer).
7. Trekk konklusjoner basert på resultatene av arbeidet.

Krav til innholdet i arbeidet

1. Jobbtittel.
2. Målet med arbeidet.
3. Kort formulering av den enkelte oppgave.
4. Tabell over endringer i programvaredesign.
5. Justerte klasse- og sekvensdiagrammer om nødvendig.
6. Konklusjoner.

Teoretisk informasjon

Tegn på dårlig organisert kode

Dette er ikke et sett med klare regler, men en beskrivelse av steder man bør være oppmerksom på ved refaktorisering.

Duplikatkode

Hvis du ser de samme kodestrukturene flere steder, kan du være sikker på at dette programmet blir bedre hvis du kan forene dem.

I de enkleste tilfellene vil uttrekksmetoden hjelpe deg. Når du arbeider med arv, bruk Pull Up Field. Hvis koden er lik, men ikke nøyaktig, må du bruke Extract Method, og deretter Form Template Method. Hvis metodene gjør det samme på forskjellige måter, velg en av dem og bruk erstatningsalgoritmen. Hvis du har duplikatkode i urelaterte klasser, bør du vurdere funksjonen Trekk ut klasse.

Lang metode

Blant objektprogrammer lever programmer med korte metoder lengst. Jo lengre prosedyren er, desto vanskeligere er det å forstå. Hvis du har et godt navn på metoden, trenger du ikke se på kroppen.

Vi følger en heuristikk: når vi føler at vi bør skrive en kommentar, skriver vi en metode i stedet. I 99 % av tilfellene, for å forkorte metoden, trenger du kun å bruke uttrekksmetoden. Lokale variabler og parametere kan komme i veien for deg, så du kan trenge Replace Temp With Query, Introduce Parameter Object og Preserve Whole Object.

Bortsett fra kommentarer er løkker og forhold også gode tegn. Bruk Decompose Conditional for forhold, og for løkker, plasser sløyfekroppen i en egen metode.

Stor klasse

Når en klasse gjør for mange ting, har den vanligvis for mange felt.

Du kan bruke Extract Class eller Extract Subclass for å trekke ut noen variabler. Når du bestemmer hva du skal ta ut, se etter fellestrekk i variabelnavn og om klassen bruker dem alle samtidig.

I tillegg er et klasserom med for mye kode også en grobunn for duplisering og kaos. Her bruker du også Extract Class eller Extract Subclass.

Hvis den store klassen din er en GUI-klasse, prøv å skille adferden fra dataene. Du kan trenge dupliserte observerte data.

Lang liste med alternativer

Dette er en levning fra prosedyreprogrammering. I objektverdenen er det alltid et objekt som du kan stille et spørsmål til og få alle svarene du trenger.

Bruk Erstatt parameter med metode, bevar hele objektet og introduser parameterobjekt.

Divergent endring

Divergent endring er når en klasse er gjenstand for forskjellige endringer.

Vi strukturerer programvaren vår for å gjøre det enklere å endre. Hvis vi ønsker å endre noe, ser vi etter det eneste stedet hvor vi kan gjøre endringen. Hvis vi ikke klarer dette, lukter vi vondt. Du kan se på klassen og tenke: "Jeg endrer disse tre metodene hver gang jeg kobler til en ny database, og disse fire - når jeg legger til et finansielt instrument." For å rydde opp i dette, finn alt som endres i dette spesielle tilfellet og bruk Extract Class.

Hagleoperasjon

Det er som divergerende forandringer, men omvendt. Hver gang du trenger å gjøre en endring som dette, gjør du en haug med små endringer i forskjellige klasser. Dette fører ofte til feil.

Bruk Move Method og Move Field for å sette alle endringer i én klasse. Hvis ingen klasse ser ut som en god kandidat, oppretter du en ny klasse.

Bruk Inline Class om nødvendig. Divergent endring er når en klasse påvirkes av forskjellige endringer, mens haglekirurgi er når en endring påvirker flere klasser.

Misunnelse etter funksjon

Hensikten med å ha objekter i et program er å kombinere data og metodene som bruker dem. En typisk dårlig lukt er når en metode virker mer interessert i dataene til et annet objekt enn sin egen.

Bare bruk Move-metoden for å flytte den dit den skal være. Hvis bare en del av metoden lider av misunnelse, bruk uttrekksmetoden først.

I tilfellet der en metode bruker data fra flere objekter, plasser den på objektet den er mest interessert i. Bruk uttrekksmetode for å isolere avhengigheter.

Bruken av noen komplekse mønstre, som strategi og besøkende, bryter med disse reglene. Den generelle anbefalingen er å alltid finne en balanse mellom kompleksitet og nødvendig fleksibilitet.

Datagrupper

Hvis du ser at dataelementer alltid reiser sammen, kombinerer du dem til ett objekt. Bruk Extract Class for felt, Bevar hele objektet og Introduser parameterobjekt for metodeparametere.

En god testmetode er: hvis du fjerner ett av dataelementene, vil de andre fortsatt gi mening? Hvis ja, bør en gjenstand være født her.

Besettelse av primitiver

Begynnende objektprogrammerere unngår vanligvis å bruke små objekter til små oppgaver som valutaer, rekkevidder, spesielle strenger for telefonnumre og lignende. Du kan komme deg ut av hulene inn i den siviliserte verdenen av objekter ved å bruke Erstatt dataverdi med objekt, Erstatt array med objekt, hvis det er en typekode, bruk Erstatt typekode med klasse, Erstatt typekode med underklasser og Erstatt typekode med strategi .

Bryter (sak) erklæring

God objektkode bruker svært sjelden Switch-setninger. Ofte vil du se den samme bryteren på forskjellige steder. Hvis du trenger å legge til et annet valg, må du søke etter alle Switch-utsagn.

I de fleste av disse tilfellene er kuren polymorfisme. Hvis bryteren bytter etter typekode, bruk Erstatt typekode med underklasser eller Erstatt typekode med strategi. Du kan trenge en uttrekksmetode og en flyttemetode for å isolere bryteren og plassere den i ønsket klasse. Når du har satt opp arvestrukturen, bruk Erstatt betinget med polymorfisme.

Parallelle arvehierarkier

Parallelle hierarkier er et spesielt tilfelle av haglekirurgi. Hver gang du legger til et barn i en klasse, blir du tvunget til å legge til et barn fra en annen klasse. La først forekomster av ett hierarki referere til tilsvarende forekomster av et annet. Bruk deretter Move Method og Move Field og det andre hierarkiet vil forsvinne litt etter litt.

Lat klasse

Hver klasse du lager koster deg penger å forstå og vedlikeholde. En klasse som ikke gjør nok for å betale for seg selv, må ødelegges. Ofte er dette en klasse som tidligere var lønnsom, men som ble kuttet under refaktorering. Hvis det er et barn fra en annen klasse, bruk Skjul hierarki. Nesten ubrukelige klasser bør gjennomgå Inline Class.

Spekulativ generalisering

Dette er et tilfelle der noen sier: "Å, se, vi trenger denne funksjonen en dag," og ønsker derfor å sette inn alle slags kroker og spesielle tilfeller for å håndtere ting som ikke er nødvendig. Resultatet er vanskeligere å bruke og vedlikeholde.

Hvis du har abstrakte klasser som ikke gjør noe, bruk Collapse Hierarchy. Unødvendig delegering kan fjernes ved å bruke Inline Class. Metoder med ubrukte parametere må være underlagt Fjern parameter.

Midlertidig felt

Noen ganger vil du se kode som bare bruker forekomstvariabler i visse tilfeller. Dette gjør det svært vanskelig å forstå.

Bruk Extract Class for å lage et hjem for fattige foreldreløse barn. Plasser all koden relatert til disse feltene der. Du kan også bli kvitt den betingede koden ved å bruke Introduce Null Object for å lage et alternativt objekt for når disse feltene ikke gir mening.

Meldingstråd

Hvis du ser kode der en klient ber om et objekt fra et annet objekt, så har objektet det neste objektet osv. Dette kan være en lang rekke getThis-metoder eller en sekvens av midlertidige variabler. I alle fall, med slike samtaler, forutsetter vi eksplisitt kunnskap om strukturen til objektene i kjeden. Enhver endring i relasjonene vil resultere i en endring av denne koden. Her må du bruke Hide Delegate. Se hvorfor samtaleresultatet brukes. Bruk uttrekksmetoden og deretter flyttemetoden for å flytte den lenger opp i kjeden. Noen er imot enhver kjede av metoder. Vi står for måtehold.

Formidler

En av hovedegenskapene til objekter er innkapsling. Du spør direktøren om han er ledig til et møte. Han delegerer meldingen til planleggeren og svarer. Du trenger ikke å vite om han bruker en planlegger, en elektronisk dings eller en sekretær.

Dette kan imidlertid gå for langt. Du ser på grensesnittet til en klasse og ser at halvparten av metodene ganske enkelt delegerer anrop til andre klasser. På tide å bruke Fjern Middle Man og snakk direkte med objektene som vet hva som skjer. Hvis bare noen metoder delegerer, kjør den innebygde metoden på dem. Hvis du legger til atferd i tillegg til delegering, bruk Erstatt delegering med arv.

Urettmessig intimitet

Noen ganger kommer timene for tett og bruker for mye tid i hverandres private deler.

Bruk Move Method og Move Field for å skille deler og redusere nærhet. Se om du kan organisere en Endre toveis tilknytning til enveis. Hvis klasser virkelig har en felles interesse, bruk Extract Class for å plassere fellesdelene på ett sted.

Arv fører ofte til unødig intimitet. Etterkommere vet alltid mer om sine forfedre enn forfedrene ønsker. Bruk Erstatt arv med delegering når det er på tide å reise hjemmefra.

Ufullstendig bibliotekklasse

Ofte er vi ikke helt fornøyd med en bibliotekklasse, men vi kan ikke bruke noe som Move Method på den. Hvis du trenger å legge til et par metoder, bruk Introduce Foreign Method. Hvis du trenger å legge til mye, trenger du Introduce Local Extension.

Dataklasse

Det er klasser som bare inneholder felt og metoder for å få tilgang til dem. Dette er bare dumme beholdere for data og mest sannsynlig manipulerer andre klasser dem i for mye detalj. Bruk først Encapsulate Field og Encapsulate Collection mens ingen ser. Se hvor klassedataene brukes. Prøv å bruke Move Method for å flytte denne koden inn i selve dataklassen. Dataklasser er som barn. De er nødvendige i de innledende stadiene. Men for å oppføre seg som en voksen gjenstand, må de ta ansvar.

Avvist arv

Underklasser arver metoder og data fra sine forfedre. Men noen ganger utnytter de ikke det de får.

Det tradisjonelle svaret er at hierarki er dårlig. Du må opprette en ny avledet klasse og bruke Push Down Method og Push Down Field. Men du kan gjette ut fra vår sarkastiske bruk av ordet tradisjonell at vi ikke alltid vil anbefale det. Vi bruker arv til gjenbruk. Det er ledsaget av en dårlig lukt, men den er vanligvis ikke veldig sterk. Hvis en avvist arv er et problem, bruk tradisjonelle råd.

Mozilla FireFox, for å avklare versjonen av dette programvareproduktet, må du åpne "Hjelp"-delen i menyen og klikke på det nederste elementet ("Om Mozilla Firefox"). Et eget vertikalt vindu åpnes, der en indikasjon på den nøyaktige versjonen av tre tall atskilt med en prikk er plassert under den store Firefox-inskripsjonen.

I Opera-menyen må du også åpne delen "Hjelp" og klikke på det nederste elementet ("Om programmet"). Men her, i motsetning til alle andre nettlesere, dukker ikke et eget vindu opp - et vanlig vindu åpnes, hvorav det meste er okkupert av lister over ulike typer lagring opprettet av nettleseren i din. Helt i begynnelsen av denne listen er det en egen seksjon, som kalles "Versjonsinformasjon". Operaversjonsnumre er to tall atskilt med en prikk.

I Internet Explorer, ved å åpne den samme menydelen kalt "Hjelp" og klikke på det siste elementet i listen, "Om", vil du se et vindu med en streng påminnelse om overholdelse av opphavsrett. I tillegg til denne teksten er det ikke mindre alvorlig kode som indikerer nettleserversjonen. I den er så mange som fire tall atskilt med en prikk, hvorav ett allerede har overskredet det firesifrede merket.

I Google Chrome, i tillegg til den like alvorlige koden til versjonen som brukes (fire tall atskilt med prikker), er det også en indikasjon på den siste modifikasjonen som er tilgjengelig for installasjon. For å se et eget vindu med all denne informasjonen, må du åpne menyen ved å klikke på skiftenøkkelikonet øverst til høyre i vinduet nettleser, og velg "Om Google Chrome".

I Apple Safari-nettleseren er det to måter å åpne et vindu med versjonsinformasjon på. En av dem ligner på metoden til Chrome-nettleseren - du må klikke på ikonet som ligger på samme sted (her tegnes et tannhjul på det) og velge "Om Safari". Den andre ligner veldig på Mozilla og IE - du må åpne "Hjelp"-delen i menyen og klikke på det nederste elementet ("Om Safari"). Apple kom opp med den lengste versjonsbetegnelsen: i tillegg til tre tall atskilt med en prikk, er det også et komplement med tre tall i parentes.