0Pricing
PHP Academy · Leçon

Paramètres par défaut et variadiques

Utilisez des valeurs par défaut et des arguments variadiques dans les fonctions PHP.

Paramètres par défaut et variadiques est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Valeurs de paramètres par défaut

Les valeurs par défaut permettent aux appelants d'omettre des arguments. La valeur par défaut est utilisée lorsque l'argument n'est pas transmis :

<?php
function createUser(string $name, string $role = 'viewer'): string {
    return "$name ($role)";
}

echo createUser('Alice');          // Alice (viewer)
echo createUser('Bob', 'admin');   // Bob (admin)

Règles des valeurs par défaut

Règles importantes concernant les paramètres par défaut :

  • Les paramètres avec des valeurs par défaut doivent venir après les paramètres obligatoires
  • Les valeurs par défaut doivent être des expressions constantes — pas des appels de fonction ni des variables
  • Les arguments nommés de PHP 8 assouplissent l'exigence d'ordre

Paramètres pouvant être NULL

Utilisez ?type pour autoriser NULL comme argument valide, avec NULL comme valeur par défaut :

<?php
function findUser(?int $id = null): string {
    if ($id === null) {
        return 'Searching all users';
    }
    return "User #$id";
}

echo findUser();    // Searching all users
echo findUser(42);  // User #42

Fonctions variadiques avec ...

Utilisez ... avant un paramètre pour accepter un nombre variable d'arguments sous forme de tableau :

<?php
function sum(int ...$numbers): int {
    return array_sum($numbers);
}

echo sum(1, 2, 3);        // 6
echo sum(10, 20, 30, 40); // 100

Paramètre variadique avec paramètres obligatoires

Vous pouvez mélanger des paramètres obligatoires avec un paramètre variadique à la fin :

<?php
function logMessage(string $level, string ...$messages): void {
    foreach ($messages as $msg) {
        echo "[$level] $msg" . PHP_EOL;
    }
}

logMessage('INFO', 'App started', 'Config loaded');

Opérateur de décomposition lors d'un appel

Utilisez ... lors de l'appel d'une fonction pour décomposer un tableau en arguments individuels :

<?php
function add3(int $a, int $b, int $c): int {
    return $a + $b + $c;
}

$args = [1, 2, 3];
echo add3(...$args);  // 6

$extra = [4, 5];
echo add3(1, ...$extra);  // 10

Arguments nommés (PHP 8)

Les arguments nommés permettent de transmettre des valeurs en indiquant le nom du paramètre, sans tenir compte de l'ordre :

<?php
function createTag(string $tag, string $content, string $class = ''): string {
    $cls = $class ? " class=\"$class\"" : '';
    return "<$tag$cls>$content</$tag>";
}

// Skip $class, pass $content by name
echo createTag(content: 'Hello', tag: 'p');
// <p>Hello</p>

Arguments nommés avec les fonctions intégrées

Les arguments nommés fonctionnent également avec les fonctions intégrées de PHP :

<?php
$arr = [3, 1, 4, 1, 5];

// Traditional positional
$result1 = array_slice($arr, 1, 3);

// Named arguments
$result2 = array_slice(array: $arr, offset: 1, length: 3);

print_r($result1); // [1, 4, 1]

func_get_args() dans l'ancien code

Avant l'apparition de la syntaxe variadique de PHP 5.6, func_get_args() était utilisé pour accéder à tous les arguments. Vous pouvez le rencontrer dans du code ancien :

<?php
function legacySum(): int {
    $args = func_get_args();
    return array_sum($args);
}

echo legacySum(1, 2, 3, 4);  // 10
// Modern: use int ...$numbers instead

Paramètre variadique avec indication de type

Combinez les indications de type avec des paramètres variadiques pour obtenir des entrées strictement typées :

<?php
declare(strict_types=1);

function joinStrings(string $sep, string ...$parts): string {
    return implode($sep, $parts);
}

echo joinStrings('-', 'a', 'b', 'c');  // a-b-c
// joinStrings('-', 'a', 42); // TypeError in strict mode

Combiner valeurs par défaut et arguments nommés

Les arguments nommés et les valeurs par défaut fonctionnent ensemble pour offrir une flexibilité maximale :

<?php
function sendEmail(
    string $to,
    string $subject,
    string $body = '',
    bool   $html  = false
): bool {
    // simulate send
    return true;
}

// Skip $body, pass $html by name
sendEmail('a@b.com', 'Hi', html: true);

Vérification rapide

Que fait l'opérateur ... dans la définition d'une fonction PHP ?

Récapitulatif : paramètres par défaut et variadiques

Résumé :

  • Les valeurs par défaut permettent d'utiliser des paramètres facultatifs
  • Les paramètres avec des valeurs par défaut viennent après les paramètres obligatoires
  • ?type permet d'utiliser NULL avec une valeur par défaut facultative
  • ...$args rassemble les arguments variadiques dans un tableau
  • L'opérateur de décomposition ...$arr développe un tableau au moment de l'appel
  • Les arguments nommés (PHP 8) sont transmis par leur nom, et non par leur position

Questions Fréquemment Posées

La leçon « Paramètres par défaut et variadiques » est-elle gratuite ?

Oui — le texte complet de « Paramètres par défaut et variadiques » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Paramètres par défaut et variadiques » ?

Utilisez des valeurs par défaut et des arguments variadiques dans les fonctions PHP. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Paramètres par défaut et variadiques » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Définir et appeler des fonctions
  2. Paramètres par défaut et variadiques
  3. Portée des variables : locale et globale
  4. Fonctions anonymes et fermetures
← Retour à PHP Academy