« Programmation PHP/Fonctions » : différence entre les versions

Navigation interactive dans l’historique

← Modification précédente Modification suivante →

Contenu supprimé Contenu ajouté

VisuelWikicode

Intégrés

Version du 13 février 2021 à 22:32

Opérateurs

Tableaux

Programmation PHP

Introduction
Installer PHP
Composer
IDE
Bases du langage
Programmation avancée
Apprendre par l'exemple
- AJAX
1. Sommaire en Ajax
2. Mise à jour périodique d'un cadre
- Mini CMS
Extensions PHP
- cURL
- DOMDocument
- JSON
- MING
- SPL
Bibliothèques externes
- ADODB
- DOMPDF
- FPDF
- PHPExcel
- PHPMailer
- PHPWord
- RabbitMQ
Cadriciels
- CakePHP
- PEAR
- Symfony
- Frameworks de tests
  - PHPUnit
  - SimpleTest
  - Behat
Logiciels métier
Problèmes connus

Version imprimable

[ Modifier le sommaire ]

Opérateurs

Tableaux

Déclaration de fonction

Outre les dizaines de fonctions natives^[1], PHP permet bien entendu d'écrire ses propres fonctions. Pour en déclarer une, il suffit d’utiliser le mot-clef function. Comme le langage est faiblement typé, une fonction peut retourner n’importe quel type de valeur (chaîne, entier…) ou ne rien retourner du tout. Enfin, ses arguments peuvent avoir des valeurs par défaut.

Principe

// foo retourne le résultat de la somme du deuxième paramètre et de 4.
// Si aucun second paramètre n'est donné, la fonction utilisera la valeur 0 par défaut.
function foo($arg1, $arg2 = 0)
{
    print 'Fonction foo(' . $arg1 . ',' . $arg2 . ') donne : ';
    return $arg2+4;
 // tout ce qui suit ne sera jamais exécuté 
}

//appel à la fonction
print foo(1,3);  //affichera: Fonction foo(1,3) donne 7
print foo(5);    //affichera: Fonction foo(5,0) donne 4

Notez que lorsqu'une fonction arrive à un return, elle l'effectue puis se termine, même s'il y a d'autres instructions après.

Par ailleurs, en cas de gros volume de données à retourner, on peut utiliser yield au lieu de return pour les décomposer à l'aide du générateur PHP^[2].

Contrairement à d'autres langages, PHP ne permet pas d'appeler certains arguments par leurs noms : si l'on souhaite appeler un des derniers arguments, il faut donc définir tous ceux avant lui, même les optionnels. Toutefois pour éviter ce désagrément, on peut utiliser la classe ReflectionMethod. NB : il existe aussi ReflectionClass^[3].

Portée des variables

Le problème de portée des variables est assez réduit en PHP. Une fonction n'a accès qu’à ses arguments, ses propres variables et aux variables globales importées statiquement (mot clé global). De ce fait, il y a peu de confusion.

Toujours suivant le même principe, les variables utilisées dans une fonction sont toutes détruites à sa sortie (les variables globales non, bien entendu).

Exemple

$valeur1=10;
$valeur2=20;

function exemple($valeur)
{
    global $valeur1; // récupération de la valeur globale de $valeur1
    $valeur3=5;
    $calcul=$valeur1+$valeur2+$valeur3+$valeur; // 10 + 0 + 5 + le paramètre qui sera entre parenthèses. 
    //$valeur2 n'ayant pas été définie comme valeur globale, la variable $valeur2 est donc vide.
    return $calcul;
}

echo exemple(2); // affiche 17

On peut aussi trouver un peu plus compliqué si vous utilisez deux fichiers. L'un pour les variables, l'autre pour les traitements.

Principe

<?php
//-- fichier 1 : les variables globales (mot clef '''global''')
global $var1 = "Salut";
?>

Principe

<?php
//-- fichier 2 : les traitements
echo "J'utilise ma variable globale : ".$GLOBALS['var1']; //-- Récupération via $GLOBALS
?>

Espaces de noms

Depuis PHP 5.3.0, des espaces de noms peuvent être définis pour cloisonner certains objets, à l'aide du mot clé namespace utilisé en début de fichier^[4]. Exemple de définition :

<?php
 namespace Projet1;
...

Soit un fichier TestNS.php suivant :

<?php
 namespace Projet1\SousProjet2;

function Fonction1()
{
    echo "Fonction exécutée.\n";
    echo __NAMESPACE__;
}
?>

