Factorisation du code et fonctions

Quand on débute en programmation, on écrit souvent des blocs de code qui se ressemblent. On copie, on colle, on modifie un petit détail, et on avance. Ça fonctionne… jusqu’à ce que l’on doive tout corriger à plusieurs endroits.

C’est là qu’entre en jeu une idée essentielle : factoriser son code. Factoriser, c’est éviter les répétitions inutiles. C’est rendre le code plus lisible, plus robuste et plus simple à maintenir.

Et pour y parvenir, l’outil le plus puissant qu’on ait à disposition, c’est la fonction. Créer une fonction, c’est regrouper des instructions qu’on pourra ensuite appeler à volonté, sans tout réécrire.

Cet article t’explique pas à pas pourquoi et comment factoriser ton code, comment créer tes premières fonctions, et comment structurer ton raisonnement pour écrire du code réutilisable et élégant :

• Pourquoi factoriser son code ?
• Identifier les répétitions à factoriser
• Qu’est ce qu’une fonction ?
• Créer une fonction pas à pas
• Bien nommer et organiser ses fonctions
• Le retour des valeurs et la portée des variables
• Fonctions natives à chaque langage

Pourquoi factoriser son code ?

Le problème de la répétition de code

Écrire deux fois la même chose, c’est rarement une bonne idée.

Prenons un exemple simple : afficher un message de bienvenue pour différents utilisateurs. Si on écrit à chaque fois les mêmes instructions, le code devient long, redondant et difficile à modifier.

Un jour, on voudra changer une phrase, un mot ou un calcul… et il faudra le faire partout. C’est le genre de petite erreur qui sème la pagaille dans un programme plus grand.

Bénéfices de la factorisation de code

Factoriser, c’est donc rassembler ce qui se répète pour n’en garder qu’une seule version.
Le code devient plus court, plus propre, et plus cohérent.

Les avantages sont nombreux :

• Lisibilité : on comprend plus vite ce que fait le programme.
• Maintenance : une seule modification suffit à tout mettre à jour.
• Évolutivité : on peut faire évoluer le code sans craindre de casser d’autres parties.

C’est le cœur du principe DRY (Don’t Repeat Yourself), qu’on peut traduire par : “ne te répète pas”.

C’est un réflexe de développeur·euse qui rend le code plus professionnel, même sur de petits projets.

Exemples de code

PHP

echo "Bonjour Alice, comment vas-tu ?";
echo "Bonjour Tom, comment vas-tu ?";
echo "Bonjour Chloé, comment vas-tu ?";

// On peut factoriser en créant 2 variables et ainsi éviter les répétitions
$start = "Bonjour";
$end = "comment vas-tu ?";

echo "$start Alice, $end";
// ...

Python

print("Bonjour Alice, comment vas-tu ?")
print("Bonjour Tom, comment vas-tu ?")
print("Bonjour Chloé, comment vas-tu ?")

# On peut factoriser en créant 2 variables et ainsi éviter les répétitions
start = "Bonjour"
end = "comment vas-tu ?"

print(f"{start} Alice, {end}")
print(f"{start} Tom, {end}")
print(f"{start} Chloé, {end}")

JavaScript

console.log("Bonjour Alice, comment vas-tu ?");
console.log("Bonjour Tom, comment vas-tu ?");
console.log("Bonjour Chloé, comment vas-tu ?");

// On peut factoriser en créant 2 variables et ainsi éviter les répétitions
let start = "Bonjour";
let end = "comment vas-tu ?";

console.log(`${start} Alice, ${end}`);
console.log(`${start} Tom, ${end}`);
console.log(`${start} Chloé, ${end}`);

Identifier les répétitions à factoriser

Avant de factoriser, il faut d’abord savoir ce qui se répète.

Les répétitions peuvent être évidentes : une même opération mathématique, un même affichage, une vérification récurrente. Mais parfois, elles sont plus subtiles : des blocs de code similaires mais pas identiques, où seule une donnée change.

Le réflexe à adopter : quand on écrit deux fois presque la même chose, on se demande s’il n’y a pas moyen d’extraire ce bloc et de le rendre réutilisable.

Un outil puissant pour la factorisation et l’organisation du code en général est la fonction.

Qu’est ce qu’une fonction ?

Une fonction, c’est un bloc d’instructions qu’on regroupe sous un nom, pour pouvoir l’utiliser plusieurs fois sans tout réécrire.

On lui donne des paramètres (les éléments qu’elle doit utiliser), elle exécute un traitement, puis elle peut renvoyer un résultat.

On peut la voir comme une petite machine :

On lui donne des entrées → elle effectue des calculs → elle renvoie une sortie.

