Cela nous permettra de réutiliser le code dans la deuxième partie comme ceci:
else $ pfCount = count ($ pf); pour ($ i = 0; $ i<$pfCount;$i++) if(isDivisible($num, $pf[$i])) return false; return true;
Et dès que nous avons commencé à travailler avec ce code, nous avons constaté qu’il était mal aligné. Les accolades sont parfois au début de la ligne, d'autres fois à la fin.
Parfois, les tabulations sont utilisées pour l'indentation, parfois les espaces. Parfois, il y a des espaces entre l'opérande et l'opérateur, parfois non. Et non, ce n'est pas un code spécialement créé. Ceci est la vraie vie. Code réel, pas un exercice artificiel.
// Vérifie si un nombre est une fonction première isPrime ($ num, $ pf = null) if (! Is_array ($ pf)) pour ($ 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;
Cela semble mieux. Immédiatement les deux si les déclarations sont très similaires. Mais nous ne pouvons pas les extraire à cause de la revenir déclarations. Si nous ne revenons pas, nous briserons la logique.
Si la méthode extraite renvoie un booléen et que nous la comparons pour décider si nous devons ou non revenir de isPrime (), cela n'aiderait pas du tout. Il peut y avoir un moyen de l'extraire en utilisant des concepts de programmation fonctionnels en PHP, mais peut-être plus tard. Nous pouvons faire quelque chose de plus simple en premier.
fonction isPrime ($ num, $ pf = null) if (! is_array ($ pf)) return checkDivisorsBetween (2, intval (sqrt ($ num)), $ num); else $ pfCount = count ($ pf); pour ($ 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;
Extraire le pour la boucle dans son ensemble est un peu plus facile, mais lorsque nous essayons de réutiliser notre méthode extraite dans la deuxième partie de la si nous pouvons voir que cela ne fonctionnera pas. Il y a ce mystérieux $ pf variable à propos de laquelle nous ne savons presque rien.
Il semble que cela vérifie si le nombre est divisible par un ensemble de diviseurs spécifiques au lieu de prendre tous les nombres jusqu'à l'autre valeur magique déterminée par intval (sqrt ($ num)). Peut-être pourrions-nous renommer $ pf dans diviseurs $.
function isPrime ($ num, $ divisors = null) if (! is_array ($ divisors)) return checkDivisorsBetween (2, intval (sqrt ($ num)), $ num); else return checkDivisorsBetween (0, count ($ divisors), $ num, $ divisors); function checkDivisorsBetween ($ début, $ fin, $ num, $ diviseurs = null) pour ($ i = $ début; $ i < $end; $i++) if (isDivisible($num, $divisors ? $divisors[$i] : $i)) return false; return true;
C'est une façon de le faire. Nous avons ajouté un quatrième paramètre, facultatif, à notre méthode de vérification. S'il a une valeur, nous l'utilisons, sinon nous utilisons $ i.
Pouvons-nous extraire autre chose? Qu'en est-il de ce morceau de code: intval (sqrt ($ num))?
fonction isPrime ($ num, $ divisors = null) if (! is_array ($ divisors)) return checkDivisorsBetween (2, integerRootOf ($ num), $ num); else return checkDivisorsBetween (0, count ($ divisors), $ num, $ divisors); function integerRootOf ($ num) return intval (sqrt ($ num));
N'est-ce pas mieux? Quelque peu. C'est mieux si la personne qui vient après nous ne sait pas quoi intval () et sqrt () font, mais cela n’aide pas à rendre la logique plus facile à comprendre. Pourquoi finissons-nous notre pour boucle à ce nombre spécifique? C’est peut-être la question à laquelle notre nom de fonction devrait répondre.
[PHP] // Vérifie si un nombre est une fonction première isPrime ($ num, $ divisors = null) if (! Is_array ($ divisors)) return checkDivisorsBetween (2, mostPossibleFactor ($ num), $ num); else return checkDivisorsBetween (0, count ($ divisors), $ num, $ divisors); function mostPossibleFactor ($ num) return intval (sqrt ($ num)); [PHP]
C’est mieux, car cela explique pourquoi nous nous arrêtons là. Peut-être pourrions-nous, à l'avenir, inventer une formule différente pour déterminer ce nombre. La dénomination introduit également une petite incohérence. Nous avons appelé les facteurs de nombres, synonyme de diviseurs. Peut-être devrions-nous en choisir un et l'utiliser uniquement. Je vais vous laisser faire la refactorisation du renommage comme un exercice.
La question est, pouvons-nous extraire davantage? Eh bien, nous devons essayer jusqu'à ce que nous tombions. J'ai mentionné quelques paragraphes ci-dessus du côté de la programmation fonctionnelle de PHP. Il existe deux principales caractéristiques fonctionnelles de programmation que nous pouvons facilement appliquer en PHP: les fonctions de première classe et la récursion. Chaque fois que je vois un si déclaration avec un revenir à l'intérieur d'un pour boucle, comme dans notre checkDivisorsBetween () méthode, je pense appliquer une ou les deux techniques.
function checkDivisorsBetween ($ début, $ fin, $ num, $ diviseurs = null) pour ($ i = $ début; $ i < $end; $i++) if (isDivisible($num, $divisors ? $divisors[$i] : $i)) return false; return true;
Mais pourquoi devrions-nous passer par un processus de pensée aussi complexe? La raison la plus agaçante est que cette méthode fait deux choses distinctes: elle fait un cycle et décide. Je le veux seulement faire un cycle et laisser la décision à une autre méthode. Une méthode devrait toujours faire une seule chose et bien le faire.
function checkDivisorsBetween ($ start, $ end, $ num, $ divisors = null) $ numberIsNotPrime = fonction ($ num, $ divisor) if (isDivisible ($ num, $ divisor))) return false; ; pour ($ i = $ start; $ i < $end; $i++) $numberIsNotPrime($num, $divisors ? $divisors[$i] : $i); return true;
Notre première tentative a été d'extraire la condition et l'instruction return dans une variable. C'est local, pour le moment. Mais le code ne fonctionne pas. En fait le pour La boucle complique un peu les choses. J'ai le sentiment qu'un peu de récursivité aidera.
fonction checkRecursiveDivisibility ($ current, $ end, $ num, $ diviseur) if ($ current == $ end) return true;
Lorsque nous pensons à la récursivité, nous devons toujours commencer par les cas exceptionnels. Notre première exception est lorsque nous atteignons la fin de notre récursion.
fonction checkRecursiveDivisibility ($ current, $ end, $ num, $ diviseur) if ($ current == $ end) return true; if (isDivisible ($ num, $ divisor)) return false;
Notre deuxième cas exceptionnel qui rompra la récursivité est celui où le nombre est divisible. Nous ne voulons pas continuer. Et c'est à peu près tous les cas exceptionnels.
ini_set ('xdebug.max_nesting_level', 10000); function checkDivisorsBetween ($ start, $ end, $ num, $ divisors = null) return checkRecursiveDivisibility ($ start, $ end, $ num, $ divisors); function checkRecursiveDivisibility ($ actuel, $ fin, $ num, $ diviseurs) if ($ actuel == $ fin) return true; if (isDivisible ($ num, $ divisors? $ divisors [$ current]: $ current)) return false; checkRecursiveDivisibility ($ current ++, $ end, $ num, $ divisors); Ceci est une autre tentative d'utilisation de la récursivité pour notre problème, mais malheureusement, une répétition de 10.000 fois en PHP entraîne un crash de PHP ou PHPUnit sur mon système. Donc, cela semble être une autre impasse. Mais si cela avait fonctionné, cela aurait été un bon remplacement de la logique originale.
Défi
Quand j'ai écrit le Golden Master, j'ai délibérément oublié quelque chose. Disons simplement que les tests ne couvrent pas autant de code qu'ils le devraient. Pouvez-vous repérer le problème? Si oui, comment l'aborderiez-vous??
Dernières pensées
"Extraire jusqu'à épuisement" est un bon moyen de disséquer les méthodes longues. Cela vous oblige à réfléchir à de petits morceaux de code et à leur donner un but en les extrayant dans des méthodes. Je trouve incroyable de voir comment cette procédure simple, associée à un changement de nom fréquent, peut m'aider à découvrir que certains codes font des choses que je n'aurais jamais imaginées possibles..
Dans notre prochain et dernier tutoriel sur la refactorisation, nous appliquerons cette technique au jeu-questionnaire. J'espère que vous avez aimé ce tutoriel qui s'est avéré un peu différent. Au lieu de parler d'exemples de manuels, nous avons pris du vrai code et nous avons dû nous battre avec les vrais problèmes auxquels nous sommes confrontés chaque jour.
Share
Accentsconagua