Le fichier doit être encodé en ANSI ou Unicode sans BOM, mais pas en Unicode seul, sous peine d’avoir l'erreur Namespace declaration statement has to be the very first statement in the script, et d'être obligé de coller le mot "namespace" à "?php").

Exemple d’utilisation :

<?php
 require 'TestNS.php';
 Projet1\SousProjet2\Fonction1();
?>

Par convention, l'arborescence du système de fichiers correspond à celle des espaces de noms. Dans l'exemple ci-dessus, il faudrait donc placer le fichier dans Projet1\SousProjet2\TestNS.php et faire plutôt require 'Projet1\SousProjet2\TestNS.php';

Références de variables

Les références sont utiles lorsque l’on souhaite retourner plusieurs valeurs dans une fonction. On utilise alors le passage d'argument par référence, qui fait que quand une fonction modifie un argument, la valeur de la variable du programme principale change aussi.

Pour utiliser un argument en tant que référence, il suffit d'y mettre l'opérateur de référence, le symbole & devant, dans la déclaration de la fonction.

Un exemple concret devrait vous faire comprendre :

Exemple

function foo(&$arg1, &$arg2, $arg3)
{
    $arg1 = 4;
    $arg2 = 6;
    $arg3 = 8;
}

foo($var1, $var2, $var3);
print $var1;  //affichera 4
print $var2;  //affichera 6
print $var3;  //affichera NULL car $arg3 n'est pas une référence (pas de &)

Fonctions variables

On appelle "fonction variable" une fonction dont on ne peut prédire le nombre d'arguments. Ce genre de fonction pourra se révéler pratique pour exécuter certains codes répétitifs ou le programmeur n'a pas envie de recopier le nom de la fonction pour n valeurs.

Pour cela, il faut retenir deux fonctions importantes :

func_num_args : permet de compter le nombre d'arguments (retourne true ou false).
func_get_args : permet de récupérer la valeur d’un argument (retourne un tableau de valeur)^[5].

Ces deux fonctions ne peuvent s'utiliser qu’à l'intérieur d’une fonction; dans le cas contraire un message d'erreur s'affichera.

Exemple

function afficher_variables ()
{
    $nb_args = func_num_args();
    $list_args = func_get_args();

    for ($i = 0; $i < $nb_args; $i++) {
        echo $list_args[$i].' ';
    }
}
$var1 = 'programmeur';
afficher_variables('Je suis', $var1, ', c\'est utile', ', c\'est intéressant.'); // Et on peut en rajouter autant que nécessaire.

Le code se comprend de lui-même. Il affichera : Je suis programmeur, c’est utile, c’est intéressant.

Fonctions de rappel

Pour passer une fonction en argument d'une autre, il faut utiliser call_user_func(). Ex :

    function fonctionAppelante(string $nomDeFonctionAppelee)
    {
        return call_user_func($nomDeFonctionAppelee);
    }

Fonctions anonymes

Une fonction sans nom peut être stockée dans une variable permettant de l'appeler. Le mot clé use permet d'injecter des variables globales dedans. Ex :

$variableGlobale = 'Hello';
$fonctionAnonyme = function ($argument) use ($variableGlobale) {
    return $variableGlobale.' '.$argument.PHP_EOL;
};
echo $fonctionAnonyme('World'); // Hello World
echo $fonctionAnonyme('You');   // Hello You

Fonctions fléchées

Depuis PHP7.4, on peut définir une fonction anonyme avec l'opérateur "=>" et le mot réservé fn. Ex :

$fonctionFlechee = fn($argument) => $variableGlobale.' '.$argument.PHP_EOL;
echo $fonctionFlechee('World'); // Hello World
echo $fonctionFlechee('You');   // Hello You

Fonctions prédéfinies

Voici une liste des fonctions globales prédéfinies en PHP les plus usuelles.

print() (alias echo) : affiche le contenu de la variable placée en paramètre.
printf() et dérivés (ex : sprintf) : print formaté, affiche un texte dont on remplace les marqueurs, numérotables, par les variables en paramètre^[6]. Exemple :

printf('Compteur : %s. ', 1);                     // Compteur : 1.
printf('Compteur : %s. ', 2);                     // Compteur : 2.

printf('Compteur : %s, taille : %s. ', 3, 1);     // Compteur : 3, taille : 1.
printf('Compteur : %2$s, taille : %1$d. ', 1, 4); // Compteur : 4, taille : 1.
printf('Compteur : %1$d, taille : %1$d. ', 5);    // Compteur : 5, taille : 5.

echo vsprintf('Tailles : %d, %d, %d, %d', [1, 2, 3, 4]); // Tailles : 1, 2, 3, 4