Exemple concret : une fonction qui calcule la moyenne de deux nombres. On lui passe les deux nombres, elle fait l’opération, et elle renvoie le résultat.

Créer une fonction pas à pas

Structure générale

Quel que soit le langage, une fonction suit toujours la même logique :

1. On déclare la fonction (on lui donne un nom).
2. On définit les paramètres (les valeurs qu’elle recevra).
3. On écrit les instructions qu’elle doit exécuter.
4. On retourne une valeur.

Paramètres

Les paramètres rendent une fonction flexible.

Au lieu de répéter le même code pour chaque situation, on modifie simplement les valeurs passées à la fonction.

Exemples de code

On va reprendre l’exemple du début de l’article et factoriser le code grâce à une fonction.

PHP

function phraseBienvenue(string $prenom): string
{
   return "Bonjour $prenom, comment vas-tu ?";
}

// Et on utilise la fonction de cette façon : 
echo phraseBienvenue("Alice");
echo phraseBienvenue("Bob");
echo phraseBienvenue("Chloé");
// C'est la même fonction, appelée avec 3 paramètres différents

Python

def phrase_bienvenue(prenom):
    return f"Bonjour {prenom}, comment vas-tu ?"

# Et on utilise la fonction de cette façon :
print(phrase_bienvenue("Alice"))
print(phrase_bienvenue("Bob"))
print(phrase_bienvenue("Chloé"))
# C'est la même fonction, appelée avec 3 paramètres différents

JavaScript

function phraseBienvenue(prenom) {
    return `Bonjour ${prenom}, comment vas-tu ?`;
}

// Et on utilise la fonction de cette façon :
console.log(phraseBienvenue("Alice"));
console.log(phraseBienvenue("Bob"));
console.log(phraseBienvenue("Chloé"));
// C'est la même fonction, appelée avec 3 paramètres différents

Plus de paramètres, plus de complexité dans une fonction

Une fonction peut recevoir plusieurs paramètres et effectuer plusieurs opérations. Tous les concepts clés de la programmation peuvent être utilisés au sein d’une fonction. Voici un exemple d’une fonction un peu plus complexe pour illustrer :

PHP

function phraseBienvenue(string $prenom, int $age): string
{
    if ($age < 18) {
        return "Salut $prenom, tu es encore jeune à $age ans !";
    } else {
        return "Bonjour $prenom, ravi de te revoir à $age ans.";
    }
}

Python

def phrase_bienvenue(prenom, age):
    if age < 18:
        return f"Salut {prenom}, tu es encore jeune à {age} ans !"
    else:
        return f"Bonjour {prenom}, ravi de te revoir à {age} ans."

JavaScript

function phraseBienvenue(prenom, age) {
    if (age < 18) {
        return `Salut ${prenom}, tu es encore jeune à ${age} ans !`;
    } else {
        return `Bonjour ${prenom}, ravi de te revoir à ${age} ans.`;
    }
}

Bien nommer et organiser ses fonctions

Donner des noms clairs

Le nom d’une fonction doit toujours exprimer ce qu’elle fait.

On évite les abréviations ou les noms vagues : “f1”, “calcul1”, “traitementFinal” ne disent rien.

Un bon nom est un verbe d’action clair et précis :

• afficherResultat()
• calculerMoyenne()
• verifierMotDePasse()

C’est une règle simple, mais elle change tout pour la compréhension du code.

Découper un programme en plusieurs fonctions

Au lieu d’écrire un grand bloc de code de 100 lignes, il vaut mieux découper son programme en plusieurs petites parties.

Chaque petite partie sera une fonction avec un rôle clair : elle fait une seule chose, mais elle le fait bien.

C’est un peu comme construire avec des briques de Lego : chaque brique a sa forme et sa fonction, et on peut les assembler facilement.

Grâce à ce découpage, ton code devient plus simple à lire, plus facile à tester et plus pratique à réutiliser plus tard.

Le retour des valeurs et la portée des variables

Les valeurs de retour

Une fonction peut renvoyer un résultat grâce à une instruction spéciale (return). Ce résultat peut ensuite être réutilisé ailleurs dans le programme.

L’idée est simple : une fonction calcule quelque chose, puis donne ce résultat au reste du code.

Exemples de code

PHP

function prixApresRemise(float $prix, float $remise)
{
    // Calcule le prix après remise et le renvoie
    return $prix - ($prix * $remise / 100);
}

// On utilise le résultat de la fonction dans une autre partie du programme
$prixFinal = prixApresRemise(100, 10); // 10% de remise
$totalAvecFrais = $prixFinal + 5; // On ajoute 5€ de frais de port

echo "Le montant total à payer est de $totalAvecFrais €.";

Python

