T: / Articles techniques / PHP
Bonnes pratiques pour bien organiser le code de ses premiers algorithmes en PHP.
En algorithmie, et en programmation d’une manière générale, adopter de bonnes pratiques est essentiel pour concevoir des algorithmes clairs, efficaces et faciles à comprendre. Cela facilite non seulement la lecture et la maintenance du code mais également la collaboration avec d’autres membres de son équipe.
Si tu as déjà beaucoup codé, cette liste te paraitra peut être « évidente » ou « triviale », mais il y a sans doute quelques éléments à découvrir et n’hésite pas à la voir comme une check list à garder en tête pendant que tu codes 😉
On alternera à chaque fois un bout de code et les explications qui vont avec (cet article étant écrit juste après les JO de Paris 2024, on va utiliser le thème du sport dans les exemples).
Voici donc 9 bonnes pratiques en PHP :
// Mauvais exemple
$a = 90;
$b = 45;
$c = $a - $b;
// Bon exemple
$totalMatchTime = 90;
$halfTimeDuration = 15;
$effectivePlayTime = $totalMatchTime - $halfTimeDuration;
Explications :
En utilisant des noms de variables explicites, ton code devient plus lisible et facile à comprendre. Dans le bon exemple, les noms $totalMatchTime, $halfTimeDuration et $effectivePlayTime décrivent clairement leur rôle, ce qui facilite la compréhension du code pour toi et pour les autres.
Il n’y a ni limite ni besoin d’abréviation lorsqu’on nomme une variable, une fonction, une classe, une méthode, etc.
// Mauvais exemple
$circleArea = 3.14159 * $radius * $radius;
// Bon exemple
define('PI', 3.14159);
$circleArea = PI * $radius * $radius;
Explications :
Les constantes te permettent de définir des valeurs fixes et sont réutilisables facilement et partout dans le scope de ton programme. En définissant PI, tu évites les erreurs liées à la réécriture de la valeur et facilites les modifications ultérieures.
// Mauvais exemple (utilisation de while pour un nombre connu d'itérations)
$i = 0;
while ($i < 11) {
echo "Joueur numéro " . $i . "\n";
$i++;
}
// Bon exemple (utilisation de for pour un nombre connu d'itérations)
for ($i = 0; $i < 11; $i++) {
echo "Joueur numéro " . $i . "\n";
}
Explications :
Choisir la boucle appropriée rend ton code plus clair et plus efficace. Utilise une boucle for
lorsque tu connais à l’avance le nombre d’itérations. D’autant qu’une boucle while peut entrainer une boucle infinie !
Si tu maitrises les callables, tu peux aussi te passer des boucles en utilisant des fonctions comme array_map mais attention à garder ton code lisible !
// Mauvais exemple
function checkQualification(int $score): string
{
if ($score >= 10) {
echo "Tu es qualifié.e pour la finale.";
} else {
echo "Tu n'es pas qualifié.e.";
}
}
// Bon exemple
function checkQualification(int $score): string
{
if ($score < 10) {
echo "Tu n'es pas qualifié.e.";
return;
}
echo "Tu es qualifié.e pour la finale.";
}
Explications :
En éliminant les else
inutiles, tu simplifies ton code et le rends plus lisible. En retournant ou en sortant de la fonction dès que possible, tu évites les conditions imbriquées et facilites la compréhension du flux logique.
Il y a encore d’autres façons d’éliminer les else en PHP.
// Mauvais exemple
$athlete1SpeedKmH = (100 / 9.58) * 3.6;
$athlete2SpeedKmH = (100 / 9.80) * 3.6;
// Bon exemple
function calculateSpeedKmH($distanceMeters, $timeSeconds) {
return ($distanceMeters / $timeSeconds) * 3.6;
}
$athlete1SpeedKmH = calculateSpeedKmH(100, 9.58);
$athlete2SpeedKmH = calculateSpeedKmH(100, 9.80);
Explications :
En créant des fonctions pour les opérations répétitives, tu rends ton code plus modulable et facile à maintenir. Dans cet exemple, la fonction calculateSpeedKmH
te permet de calculer la vitesse en km/h de n’importe quel athlète en fonction de la distance et du temps, sans répéter le calcul à chaque fois !
Pas d’exemple de code ici.
Le but n’est pas de commenter pour commenter mais de prendre le temps d’écrire les commentaires avant de coder, pour expliciter la portion de code qui arrive, à quoi elle sert, comment elle fonctionne, etc. Cela permet d’écrire le plan du code à produire, avant de le produire !
J’en parle dans la vidéo : méthodologie pour résoudre un challenge de code (à partir de 4min27)
// Mauvais exemple (fonction monolithique qui fait à boire et à manger)
function getTeamStatistics(array $team)
{
$totalPoints = 0;
$totalAssists = 0;
foreach ($team as $player) {
$totalPoints += $player['points'];
$totalAssists += $player['assists'];
}
$averagePoints = $totalPoints / count($team);
$averageAssists = $totalAssists / count($team);
echo "Points moyens par joueur : $averagePoints\n";
echo "Passes décisives moyennes par joueur : $averageAssists\n";
}
// Bon exemple (division en sous-fonctions)
function calculateTotal(array $team, string$stat): int
{
$total = 0;
foreach ($team as $player) {
$total += $player[$stat];
}
return $total;
}
function calculateAverage(int $total, int $count): float
{
// On devrait contrôler que count ne vaut pas zéro
return $total / $count;
}
function displayTeamStatistics(float $averagePoints, float $averageAssists)
{
echo "Points moyens par joueur : $averagePoints\n";
echo "Passes décisives moyennes par joueur : $averageAssists\n";
}
function getTeamStatistics(array $team)
{
$totalPoints = calculateTotal($team, 'points');
$totalAssists = calculateTotal($team, 'assists');
$averagePoints = calculateAverage($totalPoints, count($team));
$averageAssists = calculateAverage($totalAssists, count($team));
displayTeamStatistics($averagePoints, $averageAssists);
}
En divisant un problème complexe en sous-problèmes, tu rends ton code plus facile à gérer et à comprendre. Chaque fonction a une responsabilité spécifique, ce qui facilite les tests, car tu pourras tester les fonctions une par une et non tout le programme à la fois. C’est pareil pour la maintenance, tu vas pouvoir faire évoluer ou optimiser ton code portion par portion.
Tu peux retrouver des méthodes pour réfléchir au découpage d’un algorithme.
Pas d’exemple de code ici.
Le but est de rappeler que bien souvent, le diable se cache dans les détails ! Ou plutôt que les bugs se cachent dans les cas particuliers ! Alors prends le temps d’analyser ton code et de définir les cas principaux et, surtout, les cas particuliers qui te permettront de déterminer si ton code est correct ou non.
Par « cas », j’entends un ensemble de données cohérentes entre elles qui sont susceptibles d’être des paramètres d’entrée de ton code.
Et quand on parle de tests, on ne peut pas ne pas parler de tests unitaires. Donc n’hésite pas à découvrir ce que sont les tests unitaires. Ou à consulter nos corrigés en PHP qui en proposent régulièrement.
// Mauvais exemple (code condensé et peu lisible)
foreach($p as $a){$s += ($a['t']>2 ? $a['p'] : 0;)}
// Bon exemple (code clair et bien formaté)
$totalScore = 0;
foreach ($players as $athlete) {
if ($athlete['trophies'] > 2) {
$totalScore += $athlete['points'];
}
}
Explications :
L’exemple ici est un peu extrême ! Mais fais attention aux ternaires qui s’enchainent, aux conventions non respectées, aux variables mal nommées, etc. Sur l’instant, le code parait clair et intelligent… mais quand on revient dessus quelques jours plus tard, bien souvent on y comprend plus rien !
En plus des liens disséminés dans l’article, voici d’autres contenus de Tainix qui te permettront de perfectionner ton code PHP :
Cet article existe également dans ses version Javascript et Python.
Other content to discover