Les types suivants sont généralement utilisés :

d : digit
f : float
s : string

Pour échapper les "%" pour sont interprétés par ces fonctions, ce n'est pas "\" mais "%".
Ne pas utiliser les doubles quotes sous peine de Undefined variable: d.

sleep($secondes) : attend un certain nombre de secondes (utilisation déconseillée quand un humain doit attendre un résultat).
call_user_func_array('maFonction', 'mesArguments') : exécute une fonction à partir de son nom en chaine de caractères.

Sur les chaines

trim() : supprimer les espaces et retours chariots en début et fin de chaine.
strip_tags() : supprime les balises HTML de la chaine mentionnée en paramètre 1, en conservant ceux en paramètre 2 (sous la forme d'une chaine comme '<p><br>').
ucfirst() : met une majuscule en début de chaine.
lcfirst() : met une minuscule en début de chaine.
strtoupper() : met en lettres capitales toute la chaine.
strtolower() : met en bas de casse toute la chaine.
strlen() : compte la taille d'une chaine en octets. Pour avoir le nombre de caractères, utiliser mb_strlen() (pour multibyte).
str_contains($chaine, $cle) : cherche si une chaine contient une sous-chaine.
str_replace($ancien, $nouveau, $texte) : remplace des caractères par d'autres dans un un texte ou un tableau^[7].
str_ireplace($ancien, $nouveau, $texte) : fait la même chose en ignorant la casse.
strpos($meubleDeFoin, $aiguille)^[8] : première position d'une sous-chaine. Attention : ne jamais utiliser comme si elle renvoyait un booléen (~~if (strpos())~~) car si la recherche est en première position (0) elle sera considérée comme fausse avec le typage faible. Il faut tester l'existence avec if (false !== strpos()).
stripos($meubleDeFoin, $aiguille) : fait la même chose en ignorant la casse.
strrpos($meubleDeFoin, $aiguille) : dernière position d'une sous-chaine.
substr($texte, $debut , $fin) : tronque un texte en sous-chaine. Utiliser mb_substr en Unicode.
Pour accéder à un seul caractère d'une chaine, PHP peut la considérer comme un tableau (ex : $chaine[0]).
substr_count($chaine, $sous-chaine) : compte le nombre de sous-chaine dans une chaine.
parse_url() : découpe une chaine en partie d'une adresse URL (protocole, domaine et chemin d'accès).
str_pad() : complète une chaine avec un caractère pour qu'elle atteigne la taille demandée si ce n'était pas le cas. Ex :

echo str_pad(10, 2, '0');               // 10
echo str_pad(9, 2, '0');                // 90
echo str_pad(9, 2, '0', STR_PAD_LEFT);  // 09

eval($chaine) : exécute une chaine comme un script PHP.

Sur les nombres

number_format($nb, 2, ',', ' ') : pour formater les nombres, où "2" représente le nombre de chiffres après la virgule, "," le séparateur décimal et " " le séparateur de milliers.
max($nombre1, $nombre2, ...)^[9] : affiche le plus grand nombre parmi les paramètres.
min($nombre1, $nombre2, ...) : fait la même chose avec le minimum.
round($nombre) : arrondit un nombre à l'entier le plus proche, ou selon une précision en deuxième paramètre s'il est renseigné^[10]. Exemple :

echo round(5.49);  // 5
echo round(5.50);  // 6

sqrt($nombre) : racine carrée (square root).

Références

[1] ttp://php.net/manual/fr/indexes.functions.php

[2] ttp://php.net/manual/fr/language.generators.syntax.php

[3] ttp://php.net/manual/fr/reflectionclass.getdoccomment.php

[4] ttp://php.net/manual/fr/language.namespaces.rationale.php

[5] ttp://php.net/manual/fr/ref.funchand.php

[6] ttp://php.net/manual/fr/function.sprintf.php

[7] ttp://php.net/manual/fr/function.str-replace.php

[8] ttp://php.net/manual/fr/function.strpos.php

[9] ttp://php.net/manual/fr/function.max.php

[10] ttp://php.net/manual/fr/function.round.php

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

@@ Ligne 166 : / Ligne 166 : @@
 Pour passer une fonction en argument d'une autre, il faut utiliser <code>call_user_func()</code>. Ex :
 <syntaxhighlight lang="php">
-    function methodeAppelante(string $nomDeMethodeAppelee)
+    function fonctionAppelante(string $nomDeFonctionAppelee)
     {
-        call_user_func($nomDeMethodeAppelee);
+        return call_user_func($nomDeFonctionAppelee);
     }
 </syntaxhighlight>