Les fonctions

39min
il y a 7 ans
Télécharger la vidéo
Résumé Support Quiz

Les fonctions permettent d'effectuer un traitement précis et de retourner un résultat. Elles évitent la répétition et rendent le code plus organisé. En PHP, on en a déjà utilisé sans forcément le réaliser : readline() et print_r() sont des fonctions. Pour explorer l'ensemble des fonctions disponibles, la documentation officielle reste la meilleure référence.

Lire la documentation

Avant de chercher à mémoriser toutes les fonctions PHP, il est plus utile de savoir lire la documentation. Chaque page de fonction suit toujours la même structure.

La signature

La signature est la carte d'identité d'une fonction. Elle indique en un coup d'œil comment l'utiliser :

string readline([string $prompt = ""])
  • Ce qui précède le nom de la fonction est le type de retour (string ici : la fonction renvoie une chaîne).
  • Entre parenthèses, on trouve les paramètres avec leur type et leur nom.
  • Les paramètres entre crochets sont optionnels. On peut les omettre.
  • Les trois points de suspension (...) indiquent que la fonction accepte un nombre indéfini de paramètres.
  • Le type mixed signifie que le paramètre ou le retour peut être de plusieurs types différents.
  • Le type void indique que la fonction ne renvoie rien.

Trouver une fonction

Deux approches pour trouver la bonne fonction selon un besoin :

  • Parcourir la référence des fonctions organisée par catégories (chaînes, tableaux, maths...).
  • Faire une recherche sur un moteur de recherche, de préférence en anglais, en précisant le type et le langage. Par exemple : reverse string PHP donnera de meilleurs résultats que inverser chaîne PHP.

Fonctions utiles pour les chaînes

Inverser et mettre en minuscule

strrev() inverse une chaîne de caractères, et strtolower() la convertit en minuscules. On peut les combiner :

$mot = readline("Entrez un mot : "); $inverse = strtolower(strrev($mot)); if (strtolower($mot) === $inverse) { echo "Ce mot est un palindrome.\n"; } else { echo "Ce mot n'est pas un palindrome.\n"; }

Longueur d'une chaîne

strlen() retourne la taille d'une chaîne :

$taille = strlen("merde"); // 5

Extraire une portion de chaîne

substr() retourne une partie d'une chaîne. On lui passe la chaîne, l'index de départ et le nombre de caractères souhaités :

$premiere_lettre = substr("merde", 0, 1); // "m"

On peut aussi accéder à un caractère directement comme dans un tableau :

$premiere_lettre = "merde"[0]; // "m"

Répéter une chaîne

str_repeat() répète une chaîne un nombre de fois donné :

$etoiles = str_repeat("*", 5); // "*****"

Remplacer dans une chaîne

str_replace() cherche et remplace une valeur dans une chaîne. Elle accepte aussi des tableaux en paramètres pour effectuer plusieurs remplacements d'un coup :

$phrase = str_replace("merde", "***", $phrase);

Arrondir un nombre

round() arrondit un nombre à virgule flottante. Un second paramètre optionnel permet de préciser le nombre de décimales souhaité :

$moyenne = round(14.333, 2); // 14.33

Fonctions utiles pour les tableaux

Somme et taille

array_sum() fait la somme des éléments d'un tableau. count() retourne le nombre d'éléments :

$notes = [10, 20, 13]; $somme = array_sum($notes); // 43 $nombre = count($notes); // 3 $moyenne = round($somme / $nombre, 2); // 14.33

Déboguer une variable

var_dump() affiche le type et la valeur d'une variable, ce qui est pratique pour déboguer :

var_dump($notes); // array(3) { [0]=> int(10) [1]=> int(20) [2]=> int(13) }

Contrairement à print_r(), var_dump() donne le type de chaque valeur. Son retour est void : il n'est pas possible de stocker son résultat dans une variable.

Passage par référence

Certaines fonctions modifient directement la variable qu'on leur passe, sans qu'on ait à récupérer leur retour. On le repère dans la signature par le signe & devant le paramètre.

Par exemple, array_push() ajoute un ou plusieurs éléments à un tableau et modifie la variable passée :

$notes = [10, 20, 13]; array_push($notes, 16, 17); // $notes vaut maintenant [10, 20, 13, 16, 17]

En revanche, array_reverse() ne modifie pas la variable d'origine : elle retourne un nouveau tableau :

$notes = [10, 20, 13]; $inversees = array_reverse($notes); // $notes est inchangé, $inversees vaut [13, 20, 10]

sort() trie un tableau en place (passage par référence) et retourne un booléen indiquant le succès :

$notes = [10, 20, 13]; sort($notes); // $notes vaut maintenant [10, 13, 20]

⚠️ Ces comportements différents peuvent surprendre. Il faut toujours vérifier la signature dans la documentation pour savoir si une fonction modifie la variable ou retourne un nouveau résultat.

Référence dans les assignations

Le même principe s'applique aux variables : par défaut, une assignation copie la valeur. Avec &, on crée une référence qui pointe vers la même valeur en mémoire.

$a = [1, 2, 3]; $b = $a; // copie, $a et $b sont indépendants $b[] = 4; // seul $b est modifié $c = &$a; // référence, $a et $c pointent vers le même tableau $c[] = 5; // $a est aussi modifié

Fonctions exit et die

exit() (ou son alias die()) interrompt immédiatement l'exécution du script. On peut lui passer un message à afficher :

while (true) { $mot = readline("Entrez un mot (ou laisser vide pour quitter) : "); if ($mot === "") { exit("Fin du programme.\n"); } $inverse = strtolower(strrev($mot)); if (strtolower($mot) === $inverse) { echo "\"$mot\" est un palindrome.\n\n"; } else { echo "\"$mot\" n'est pas un palindrome.\n\n"; } }

Exemple pratique : filtre d'insultes

Pour illustrer la combinaison de plusieurs fonctions, voici un filtre qui remplace les gros mots par des astérisques, en conservant la première lettre de chaque mot censuré :

$insultes = ["merde", "con"]; $phrase = readline("Entrez une phrase : "); $asterisques = []; foreach ($insultes as $insulte) { $premiere = substr($insulte, 0, 1); $asterisques[] = $premiere . str_repeat("*", strlen($insulte) - 1); } $phrase = str_replace($insultes, $asterisques, $phrase); echo $phrase . "\n";

str_replace() accepte des tableaux en premier et second paramètre : elle effectue tous les remplacements en une seule fois, ce qui évite d'utiliser une boucle pour les remplacements.