Une fonction peut être définie en utilisant la syntaxe suivante : ]]> Tout code PHP, correct syntaxiquement, peut apparaître dans une fonction et dans des définitions de classe. Les noms de fonctions suivent les mêmes règles que les autres labels en PHP. Un nom de fonction valide commence par une lettre ou un souligné, suivi par un nombre quelconque de lettres, de nombres ou de soulignés. Ces règles peuvent être représentées par l'expression rationnelle suivante : ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$ &tip.userlandnaming; Les fonctions n'ont pas besoin d'être définies avant d'être utilisées, SAUF lorsqu'une fonction est définie conditionnellement, comme montré dans les deux exemples suivants. Lorsqu'une fonction est définie de manière conditionnelle, comme dans les exemples ci-dessous, leur définition doit précéder leur utilisation. ]]> ]]> Toutes les fonctions et classes en PHP ont une portée globale - elles peuvent être appelées à l'extérieur d'une fonction si elles ont été définies à l'intérieur et vice-versa. PHP ne supporte pas la surcharge, la destruction et la redéfinition de fonctions déjà déclarées. Les noms de fonctions sont insensibles à la casse pour les caractères ASCII A à Z, et il est généralement admis que les fonctions doivent être appelées avec le nom utilisé dans leur déclaration, y compris la casse. Les listes variables d'arguments de fonction et les valeurs par défaut d'arguments sont supportés : voir les fonctions de références que sont func_num_args, func_get_arg, et func_get_args pour plus d'informations. Il est possible d'appeler des fonctions récursives en PHP. ]]> Les appels de méthodes/fonctions récursives avec 100-200 degrés de récursivité peuvent remplir la pile et ainsi, terminer le script courant. À noter qu'une récursion infinie est considérée comme une erreur de programmation. Des informations peuvent être passées à une fonction en utilisant une liste d'arguments, dont chaque expression est séparée par une virgule. Les arguments seront évalués depuis la gauche vers la droite, avant que la fonction soit actuellement appelée (évaluation immédiate). PHP supporte le passage d'arguments par valeur (comportement par défaut), le passage par référence, et des valeurs d'arguments par défaut. Une liste variable d'arguments, ainsi que les Arguments Nommés sont également supportés. ]]> À partir de PHP 8.0.0, la liste des arguments de fonction peut inclure une virgule trainante, qui sera ignoré. Ceci est particulièrement pratique dans les cas où la liste d'arguments est longue ou contient des noms de variables longs, le rendant pratique pour lister les arguments verticalement. ]]> Par défaut, les arguments sont passés à la fonction par valeur (aussi, changer la valeur d'un argument dans la fonction ne change pas sa valeur à l'extérieur de la fonction). Si vous voulez que vos fonctions puissent changer la valeur des arguments, vous devez passer ces arguments par référence. Si vous voulez qu'un argument soit toujours passé par référence, vous pouvez ajouter un '&' devant l'argument dans la déclaration de la fonction : ]]> C'est une erreur de passer une valeur en tant qu'argument qui est supposé d'être passé par référence. Une fonction peut définir des valeurs par défaut pour les arguments en utilisant une syntaxe similaire à l'affectation d'une variable. La valeur par défaut n'est utilisée que lorsque le paramètre n'est pas spécifié ; en particulier, notez que le passage de &null; n'assigne pas la valeur par défaut. ]]> &example.outputs; Les valeurs par défaut des paramètres peuvent être des valeurs scalaires, des &array;s, le type spécial &null;, et à partir de PHP 8.1.0, des objets utilisant la syntaxe new ClassName(). ]]> brew(); } echo makecoffee(); echo makecoffee(new FancyCoffeeMaker); ?> ]]> La valeur par défaut d'un argument doit obligatoirement être une constante, et ne peut être ni une variable, ni un membre de classe, ni un appel de fonction. Il est à noter que tous les arguments facultatifs doivent être spécifiés après les arguments obligatoires, sinon ils ne peuvent pas être omis dans les appels. Considérons le code suivant : ]]> &example.outputs; Maintenant comparons l'exemple précédent avec l'exemple suivant : ]]> &example.outputs; À partir de PHP 8.0.0, les arguments nommés peuvent être utilisées pour passer outre plusieurs paramètres optionnels. ]]> &example.outputs; À partir de PHP 8.0.0, déclarer des arguments obligatoires après des arguments optionnels est obsolète. Ce problème peut généralement être résolu en abandonnant la valeur par défaut, puisqu'elle ne sera jamais utilisée. Une exception à cette règle concerne les arguments de la forme Type $param = null, où le &null; par défaut rend le type implicitement nullable. Cet usage reste autorisé, bien qu'il soit recommandé d'utiliser un type nullable explicite à la place. ]]> À partir de PHP 7.1.0, l'omission d'un paramètre qui ne spécifie pas une valeur par défaut lance un ArgumentCountError ; dans les versions précédentes, cela levait un avertissement. Les arguments passés par référence peuvent avoir une valeur par défaut. PHP supporte les arguments à nombre variable dans les fonctions défini par l'utilisateur en utilisant le token .... Il est aussi possible d'accomplir les arguments à nombre variable en utilisant les fonctions func_num_args, func_get_arg, et func_get_args. Cette technique n'est pas recommandée, car elle était utilisée antérieur à l'introduction du token .... La liste des arguments peut inclure le token ... pour indiquer que cette fonction accepte un nombre variable d'arguments. Les arguments seront passés dans la variable fournie sous forme d'un tableau ; par exemple : ]]> &example.outputs; ... peut aussi être utilisé lors des appels de fonctions pour extraire le &array; ou la variable Traversable ou le littéral dans la liste d'arguments : ]]> &example.outputs; Vous pouvez spécifier des arguments classiques avant le mot clé .... Dans ce cas, seuls les arguments finaux qui ne correspondent pas à un argument classique seront ajoutés au tableau généré par .... Il est également possible d'ajouter une déclaration de type avant le jeton .... Si ceci est présent, alors tous les arguments capturés par ... doivent correspondre au type de paramètre. $unit; } return $time; } $a = new DateInterval('P1D'); $b = new DateInterval('P2D'); echo total_intervals('d', $a, $b).' jours'; // Ceci échouera, car null n'est pas un objet DateInterval. echo total_intervals('d', null); ?> ]]> &example.outputs; Pour finir, vous pouvez passer des arguments variables par référence en préfixant le mot clé ... d'un ET commercial (&). Aucune syntaxe spéciale n'est nécessaire pour spécifier qu'une fonction est variable ; cependant, l'accès aux arguments de la fonction nécessite l'utilisation des fonctions func_num_args, func_get_arg et func_get_args. Le premier exemple ci-dessus serait implémenté comme ceci pour des anciennes versions de PHP ]]> &example.outputs; PHP 8.0.0 introduit les arguments nommés comme extension aux paramètres positionnels existant. Les arguments nommés permettent de passer les arguments à une fonction en s'appuyant sur le nom du paramètre, au lieu de la position du paramètre. Ceci documente automatiquement la signification de l'argument, rend l'ordre des arguments indépendant et permet d'ignorer les valeurs par défaut arbitrairement. Les arguments nommés sont passés en préfixant la valeur avec le nom du paramètre suivit d'un deux-points. Utiliser des mots-clés réservés comme nom de paramètre est autorisé. Le nom du paramètre doit être un identifiant, le spécifiant de façon dynamique n'est pas permis. ]]> ]]> L'ordre dans lequel les arguments nommés sont passés n'importe pas. ]]> Les arguments nommés peuvent être combinés avec les arguments positionnels. Auquel cas, les arguments nommés doivent venir après les arguments positionnels. Il est aussi possible de spécifier seulement certains des arguments optionnels d'une fonction, peu importe leur ordre. ]]> Passer le même paramètre plusieurs fois résulte en une Error exception. ]]> À partir de PHP 8.1.0, il est possible d'utiliser des arguments nommés après avoir décompressé les arguments. Un argument nommé ne doit pas écraser un argument déjà déballé. 2, 'a' => 1], d: 40)); // 46 var_dump(foo(...[1, 2], b: 20)); // Erreur fatale. Le paramètre nommé $b écrase l'argument précédent. ?> ]]> Les valeurs sont renvoyées en utilisant une instruction de retour optionnelle. Tous les types de variables peuvent être renvoyés, tableaux et objets compris. Cela fait que la fonction finit son exécution immédiatement et passe le contrôle à la ligne appelante. Voir return pour plus d'informations. Si return est omis, la valeur &null; sera retournée. ]]> Une fonction ne peut pas renvoyer plusieurs valeurs en même temps, mais vous pouvez obtenir le même résultat en renvoyant un tableau. ]]> Pour retourner une référence d'une fonction, utilisez l'opérateur & aussi bien dans la déclaration de la fonction que dans l'assignation de la valeur de retour. ]]> Pour plus d'informations sur les références, référez-vous à l'explication sur les références. PHP supporte le concept de fonctions variables. Cela signifie que si le nom d'une variable est suivi de parenthèses, PHP recherchera une fonction de même nom et essaiera de l'exécuter. Cela peut servir, entre autres, pour faire des fonctions de rappel, des tables de fonctions... Les fonctions variables ne peuvent pas fonctionner avec les éléments de langage comme les echo, print, unset, isset, empty, include, require etc. Vous devez utiliser votre propre gestion de fonctions pour utiliser un de ces éléments de langage comme fonctions variables. \n"; } function bar($arg = '') { echo "Dans bar(); l'argument était '$arg'.
\n"; } // Ceci est une fonction détournée de echo function echoit($string) { echo $string; } $func = 'foo'; $func(); // Appel foo() $func = 'bar'; $func('test'); // Appel bar() $func = 'echoit'; $func('test'); // Appel echoit() ?> ]]> Vous pouvez aussi appeler les méthodes d'un objet en utilisant le système des fonctions variables. $name(); // Appelle la méthode Bar() } function Bar() { echo "C'est Bar"; } } $foo = new Foo(); $funcname = "Variable"; $foo->$funcname(); // Appelle $foo->Variable() ?> ]]> Lors de l'appel à des méthodes statiques, l'appel de fonction est meilleur que l'opérateur de propriété statique : Variable(), lisant ainsi la $variable depuis le contexte. ?> ]]> &reftitle.seealso; is_callable call_user_func function_exists Les variables variable PHP dispose de nombreuses fonctions et structures standards. Il y a aussi des fonctions qui requièrent des extensions spécifiques de PHP, sans lesquelles vous obtiendrez l'erreur fatale undefined function. Par exemple, pour utiliser les fonctions d'images, telles que imagecreatetruecolor, vous aurez besoin du support de GD dans PHP. Ou bien, pour utiliser mysqli_connect, vous aurez besoin de l'extension MySQLi. Il y a des fonctions de base qui sont incluses dans toutes les versions de PHP, telles que les fonctions de chaînes de caractères et les fonctions de variables. Utilisez phpinfo ou get_loaded_extensions pour savoir quelles sont les extensions qui sont compilées avec votre PHP. Notez aussi que de nombreuses extensions sont activées par défaut, et que le manuel PHP est compartimenté par extension. Voyez les chapitres de configuration, installation ainsi que les détails particuliers à chaque extension, pour savoir comment les mettre en place. Lire et comprendre le prototype d'une fonction est décrit dans l'annexe Comment lire la définition d'une fonction (prototype). Il est important de comprendre ce qu'une fonction retourne, ou si une fonction travaille directement sur la valeur des paramètres fournis. Par exemple, str_replace va retourner une chaîne modifiée, tandis que usort travaille directement sur la variable passée en paramètre. Chaque page du manuel a des informations spécifiques sur chaque fonction, comme le nombre de paramètres, les évolutions de spécifications, les valeurs retournées en cas de succès ou d'échec, et la disponibilité en fonction des versions. Bien connaître ces différences, parfois subtiles, est crucial pour bien programmer en PHP. Si les paramètres donnés à une fonction ne sont pas corrects, comme le fait de passer un &array; alors qu'une &string; est attendue, la valeur retournée de la fonction est indéfinie. Dans ce cas, la fonction retournera la plupart du temps une valeur &null; mais ce n'est juste qu'une convention et ne peut être considéré comme une certitude. À partir de PHP 8.0.0, une exception TypeError est normalement lancée dans ce cas. En mode coercitif, les types scalaires des fonctions internes sont nullables par défaut. À partir PHP 8.1.0, passer &null; à un paramètre de fonction interne qui n'est pas déclaré nullable est déconseillé et émet une notice de dépréciation en mode coercitif pour s'aligner sur le comportement des fonctions définies par l'utilisateur, où les types scalaires doivent être marqués comme nullables explicitement. Par exemple, la fonction strlen attend du paramètre $string soit de type &string; et non &null;. Pour des raisons historiques, PHP autorise le passage de &null; pour ce paramètre en mode coercitif. Le paramètre est alors implicitement converti en string, résultant en une valeur "". Noter qu'une TypeError est émise en mode strict. ]]> &reftitle.seealso; function_exists l'index des fonctions get_extension_funcs dl Les fonctions anonymes, aussi appelées fermetures ou closures permettent la création de fonctions sans préciser leur nom. Elles sont particulièrement utiles comme fonctions de rappel callable, mais leur utilisation n'est pas limitée à ce seul usage. Les fonctions anonymes sont implémentées en utilisant la classe Closure. ]]> Les fonctions anonymes peuvent aussi être utilisées comme valeurs de variables. PHP va automatiquement convertir ces expressions en objets Closure. Assigner une fermeture à une variable est la même chose qu'une affectation classique, y compris pour le point-virgule final. ]]> Les fonctions anonymes peuvent hériter des variables du contexte de leur parent. Ces variables doivent alors être passées dans la construction de langage use. À partir de PHP 7.1, ces variables ne doivent pas inclure de &link.superglobals;, $this, ou des variables ayant le même nom qu'un paramètre. Une déclaration de type de retour pour la fonction doit être placé après la clause use. ]]> &example.outputs.similar; À partir de PHP 8.0.0, la liste des variables hérité du contexte peut inclure une virgule trainante, qui sera ignoré. L'héritage du contexte parent n'est pas la même chose que les variables de l'environnement global. Les variables globales existent dans le contexte global, qui est le même, quelle que soit la fonction qui s'exécute. Le contexte parent d'une fonction anonyme est la fonction dans laquelle la fonction a été déclarée (pas nécessairement celle qui appelle). Voyez l'exemple ci-dessous : products[$product] = $quantity; } public function getQuantity($product) { return isset($this->products[$product]) ? $this->products[$product] : FALSE; } public function getTotal($tax) { $total = 0.00; $callback = function ($quantity, $product) use ($tax, &$total) { $pricePerItem = constant(__CLASS__ . "::PRICE_" . strtoupper($product)); $total += ($pricePerItem * $quantity) * ($tax + 1.0); }; array_walk($this->products, $callback); return round($total, 2); } } $mon_panier = new Panier; // Ajout d'élément au panier $mon_panier->add('beurre', 1); $mon_panier->add('lait', 3); $mon_panier->add('oeuf', 6); // Affichage du prix avec 5.5% de TVA print $mon_panier->getTotal(0.055) . "\n"; // Le résultat sera 54.29 ?> ]]> testing(); $function(); ?> ]]> &example.outputs; Lorsque déclarée dans le contexte d'une classe, la classe courante est automatiquement liée, la rendant $this disponible dans le contexte de la fonction. Si ce liage automatique de la classe courante n'est pas souhaité, alors les fonctions anonymes statiques peuvent être utilisées à la place. Les fonctions anonymes peuvent être déclarées statiquement. Ceci permet de ne pas lier automatiquement la classe courante à la fonction. Les objets peuvent aussi ne pas être liés lors de l'exécution. ]]> &example.outputs; bindTo(new StdClass); $func(); ?> ]]> &example.outputs; &reftitle.changelog; &Version; &Description; 7.1.0 Les fonctions anonymes peuvent ne pas se fermer sur les &link.superglobals;, $this, ou toute variable avec le même nom qu'un paramètre. &reftitle.notes; Il est possible d'utiliser les fonctions func_num_args, func_get_arg et func_get_args dans une fonction anonyme. Les fonctions fléchées ont été introduites en PHP 7.4 en tant que syntaxe plus concise pour les fonctions anonymes. Les fonctions anonymes comme les fonctions fléchées sont implémentées en utilisant la classe Closure. Les fonctions fléchées ont la forme basique fn (argument_list) => expr. Les fonctions fléchées supportent les mêmes fonctionnalités que les fonctions anonymes, à l'exception que l'utilisation des variables de la portée parente est automatique. Quand une variable utilisée dans l'expression est définie dans la portée parente, elle sera implicitement capturée par valeur. Dans l'exemple suivant, les fonctions $fn1 et $fn2 se comportent de façon identique. $x + $y; // equivalent to using $y by value: $fn2 = function ($x) use ($y) { return $x + $y; }; var_export($fn1(3)); ?> ]]> &example.outputs; Ceci fonctionne aussi si les fonctions fléchées sont imbriquées : fn($y) => $x * $y + $z; // Outputs 51 var_export($fn(5)(10)); ?> ]]> Similairement aux fonctions anonymes, la syntaxe des fonctions fléchées permet les signatures de fonction arbitraire, ceci inclus les types de paramètres et de retour, valeur par défaut, variable, aussi bien que le passage et retour par référence. Tous les exemples suivants sont des fonctions fléchées valides : $x; static fn(): int => $x; fn($x = 42) => $x; fn(&$x) => $x; fn&($x) => $x; fn($x, ...$rest) => $rest; ?> ]]> Les fonctions fléchées lie les variables par valeur. Ceci est à peu près équivalent à effectuer un use($x) pour chaque variable $x utilisée à l'intérieur de la fonction fléchée. Un liage par valeur signifie qu'il n'est pas possible de modifier une valeur de la portée extérieure. Les fonctions anonymes peuvent être utilisées à la place pour des liaisons par référence. $x++; // Has no effect $fn(); var_export($x); // Outputs 1 ?> ]]> &reftitle.changelog; &Version; &Description; 7.4.0 Les fonctions fléchées sont désormais disponibles. &reftitle.notes; Il est possible d'utiliser func_num_args, func_get_arg, et func_get_args depuis l'intérieur d'une fonction fléchée. La syntaxe de callable de première classe est introduite à partir de PHP 8.1.0, comme une manière de créer des fonctions anonymes depuis des callable. Elle remplace la syntaxe des callables existante utilisant les chaînes et tableaux. L'avantage de cette syntaxe est qu'elle est accessible à l'analyse statique et utilise la portée du point où le callable est acquis. La syntaxe CallableExpr(...) est utilisée pour créer un objet Closure depuis le callable. CallableExpr accepte toute expression qui peut être directement appelée dans la grammaire de PHP : method(...); $f4 = $obj->$methodStr(...); $f5 = Foo::staticmethod(...); $f6 = $classStr::$staticmethodStr(...); // traditional callable using string, array $f7 = 'strlen'(...); $f8 = [$obj, 'method'](...); $f9 = [Foo::class, 'staticmethod'](...); ?> ]]> Les ... font partie de la syntaxe et ne sont pas une omission. CallableExpr(...) a les mêmes sémantiques que Closure::fromCallable. C'est-à-dire, contrairement aux callables utilisant les chaînes et tableaux, CallableExpr(...) respecte la portée du point où il est créé : getPrivateMethod(); $privateMethod(); // Fatal error: Call to private method Foo::privateMethod() from global scope // This is because call is performed outside from Foo and visibility will be checked from this point. class Foo1 { public function getPrivateMethod() { // Uses the scope where the callable is acquired. return $this->privateMethod(...); // identical to Closure::fromCallable([$this, 'privateMethod']); } private function privateMethod() { echo __METHOD__, "\n"; } } $foo1 = new Foo1; $privateMethod = $foo1->getPrivateMethod(); $privateMethod(); // Foo1::privateMethod ?> ]]> La création d'objets avec cette syntaxe (e.g new Foo(...)) n'est pas supportée, car la syntaxe new Foo() n'est pas considérée comme un appel. La syntaxe de callable de première classe ne peut pas être combinée avec l'opérateur nullsafe. Les deux cas suivants entraînent une erreur de compilation : method(...); $obj?->prop->method(...); ?> ]]>