Fonctions PHP

Fonctions intégrées PHP

Une fonction est un bloc de code autonome qui exécute une tâche spécifique.

PHP a une énorme collection de fonctions internes ou intégrées que vous pouvez appeler directement dans vos scripts PHP pour effectuer une tâche spécifique, comme gettype(), print_r(), var_dump, etc.

 

Fonctions PHP définies par l'utilisateur

En plus des fonctions intégrées, PHP vous permet également de définir vos propres fonctions. C'est un moyen de créer des packages de code réutilisables qui effectuent des tâches spécifiques et peuvent être conservés et maintenus séparément du programme principal. Voici quelques avantages de l'utilisation des fonctions :

• Une fonction réduit la répétition de code dans un programme — Une fonction vous permet d'extraire un bloc de code couramment utilisé en un seul composant. Vous pouvez maintenant effectuer la même tâche en appelant cette fonction où vous voulez dans votre script sans avoir à copier et coller le même bloc de code encore et encore.
• Les fonctions rendent le code beaucoup plus facile à maintenir - Puisqu'une fonction créée une fois peut être utilisée plusieurs fois, toute modification apportée à l'intérieur d'une fonction est automatiquement implémentée à tous les endroits sans toucher aux différents fichiers.
• Les fonctions facilitent l'élimination des erreurs - Lorsque le programme est subdivisé en fonctions, si une erreur se produit, vous savez exactement quelle fonction est à l'origine de l'erreur et où la trouver. Par conséquent, la correction des erreurs devient beaucoup plus facile.
• Les fonctions peuvent être réutilisées dans d'autres applications — Parce qu'une fonction est séparée du reste du script, il est facile de réutiliser la même fonction dans d'autres applications simplement en incluant le fichier php contenant ces fonctions.

La section suivante vous montrera avec quelle facilité vous pouvez définir votre propre fonction en PHP.

Créer et invoquer des fonctions

La syntaxe de base de la création d'une fonction personnalisée peut être donnée avec :

function nom_fonction(){
    // Code à exécuter
}

La déclaration d'une fonction définie par l'utilisateur commence par le mot-clé function, suivi du nom de la fonction que vous souhaitez créer suivi de parenthèses, c'est-à-dire () et placez enfin le code de votre fonction entre accolades {}.

Voici un exemple simple d'une fonction définie par l'utilisateur, qui affiche la date du jour :

<?php
/* définir une fonction */
function whatIsToday(){
    echo "Today is " . date('l', mktime());
}
/* appel de la fonction */
whatIsToday();
?>

Remarque : Un nom de fonction doit commencer par une lettre ou un caractère de soulignement et non par un chiffre, éventuellement suivi par d'autres lettres, chiffres ou caractères de soulignement. Les noms de fonction ne sont pas sensibles à la casse.

Fonctions avec paramètres

Vous pouvez spécifier des paramètres lorsque vous définissez votre fonction pour accepter des valeurs d'entrée au moment de l'exécution. Les paramètres fonctionnent comme des variables d'espace réservé dans une fonction ; ils sont remplacés au moment de l'exécution par les valeurs (appelées arguments) fournies à la fonction au moment de l'invocation.

 

function myFunc($oneParameter, $anotherParameter){
    // Code à exécuter
}

Vous pouvez définir autant de paramètres que vous le souhaitez. Cependant, pour chaque paramètre que vous spécifiez, un argument correspondant doit être passé à la fonction lorsqu'elle est appelée.

La fonction getSum() dans l'exemple suivant prend deux valeurs entières comme arguments, il suffit de les additionner, puis d'afficher le résultat dans le navigateur.

<?php
function getSum($num1, $num2){
  $sum = $num1 + $num2;
  echo "Sum of the two numbers $num1 and $num2 is : $sum";
}

getSum(10, 20);
?>

La sortie du code ci-dessus sera :

La somme des deux nombres 10 et 20 est : 30

Astuce : Un argument est une valeur que vous transmettez à une fonction, et un paramètre est la variable dans la fonction qui reçoit l'argument. Cependant, dans l'usage courant, ces termes sont interchangeables, c'est-à-dire qu'un argument est un paramètre est un argument.

Fonctions avec paramètres facultatifs et valeurs par défaut

Vous pouvez également créer des fonctions avec des paramètres facultatifs - insérez simplement le nom du paramètre, suivi d'un signe égal (= ), suivi d'une valeur par défaut, comme ceci.

<?php
function customFont($font, $size=1.5){
    echo "<p style=\"font-family: $font; font-size: {$size}em;\">Hello, world!</p>";
}

customFont("Arial", 2);
customFont("Times", 3);
customFont("Courier");
?>

Comme vous pouvez le voir, le troisième appel à customFont() n'inclut pas le deuxième argument. Cela amène le moteur PHP à utiliser la valeur par défaut pour le paramètre $size qui est 1.5.

Renvoyer des valeurs à partir d'une fonction

Une fonction peut renvoyer une valeur au script qui a appelé la fonction à l'aide de l'instruction return. La valeur peut être de n'importe quel type, y compris des tableaux et des objets.

<?php
function getSum($num1, $num2){
    $total = $num1 + $num2;
    return $total;
}


echo getSum(5, 10); // Sortie : 15
?>

Une fonction ne peut pas renvoyer plusieurs valeurs. Cependant, vous pouvez obtenir des résultats similaires en retournant un tableau, comme illustré dans l'exemple suivant.

<?php
function divideNumbers($dividend, $divisor){
    $quotient = $dividend / $divisor;
    $array = array($dividend, $divisor, $quotient);
    return $array;
}
 
