Développement web avancé

Fonctions - PHP

2526 · Dekens Antoine

Fonctions utilisateurs

Syntaxe

Une fonction est définie en utilisant le mot-clé function, un nom, une liste de paramètres (qui peuvent être vides) séparés par des virgules (,) entre parenthèses, suivis du corps de la fonction entre accolades :

function name( $a, $b, … ) {
  // votre logique
}

function

Valeurs par défaut

Il est possible de donner une valeur par défaut à un paramètre via une affectation. Le paramètre devient optionnel, ce qui veut dire qu'ils doivent se situer après ceux sans valeur par défaut, qui sont considérés obligatoires.

Valeurs par défaut

function orderDrink( $drink = "coca" ) {
  echo "Je voudrais un $drink";
}

orderDrink();
orderDrink( "thé" );

Déclaration de type

Les déclarations de types peuvent être ajoutées aux arguments des fonctions, valeurs de retour, à partir de PHP 7.4.0, les propriétés de classe, et à partir de PHP 8.3.0, les constantes de classe :

// Active le typage strict
declare(strict_types=1);

// $a et $b doivent être des entiers.
function sum( int $a, int $b ){
  return $a + $b;
}

Déclaration de type Typage strict

Valeur de retour

La valeur de retour peut être définie avec : type après les parenthèses :

// Active le typage strict
declare(strict_types=1);

// $a et $b doivent être des entiers.
// return doit retouner un entier.
function sum( int $a, int $b ): int
{
  return $a + $b;
}

Valeurs spécifiques

Types d'unions

Un type d'union accepte des valeurs de plusieurs types différents, plutôt qu'un seul. Les types sont séparés par des barres verticals | :

// Active le typage strict
declare(strict_types=1);

// $a et $b peuvent être entier ou décimaux.
function sum( int|float $a, int|float $b )
{
  return $a + $b;
}

type d'union barre verticale

Mixed

mixed

// Active le typage strict
declare(strict_types=1);

// $a peut être de n'importe quel type.
function test( mixed $a )
{
  return $a;
}

Void

void est une valeur de retour, indiquant que la fonction ne retourne rien de particulier mais se termine malgré tout.

Même si une fonction a un type de retour void, elle retournera toujours une valeur, cette valeur est toujours null.

void

// Active le typage strict
declare(strict_types=1);

// $a peut être de n'importe quel type.
function test( mixed $a ): void
{
  // votre logique ici
}

Type nullable

Une déclaration de type de base unique peut être marquée comme valeur NULL en faisant précéder le type d'un point d'interrogation :

// Active le typage strict
declare(strict_types=1);

// $a peut être un entier ou null
// Équivalant à int|null en type union
function test( ?int $a )
{
  // votre logique ici
}

type nullable

Fonctions natives

Manipulation de string

mb_strlen

Retourne un nombre entier indiquant le nombre de caractères présent dans un texte passé entre parenthèses.

mb_strlen

<?php 
  $sentence = "Une chaîne de caractères";

  // On récupère la longueur de notre phrase
  // et on la stocke dans une variable;
  $length = mb_strlen( $sentence );

  // Affiche 24
  echo $lenght;
?>

mb_strpos

Détecte la première occurence d'un caractère dans une chaîne de caractères en retournant sa position numérique. Il existe 4 paramètres :

haystack : la chaîne de caractères à analyser
needle : le caractère à trouver
offset (optionnel): la position de début de recherche, par défaut à 0 (le début)
encoding (optionnel): le type d'encodage

Retourne false si la fonction ne détecte pas le caractère.

mb_strpos

<?php 
  $sentence = "Une chaîne de caractères";
  $character = "a";

  // Analyse la phrase depuis le début
  // et retourne la position du caractère recherché.
  $characterPositionA = mb_strpos( $sentence, $character );

  // Analyse la phrase depuis le 8ème caractère
  // et retourne la position du caractère recherché.
  $characterPositionB = mb_strpos( $sentence, $character, 8 );

  echo $characterPositionA; // Affiche 6
  echo $characterPositionB; // Affiche 15
?>

mb_strrpos

Détecte la dernière occurence d'un caractère dans une chaîne de caractères en retournant sa position numérique. Il existe 4 paramètres :

