Aller au contenu
Encyclopédie informatique Édition 2026

Les fonctions

Partie 2 sur 6

Niveau de lecture :

3Les paramètres et les arguments

Il est possible de passer des arguments, aussi appelés paramètres, à une fonction, c’est-à-dire de lui fournir une valeur ou le nom d’une variable afin qu’elle puisse effectuer des opérations sur ces valeurs, ou grâce à elles. On emploie souvent les deux mots sans les distinguer. Dans l’usage rigoureux, on les distingue : le paramètre est le nom écrit dans la définition (largeur), l’argument est la valeur fournie à l’appel (4). Le premier est une case vide ; le second est ce que l’on y met.

3.1Respecter le nombre et l’ordre

Le passage d’arguments se fait au moyen d’une liste d’arguments, séparés par des virgules, placée entre parenthèses juste après le nom de la fonction. Elle doit correspondre à celle de la définition : le nombre et le type doivent concorder, au risque, sinon, de générer une erreur lors de la compilation. L’ordre compte : aire_rectangle(4, 3) associe 4 à largeur et 3 à hauteur. Pour une multiplication, l’ordre ne change rien ; pour une soustraction ou une division, il change tout. Dans les langages qui vérifient avant l’exécution (C, C++, Java), un argument de trop ou de moins arrête la compilation. Dans les langages plus souples (JavaScript, PHP, Python), l’erreur apparaît à l’exécution, ou, pire, passe inaperçue : en JavaScript, un paramètre manquant vaut simplement undefined (« non défini »).

3.2La correspondance des types

En C, C++ et Java, chaque paramètre a un type (entier, nombre décimal, texte…) et l’argument doit lui correspondre. Si l’on passe un texte à une fonction qui attend un entier, le compilateur refuse. Ce contrôle est une aide précieuse : il attrape des erreurs avant même que le programme ne tourne. Les langages plus récents ont montré qu’on pouvait avoir le beurre et l’argent du beurre : TypeScript (voir TypeScript) ajoute des types à JavaScript, Python accepte des « annotations de type » vérifiées par des outils, et Rust (voir Rust) ou Go (voir Go) font vérifier les types par le compilateur, tout en déduisant ceux que l’on ne précise pas.

3.3Les valeurs par défaut

Il arrive souvent que l’on passe presque toujours la même valeur. Pour simplifier les appels d’une fonction dont un paramètre varie peu, certains langages permettent de déclarer des valeurs par défaut. Le C++ et PHP le permettent depuis longtemps ; c’est aujourd’hui possible en Python, JavaScript, PHP, C++ et dans bien d’autres. Exemple en Python :

def saluer(prenom, formule="Bonjour"):
    return formule + ", " + prenom + " !"

saluer("Momo")                  # "Bonjour, Momo !"
saluer("Léa", "Salut")          # "Salut, Léa !"

Une règle de bon sens, valable partout : les paramètres avec valeur par défaut se placent à la fin de la liste, après ceux qui sont obligatoires (« les derniers de la liste, ceux le plus à droite »). En C++, un détail propre au langage : ces valeurs ne sont écrites que dans le prototype (partie 6), pas dans la définition, sous peine d’erreur.

Ces valeurs ont un piège connu en Python : si la valeur par défaut est une liste, elle est créée une seule fois et partagée entre tous les appels ; on utilise alors la valeur « rien » (None) et l’on crée la liste dans la fonction. Les arguments nommés (saluer(prenom="Léa", formule="Salut")) sont une autre amélioration : l’ordre n’a plus d’importance et l’appel se lit tout seul.

3.4Passer une valeur ou passer une référence

Que fait la fonction de l’argument qu’elle reçoit ? Deux comportements existent. Dans le passage par valeur, la fonction reçoit une copie : elle peut la modifier à sa guise, la variable de départ ne bouge pas. Dans le passage par référence, la fonction reçoit l’emplacement de la variable d’origine : si elle la modifie, le changement se voit à l’extérieur. En PHP, en faisant précéder le paramètre du caractère &, on précise qu’il s’agit d’un alias : la valeur de la variable est modifiée à la sortie de la fonction. On parle alors de passage par référence : on passe la référence, c’est-à-dire l’adresse mémoire de la variable, à la fonction. C’est la raison pour laquelle le caractère & n’a pas sa place dans un nom de fonction : il a ce rôle-là.

function ajouter_un(&$compteur) {
    $compteur = $compteur + 1;
}
$n = 5;
ajouter_un($n);       // $n vaut maintenant 6

En C, on obtient le même effet en passant l’adresse (un « pointeur », voir le langage C) ; en C++, la référence s’écrit aussi avec & dans le type. En Java et en Python, la situation est plus subtile : on passe toujours une copie de la « poignée » vers l’objet. Si l’objet est modifiable (une liste, un tableau), la fonction peut le changer ; si elle réaffecte simplement la variable, l’extérieur ne le voit pas. Les fonctions qui modifient leurs arguments surprennent le lecteur ; on les évite quand c’est possible, en renvoyant plutôt un résultat.

