Det gör det möjligt för oss att återanvända koden i den andra delen så här:
annars $ pfCount = count ($ pf); för ($ i = 0; $ i<$pfCount;$i++) if(isDivisible($num, $pf[$i])) return false; return true;
Och så snart vi började arbeta med den här koden såg vi att det är oslagbart i linje med varandra. Hängslen är ibland vid början av linjen, andra gånger i slutet.
Ibland används flikar för indryckning, ibland mellanrum. Ibland finns det mellanrum mellan operand och operatör, ibland inte. Och nej, det här är inte särskilt skapad kod. Detta är verkligheten. Verklig kod, inte någon artificiell övning.
// Kontrollera om ett tal är primära funktionen är Prime ($ num, $ pf = null) if (! Is_array ($ pf)) for ($ i = 2; $ i < intval(sqrt($num)); $i++) if (isDivisible($num, $i)) return false; return true; else $pfCount = count($pf); for ($i = 0; $i < $pfCount; $i++) if (isDivisible($num, $pf[$i])) return false; return true;
Det ser bättre ut. Omedelbart de två om uttalanden ser väldigt likartade ut. Men vi kan inte extrahera dem på grund av lämna tillbaka uttalanden. Om vi inte kommer tillbaka kommer vi att bryta logiken.
Om den extraherade metoden skulle returnera en booleska och vi jämför det för att bestämma om vi ska eller inte återvända från isPrime (), det skulle inte alls hjälpa. Det kan finnas ett sätt att extrahera det genom att använda några funktionella programmeringskoncept i PHP, men kanske senare. Vi kan göra någonting enklare först.
funktionen ärPrime ($ num, $ pf = null) if (! is_array ($ pf)) return checkDivisorsBetween (2, intval (sqrt ($ num)), $ num); annars $ pfCount = count ($ pf); för ($ i = 0; $ i < $pfCount; $i++) if (isDivisible($num, $pf[$i])) return false; return true; function checkDivisorsBetween($start, $end, $num) for ($i = $start; $i < $end; $i++) if (isDivisible($num, $i)) return false; return true;
Extraktionen av för slingan som helhet är lite lättare, men när vi försöker återanvända vår extraherade metod i den andra delen av om vi kan se att det inte kommer att fungera. Det är här mystiskt $ pf variabel som vi nästan inte vet om.
Det verkar som om det kontrolleras om numret är delbart med en uppsättning specifika divisorer istället för att ta alla siffror upp till det andra magiska värdet bestämt av intval (sqrt ($ num)). Kanske kan vi byta namn $ pf in i $ delare.
funktionen är Premium ($ num, $ divisors = null) if (! is_array ($ divisors)) return checkDivisorsBetween (2, intval (sqrt ($ num)), $ num); annars return checkDivisorsBetween (0, count ($ divisors), $ num, $ divisors); funktionskontrollDivisorerBetween ($ start, $ end, $ num, $ divisors = null) for ($ i = $ start; $ i < $end; $i++) if (isDivisible($num, $divisors ? $divisors[$i] : $i)) return false; return true;
Detta är ett sätt att göra det. Vi lade till en ytterligare valfri parameter till vår kontrollmetod. Om det har ett värde använder vi det, annars använder vi $ i.
Kan vi extrahera något annat? Vad sägs om den här koden: intval (sqrt ($ num))?
funktionen är Premium ($ num, $ divisors = null) if (! is_array ($ divisors)) return checkDivisorsBetween (2, integerRootOf ($ num), $ num); annars return checkDivisorsBetween (0, count ($ divisors), $ num, $ divisors); funktion integerRootOf ($ num) return intval (sqrt ($ num));
Är inte det bättre? Något. Det är bättre om den som kommer efter oss inte vet vad intval () och sqrt () gör det, men det hjälper inte att göra logiken lättare att förstå. Varför avslutar vi vår för slinga vid det specifika numret? Kanske är det här frågan vårt funktionsnamn ska svara på.
[PHP] // Kontrollera om ett tal är den främsta funktionen är Prime ($ num, $ divisors = null) if (! Is_array ($ divisors)) return checkDivisorsBetween (2, highestPossibleFactor ($ num), $ num); annars return checkDivisorsBetween (0, count ($ divisors), $ num, $ divisors); funktion highestPossibleFactor ($ num) return intval (sqrt ($ num)); [PHP]
Det är bättre som det förklarar varför vi slutar där. Kanske i framtiden kan vi uppfinna en annan formel för att bestämma det numret. Namngivningen introducerade också en liten inkonsekvens. Vi kallade talfaktorerna, vilket är en synonym för divisorer. Kanske borde vi välja en och bara använda det. Jag låter dig göra omprövningen som en övning.
Frågan är, kan vi extrahera längre? Tja, vi måste försöka tills vi släpper. Jag nämnde PHP: s funktionella programmeringssida några stycken ovan. Det finns två huvudsakliga funktionella programmeringsegenskaper som vi enkelt kan tillämpa i PHP: förstklassiga funktioner och rekursion. När jag ser en om uttalande med a lämna tillbaka inuti a för slinga, som i vår checkDivisorsBetween () metod, jag tänker på att tillämpa en eller båda teknikerna.
funktion checkDivisorsBetween ($ start, $ end, $ num, $ divisors = null) for ($ i = $ start; $ i < $end; $i++) if (isDivisible($num, $divisors ? $divisors[$i] : $i)) return false; return true;
Men varför ska vi gå igenom en så komplex tankeprocess? Den mest irriterande orsaken är att den här metoden gör två olika saker: det cyklar och det bestämmer. Jag vill att den bara ska cykla och lämna beslutet till en annan metod. En metod ska alltid göra en enda sak och göra det bra.
funktion $ ($ num, $ divisor) if (isDivisible ($ num, $ divisor)) return false; ; för ($ i = $ start; $ i < $end; $i++) $numberIsNotPrime($num, $divisors ? $divisors[$i] : $i); return true;
Vårt första försök var att extrahera villkoret och avkastningen i en variabel. Detta är lokalt, för tillfället. Men koden fungerar inte. Egentligen för loop komplicerar saker ganska. Jag har en känsla av att en liten rekursion kommer att hjälpa.
funktion checkRecursiveDivisibility ($ current, $ end, $ num, $ divisor) om ($ current == $ end) return true;
När vi tänker på rekursivitet måste vi alltid börja med de exceptionella fallen. Vårt första undantag är när vi når slutet av vår rekursion.
funktion checkRecursiveDivisibility ($ current, $ end, $ num, $ divisor) om ($ current == $ end) return true; om (isDivisible ($ num, $ divisor)) return false;
Vår andra exceptionella fall som kommer att bryta rekursionen är när numret är delbart. Vi vill inte fortsätta. Och det handlar om alla exceptionella fall.
ini_set ('xdebug.max_nesting_level', 10000); funktion checkDivisorsBetween ($ start, $ end, $ num, $ divisors = null) return checkRecursiveDivisibility ($ start, $ end, $ num, $ divisors); funktion checkRecursiveDivisibility ($ current, $ end, $ num, $ divisors) om ($ current == $ end) return true; om (isDivisible ($ num, $ divisors? $ divisors [$ current]: $ current)) return false; checkRecursiveDivisibility ($ current ++, $ end, $ num, $ divisors); Detta är ett annat försök att använda rekursion för vårt problem, men tyvärr återkommer 10 000 gånger i PHP till en krasch av PHP eller PHPUnit på mitt system. Så det verkar vara ett annat slut. Men om det skulle ha fungerat skulle det ha varit en bra ersättning för den ursprungliga logiken.
Utmaning
När jag skrev den gyllene mästaren, förbisedde jag med avsikt något. Låt oss bara säga att testen inte täcker så mycket kod som de borde. Kan du upptäcka problemet? Om ja, hur skulle du närma dig den?
Slutgiltiga tankar
"Extract till you drop" är ett bra sätt att dissekera långa metoder. Det tvingar dig att tänka på små bitar av kod och att ge bitarna ett syfte genom att extrahera dem till metoder. Jag tycker att det är fantastiskt hur det här enkla förfarandet, tillsammans med frekvent byte namn, kan hjälpa mig att upptäcka att någon kod gör saker som jag aldrig trodde var möjligt.
I vår nästa och sista handledning om refactoring kommer vi att tillämpa denna teknik på trivia-spelet. Jag hoppas att du gillade den här handledningen som visade sig vara lite annorlunda. I stället för att prata i läroboksexemplar tog vi en riktig kod och vi måste kämpa med de verkliga problemen vi möter varje dag.
Share
Accentsconagua