haystack : la chaîne de caractères à analyser
needle : le caractère à trouver
offset (optionnel): la position de début de recherche, par défaut à 0 (le début)
encoding (optionnel): le type d'encodage

Retourne false si la fonction ne détecte pas le caractère.

mb_strrpos

mb_substr

Renvoie une portion d'une chaîne de caractères comprise entre une position de début et une certaine longueur :

string : la chaîne de caractère d'entrée
offset : la position de début
length : la longueur de la portion à retourner. Si omis, retourne le restant du texte.

mb_substr

<?php 
  $sentence = "Une chaîne de caractères";

  // Retourne les 10 premiers caractères
  // de notre texte.
  $subStrA = mb_substr( $sentence, 0, 10);

  // Retourne 6 caractères depuis le cinquième caractère. 
  // U n e   c …
  // 0 1 2 3 4 …
  $subStrB = mb_substr( $sentence, 4, 6);

  echo $subStrA; // Affiche "Une chaîne"
  echo $subStrB; // Affiche "chaîne"

str_replace

Permet de remplacer toute les occurences d'une chaîne de caractères par un autre texte :

search : les occureances à trouver (array ou string)
replace : la valeur de remplacement (array ou string)
subject : la chaîne de caractères d'origine

str_replace

<?php 
  $sentenceA = "J'ai attrapé un pokemon sauvage!";
  $searchA = "pokemon";
  $replaceA = "pikachu";

  // Affiche "J'ai attrapé un pikachu sauvage!";
  echo str_replace( $searchA, $replaceA, $sentenceA );

  $sentenceB = "J'ai 2 pokemons et 100 pokedollars.";
  $searchB = [ '2', ' pokedollars'];
  $replaceB = [ 'deux', '₽'];

  // Affiche "J'ai deux pokemons et 100₽.";
  echo str_replace( $searchB, $replaceB, $sentenceB );

trim

Permet de supprimer certains caractères invisibles (ex: les espaces) en début et fin de chaîne de caractères.

Cela supprime aussi les tabulations, les sauts de ligne, les retours chariot, etc. Il existe depuis PHP 8.4 la fonction mb_trim qui est plus complète.

trim mb_trim

<?php 
  $sentence = "    J'ai attrapé un pokemon sauvage!";

  // Supprime les espaces en début de chaîne et
  // affiche "J'ai attrapé un pokemon sauvage!";
  echo trim( $sentence );

explode

Un tableau peut être créé à partir d'un chaîne de caractères via la fonction explode( ). Elle prend au moins 2 paramètres :

Separator : caractère servant à la séparation
string : notre chaîne de caractères à séparer

Cela nous retourne un tableau

explode

$pokemons = "pikachu,carapuce,onix";

// On créé un tableau à partir d'un texte
// qui sera délimité par des ","
$pokedex = explode( ",", $pokemons );

Exemple

Définissons une fonction truncate qui limitera le nombre de caractères d'un texte. Faisons cela en plusieurs étapes :

Définir la fonction et ses paramètres
Retourner une chaine réduite
Ajouter un suffixe

// On prévoit 2 paramères, un pour passer notre texte
// à raccourcir et le dernier pour donner la longueur limite.
function truncate( string $text, int $maxLength ):string {}

$sentence = "Pampa utilise la compétence 1000 épines";

function truncate( string $text, int $maxLength ) {

  // Retire les caractères invisibles en début et fin de chaîne.
  $text = trim( $text );

  // Réduit le texte depuis son début en utilisant
  // la longueur maximum .
  $truncateText = mb_substr( $text, 0, $maxLength );

  // Retourne le nouveau texte
  return $truncateText;
}

$sentence = "Pampa utilise la compétence 1000 épines";

// Demande de raccourcir le texte à 20 caractères.
echo truncate( $sentence, 20 );

function truncate( string $text, int $maxLength ) {                        
  $text = trim( $text );

  // Calcule la longueur du texte
  $length = mb_strlen( $text );

  // Calcule la différence entre la longueur et le maximum demandé
  $diffLength = $length - $maxLength;

  // Si la différence est égale ou inférieur à 0, il est
  // inutile de raccourcir le texte. On met donc fin
  // prématurément à l'éxécution.
  if( $diffLength <= 0 ){
    return;
  }

  $truncateText = mb_substr( $text, 0, $maxLength );
  return $truncateText;
}