list($dividend, $divisor, $quotient) = divideNumbers(10, 2);
echo $dividend;  // Affiche: 10
echo $divisor;   // Affiche : 2
echo $quotient;  // Affiche : 5
?>

Passer des arguments à une fonction par référence

En PHP, il existe deux manières de passer des arguments à une fonction : par valeur et par référence . Par défaut, les arguments de la fonction sont passés par valeur afin que si la valeur de l'argument dans la fonction est modifiée, elle ne soit pas affectée en dehors de la fonction. Cependant, pour permettre à une fonction de modifier ses arguments, ils doivent être passés par référence.

Le passage d'un argument par référence se fait en ajoutant une esperluette ( &) au début du nom de l'argument dans la définition de la fonction, comme illustré dans l'exemple ci-dessous :

<?php
/* une fonction qui multiplie un nombre
par lui meme et retourne une valeur */
function selfMultiply(&$number){
    $number *= $number;
    return $number;
}
 
$mynum = 5;
echo $mynum; // Affiche: 5
 
selfMultiply($mynum);
echo $mynum; // Affiche: 25
?>

Comprendre la portée variable

Cependant, vous pouvez déclarer les variables n'importe où dans un script PHP. Mais, l'emplacement de la déclaration détermine l'étendue de la visibilité d'une variable dans le programme PHP, c'est-à-dire l'endroit où la variable peut être utilisée ou accessible. Cette accessibilité est connue sous le nom de portée d'une variable.

Par défaut, les variables déclarées dans une fonction sont locales et ne peuvent pas être visualisées ou manipulées depuis l'extérieur de cette fonction, comme illustré dans l'exemple ci-dessous :

<?php
function test(){
    $greet = "Hello World!";
    echo $greet;
}
 
test(); // Affiche: Hello World!
 
echo $greet; /* undefined variable error */
?>

De même, si vous essayez d'accéder ou d'importer une variable externe à l'intérieur de la fonction, vous obtiendrez une erreur de variable indéfinie, comme illustré dans l'exemple suivant :

<?php
$greet = "Hello World!";
function test(){
    echo $greet;
}
 
test();  /* undefined variable error */
echo $greet; // Affiche: Hello World!
?>

Comme vous pouvez le voir dans les exemples ci-dessus, la variable déclarée à l'intérieur de la fonction n'est pas accessible de l'extérieur, de même la variable déclarée à l'extérieur de la fonction n'est pas accessible à l'intérieur de la fonction. Cette séparation réduit les chances que les variables d'une fonction soient affectées par les variables du programme principal.

Astuce : Il est possible de réutiliser le même nom pour une variable dans différentes fonctions, car les variables locales ne sont reconnues que par la fonction dans laquelle elles sont déclarées.

Le mot-clé global

Il peut arriver que vous ayez besoin d'importer une variable du programme principal dans une fonction, ou vice versa. Dans de tels cas, vous pouvez utiliser le mot-clé global avant les variables à l'intérieur d'une fonction. Ce mot clé transforme la variable en variable globale, la rendant visible ou accessible à la fois à l'intérieur et à l'extérieur de la fonction, comme le montre l'exemple ci-dessous :

<?php
$greet = "Hello World!";

function test(){
    global $greet;
    echo $greet;
}
 
test(); // Affiche: Hello World!
echo $greet; // Affiche: Hello World!
 /* assigner une nouvelle valeur */
$greet = "Goodbye";
 
test(); // Affiche: Goodbye
echo $greet; // Affiche: Goodbye
?>

Vous en apprendrez plus sur la visibilité et le contrôle d'accès dans le chapitre Classes et objets PHP .

Création de fonctions récursives

Une fonction récursive est une fonction qui s'appelle encore et encore jusqu'à ce qu'une condition soit satisfaite. Les fonctions récursives sont souvent utilisées pour résoudre des calculs mathématiques complexes ou pour traiter des structures profondément imbriquées, par exemple en imprimant tous les éléments d'un tableau profondément imbriqué.

L'exemple suivant montre comment fonctionne une fonction récursive.

<?php
/* définir une fonction récursive */
function printValues($arr) {
    global $count;
    global $items;
    
    /* verifie si c'est un tableau
    if(!is_array($arr)){
        die("ERROR: Input is not an array");
    }
    
    /*
   Boucle dans le tableau, si la valeur est elle-même un tableau,
 appelez la fonction de manière récursive, sinon ajoutez
 la valeur trouvée au tableau des éléments de sortie et incrémentez le compteur de 1 pour chaque valeur trouvée
   */
    foreach($arr as $a){
        if(is_array($a)){
            printValues($a);
        } else{
            $items[] = $a;
            $count++;
        }
    }
    
    /* retourner le total et les valeurs trouvées dans le tableau
    return array('total' => $count, 'values' => $items);
}
 
// Définir un tableau associatif
$species = array(
    "birds" => array(
        "Eagle",
        "Parrot",
        "Swan"
    ),
    "mammals" => array(
        "Human",
        "cat" => array(
            "Lion",
            "Tiger",
            "Jaguar"
        ),
        "Elephant",
        "Monkey"
    ),
    "reptiles" => array(
        "snake" => array(
            "Cobra" => array(
                "King Cobra",
                "Egyptian cobra"
            ),
            "Viper",
            "Anaconda"
        ),
        "Crocodile",
        "Dinosaur" => array(
            "T-rex",
            "Alamosaurus"
        )
    )
);
 
/* Compter et afficher les éléments dans le tableau */
$result = printValues($species);
echo $result['total'] . ' value(s) found: ';
echo implode(', ', $result['values']);
?>

Remarque : soyez prudent lors de la création de fonctions récursives, car si le code est écrit de manière incorrecte, cela peut entraîner une boucle infinie d'appel de fonction.