Notons enfin que les arguments peuvent être de simples variables, mais aussi des tableaux ou des objets : une fonction peut recevoir une liste entière, une fiche d’élève, un autre ensemble de données.

3.5Une fonction vaut mieux que dix : paramétrer

Un exemple en JavaScript est à retenir. Pour afficher un texte différent selon le lien cliqué, la méthode de base consiste à écrire une fonction par texte : AfficheTexte1(), AfficheTexte2()… Il existe toutefois une méthode « plus classe » : créer une seule fonction qui prend le texte en paramètre, et l’appeler avec des arguments différents (Affiche('Texte1'), Affiche('Texte2')). Le résultat est visuellement identique, mais le code ne contient plus qu’une fonction au lieu de dix. Le réflexe à acquérir : dès que deux fonctions se ressemblent beaucoup, cherchez ce qui change et faites-en un paramètre.

3.6Un nombre variable d’arguments

Certaines fonctions doivent accepter un nombre quelconque de valeurs, comme une fonction qui additionne tout ce qu’on lui donne. Python écrit def somme(*valeurs):, JavaScript function somme(...valeurs), PHP function somme(...$valeurs), Java int somme(int... valeurs). À l’intérieur, valeurs se comporte comme une liste.

4Renvoyer une valeur

La fonction peut renvoyer une valeur, et donc se terminer, grâce au mot-clé return. Lorsque l’instruction return est rencontrée, la fonction évalue la valeur qui la suit, puis la renvoie au programme appelant (le programme à partir duquel la fonction a été appelée). C’est ce qui permet d’écrire surface = aire_rectangle(4, 3) : la valeur rendue par return prend la place de l’appel.

4.1Un return arrête tout

Une fonction peut contenir plusieurs instructions return ; toutefois, c’est la première rencontrée qui provoque la fin de la fonction et le renvoi de la valeur qui la suit. Ce qui reste après est ignoré. Exemple, qui renvoie le plus grand de deux nombres :

def plus_grand(a, b):
    if a > b:
        return a      # si a est le plus grand, on s'arrête ici
    return b          # sinon, on arrive ici

Écrire plusieurs return à des endroits utiles rend souvent le code plus lisible : on traite d’abord les cas simples et on sort aussitôt (« sortie anticipée »).

4.2Le type du retour

En C, C++ et Java, le type de valeur retourné doit correspondre à celui précisé dans la définition : une fonction déclarée int ne renvoie pas un texte. Si elle ne renvoie rien, on la fait précéder du mot-clé void. Le C++ impose cette précision, et Java aussi : une méthode doit obligatoirement porter un type de retour, avec une seule exception, les constructeurs (des méthodes spéciales qui créent un objet, voir la programmation orientée objet). Un conseil ancien est à ne plus suivre : en C, si aucun type de donnée n’est précisé, le type int est pris par défaut. On jugeait cela « très vilain », et c’était justifié : cette règle a été supprimée du langage en 1999 (norme C99), et les compilateurs actuels la refusent ou la signalent. Précisez toujours le type.

Dans les langages sans type obligatoire, une fonction qui n’a pas de return renvoie une valeur « vide » (None en Python, undefined en JavaScript, null en PHP). Il est donc facile d’oublier le return et de se retrouver avec une variable vide : une des erreurs les plus courantes.

4.3Rendre plusieurs valeurs

Le return ne renvoie qu’une valeur. Quand une fonction doit en rendre plusieurs, la solution simple, en PHP, est d’utiliser un tableau. C’est encore la voie générale : on renvoie une liste, un tableau, une structure ou un objet qui contient les différents résultats. Python permet d’écrire return minimum, maximum (en fait, un couple, que l’on peut défaire à l’arrivée : bas, haut = bornes(valeurs)). Go renvoie nativement plusieurs valeurs, ce qu’il utilise pour signaler les erreurs : resultat, erreur := lire(fichier). Rust renvoie des couples ou des énumérations.

4.4Les erreurs

Que renvoyer quand le calcul est impossible (division par zéro, fichier absent) ? Trois traditions coexistent. Une valeur spéciale (-1, null), simple mais ambiguë. Un code d’erreur en plus du résultat (Go). Une exception, signal qui interrompt la fonction et remonte jusqu’à un endroit prévu pour la traiter (Java, Python, JavaScript, PHP, C++). Rust utilise des types particuliers qui obligent à traiter le cas d’échec. Quel que soit le choix, documentez-le : celui qui appelle doit savoir ce qui peut arriver.

Pour s’exercer

Exercice 2 : écrire une fonction

Écrivez en Python une fonction ttc(prix, taux) qui renvoie le prix toutes taxes comprises, avec un taux par défaut de 20 (pour cent). Que renvoient ttc(100) et ttc(100, 5.5) ?

Voir la réponse

def ttc(prix, taux=20):
    return prix * (1 + taux / 100)

ttc(100) renvoie 120,0 ; ttc(100, 5.5) renvoie 105,5. Le paramètre à valeur par défaut est bien placé en dernier.