$sentence = "Pampa utilise la compétence 1000 épines";
echo truncate( $sentence, 20 );

function truncate( string $text, int $maxLength ) {                        
  $text = trim( $text );
  $length = mb_strlen( $text );
  $diffLength = $length - $maxLength;

  if( $diffLength <= 0 ){
    return;
  }

  // Récupère le dernier espace de notre texte basé sur la longueur demandée
  $lastSpacePosition = mb_strrpos( $text, ' ', $maxLength - $length);

  // Utilise cette position pour définir la limite de notre texte. 
  // Cela évite de tronquer au milieu d'un mot.                          
  $truncateText = mb_substr( $text, 0, $lastSpacePosition );
  return $truncateText;
}

$sentence = "Pampa utilise la compétence 1000 épines";
echo truncate( $sentence, 20 );

// On ajoute un paramètre "suffix" qui permettra de 
// définir comment doit se terminer le texte tronqué.
// On mettra "…" comme valeur par défaut.
function truncate( string $text, int $maxLength, string $suffix = "…" ) {                        
  $text = trim( $text );
  $length = mb_strlen( $text );
  $diffLength = $length - $maxLength;

  if( $diffLength <= 0 ){
    return;
  }

  $lastSpacePosition = mb_strrpos( $text, ' ', $maxLength - $length);
  
  // On concatène avec notre suffixe.
  $truncateText = mb_substr( $text, 0, $lastSpacePosition ) . $suffix;
  return $truncateText;
}

$sentence = "Pampa utilise la compétence 1000 épines";
echo truncate( $sentence, 20 );

Manipulation d'array

count

La fonction count( ) permet de retourner le nombre d'éléments dans notre tableau :

$pokedex = [ 'pikachu', 'carapuce', 'onix' ];

// Retourne la longueur de notre tableau => 3
echo count( $pokedex );

count

in_array

Retourne un boolean si un élément se trouve dans un tableau avec 3 paramètres :

needle : La valeur à rechercher
haystack : Le tableau où chercher
strict (optionnel) : Vérifie avec une égalité strict si on passe true. Par défaut false

in_array

$pokedex = [ 'pikachu', 'carapuce', 'onix' ];

// Vérifie la présence de 'carapuce' de manière strict.
if( in_array( 'carapuce', $pokedex, true ) ) {
  echo "Carapuce est présent";
}

sort

Permet de trier un tableau sur base d'un comportement de tri. Par défaut par ordre croissant. Prend 2 paramètres :

array : le tableau à trier
flag (opionnel) : type(s) de tri

sort

$pokedex = [ 'pikachu', 'carapuce', 'onix' ];

sort( $pokedex );

// [ 'carapuce', 'onix', 'pikachu' ];
var_dump( $pokedex );

array_merge

Retourne la fusion entre n tableaux, séparés par des virgules où chaque tableau est ajouté à la fin d'un autre.

array_merge

$pokedexA = [ 'pikachu', 'carapuce' ];
$pokedexB = [ 'onix', 'dracaufeu' ];
$pokedexC = [ 'roucool' ];

$pokedex = array_merge( $pokedexA, $pokedexB, $pokedexC );

// [ 'pikachu', 'carapuce', 'onix', 'dracaufeu', 'roucool' ];
var_dump( $pokedex );

array_unique

Retourne un nouveau tableau en retirant les doublons d'un autre tableau, avec la possibilité de changer le comportement de comparaison :

array : le tableau à vérifier
flag : le comportement de comparaison

Les clés seront conservées (indices ou nommage).

array_unique

$pokedex = [ 'pikachu', 'carapuce', 'onix', 'carapuce' ];

$newPokedex = array_unique( $pokedex );
// [ 'pikachu', 'carapuce', 'onix' ];
var_dump( $newPokedex );

implode

L'inverse de la fonction explode, la fonction implode permet de former une chaîne de caractère sur base des éléments d'un tableu, qui peut être délimité par un symbole :

separator (optionnel) : le séparateur utilisé, vide par défaut
array : le tableau à rassembler

implode

$pokedex = [ 'pikachu', 'carapuce', 'onix' ];

// Retoure "pikachu / carapuce / onix"
echo implode( ' / ', $pokedex );