def prix_apres_remise(prix, remise):
    # Calcule le prix après remise et le renvoie
    return prix - (prix * remise / 100)

# On utilise le résultat de la fonction dans une autre partie du programme
prix_final = prix_apres_remise(100, 10)  # 10% de remise
total_avec_frais = prix_final + 5  # On ajoute 5€ de frais de port

print(f"Le montant total à payer est de {total_avec_frais} €.")

JavaScript

function prixApresRemise(prix, remise) {
    // Calcule le prix après remise et le renvoie
    return prix - (prix * remise / 100);
}

// On utilise le résultat de la fonction dans une autre partie du programme
let prixFinal = prixApresRemise(100, 10); // 10% de remise
let totalAvecFrais = prixFinal + 5; // On ajoute 5€ de frais de port

console.log(`Le montant total à payer est de ${totalAvecFrais} €.`);

Portée des variables

Point très important, qui crée souvent des erreurs dans les premiers programmes écrits, il ne faut pas confondre variables et paramètres, variables de la fonction et variables du programme principal.

C’est ce qu’on appelle la portée locale. Les variables créées à l’intérieur d’une fonction n’existent que dans cette fonction. Cela permet d’éviter les interférences : deux fonctions peuvent utiliser des variables du même nom sans se gêner. Mais il faut faire attention à ne pas s’emmêler les pinceaux entre les variables des fonctions et les variables du programme principal.

Exemples de code

• « compteur » existe à deux endroits différents
• le « compteur » paramètre récupère la valeur de la variable mais techniquement, malgré un nom identique, n’a rien à voir avec la variable du programme principal
• Quand on modifie « compteur » dans le fonction, on ne modifie en rien le « compteur » du programme principal

PHP

$compteur = 10; // variable du programme principal
echo "En dehors de la fonction : $compteur"; // Affiche "10"

function incrementer($compteur)
{
    $compteur = $compteur + 1; // variable locale (paramètre)
    echo "Dans la fonction : $compteur"; // Affiche "11"
}

incrementer($compteur);
echo "En dehors de la fonction : $compteur"; // Affiche toujours "10"

Python

compteur = 10  # variable du programme principal
print("En dehors de la fonction :", compteur)  # Affiche "10"

def incrementer(compteur):
    compteur = compteur + 1  # variable locale (paramètre)
    print("Dans la fonction :", compteur)  # Affiche "11"

incrementer(compteur)
print("En dehors de la fonction :", compteur)  # Affiche toujours "10"

JavaScript

let compteur = 10; // variable du programme principal
console.log("En dehors de la fonction :", compteur); // Affiche "10"

function incrementer(compteur) {
    compteur = compteur + 1; // variable locale (paramètre)
    console.log("Dans la fonction :", compteur); // Affiche "11"
}

incrementer(compteur);
console.log("En dehors de la fonction :", compteur); // Affiche toujours "10"

Fonctions natives à chaque langage

Avant de créer ses propres fonctions, il est utile de savoir que tous les langages de programmation proposent déjà des fonctions toutes prêtes.

Elles permettent de faire rapidement des calculs, des conversions, des manipulations de texte, des opérations sur les listes et tableaux et bien d’autres choses encore !

Ces fonctions sont dites natives ou intégrées : elles font partie du langage lui-même. Il est primordial de les utiliser pour ne pas avoir à recoder des éléments de logique qui existeraient déjà de base dans le langage.

Exemples de code

PHP

strlen("Bonjour"); // renvoie la longueur d'une chaîne : 7
strtoupper("bonjour"); // renvoie une chaine en majuscules, ici "BONJOUR"
round(12.34); // renvoie l'arrondi, ici 12

Python

len("Bonjour") # renvoie la longueur d'une chaîne : 7
"bonjour".upper() # renvoie une chaine en majuscules, ici "BONJOUR"
round(12.34) # renvoie l'arrondi, ici 12

JavaScript

"Bonjour".length; // renvoie la longueur d'une chaîne : 7 (ici ce n'est pas une fonction, mais une "propriété d'un tableau"
"bonjour".toUpperCase(); // renvoie une chaine en majuscules, ici "BONJOUR"
Math.round(12.34); // renvoie l'arrondi, ici 12

Conclusion

Factoriser son code, c’est apprendre à penser avant d’écrire. C’est reconnaître les répétitions, isoler ce qui se répète, et en faire quelque chose de plus simple, de plus élégant.

Les fonctions sont le premier grand outil de cette démarche : elles permettent de donner un nom aux actions, de structurer les idées et de réutiliser son travail.

Elles transforment un code “bricolé” en un code organisé et pérenne.

Avec un peu d’habitude, ce réflexe devient naturel : dès qu’un bloc se répète, on se dit “tiens, et si j’en faisais une fonction !”.