Notions avancées de PHP

Cette page couvre les tableaux et les fonctions, les deux outils qui permettent de générer du contenu par programmation plutôt que de l’écrire à la main. La comparaison avec JavaScript continue tout du long.

Les tableaux indexés

Un tableau indexé range des valeurs dans un ordre, accessibles par un indice qui commence à 0.

<?php
$products = ["sirop", "beurre", "tire"];
echo $products[0];      // sirop
$products[] = "sucre";  // ajoute à la fin
echo count($products);  // 4

En JavaScript :

let products = ["sirop", "beurre", "tire"];
console.log(products[0]);   // sirop
products.push("sucre");     // ajoute à la fin
console.log(products.length); // 4

Différences de surface

Ajout à la fin : PHP utilise $arr[] = valeur, JavaScript utilise arr.push(valeur). Taille : PHP utilise la fonction count($arr), JavaScript utilise la propriété arr.length.

Les tableaux associatifs

Un tableau associatif relie des clés à des valeurs.

<?php
$prices = ["sirop" => 14.50, "beurre" => 9.95];
echo $prices["sirop"];   // 14.5

En JavaScript :

let prices = { sirop: 14.50, beurre: 9.95 };
console.log(prices["sirop"]);   // 14.5

En PHP, le tableau indexé et le tableau associatif sont un seul et même type : array. En JavaScript, ce sont deux choses distinctes : un Array pour les listes, un Object (ou une Map) pour les paires clé-valeur. C’est la différence conceptuelle la plus importante de cette page.

▲ Conséquence

Comme tout est un array en PHP, une même variable peut mélanger indices numériques et clés nommées. C’est puissant, mais ça demande de la rigueur dans le nommage.

Parcourir un tableau : foreach

foreach est l’outil de prédilection pour parcourir un tableau.

<?php
$menu = ["Poutine" => 9.50, "Guédille" => 7.00];

foreach ($menu as $plat => $prix) {
  echo "{$plat} : {$prix} $";
}

En JavaScript :

let menu = { Poutine: 9.50, Guédille: 7.00 };

for (const [plat, prix] of Object.entries(menu)) {
  console.log(`${plat} : ${prix} $`);
}

foreach, clé et valeur

foreach ($arr as $valeur) donne chaque valeur. foreach ($arr as $cle => $valeur) donne la clé et la valeur.

Fonctions utiles sur les tableaux

PHP fournit plusieurs fonctions pour inspecter, transformer, filtrer, trier ou modifier des tableaux. Ces fonctions sont très utilisées, car elles évitent d’écrire manuellement des boucles pour des opérations courantes.

<?php

$prices = [14.50, 9.95, 7.00];

Taille, présence et recherche

<?php

$prices = [14.50, 9.95, 7.00];

count($prices);                        // 3

in_array(9.95, $prices);               // true
in_array(9.95, $prices, true);         // true, comparaison stricte recommandée

array_search(9.95, $prices);           // 1, retourne l'index de la valeur trouvée
array_search(20.00, $prices);          // false

Pour les tableaux associatifs, on utilise souvent les clés.

<?php

$product = [
    "name" => "Café",
    "price" => 3.50,
    "available" => true
];

array_key_exists("price", $product);   // true
isset($product["price"]);              // true

▲ array_key_exists ou isset ?

array_key_exists() vérifie si une clé existe dans le tableau, même si sa valeur est null. isset() vérifie si la clé existe et si sa valeur n’est pas null.

Filtrer un tableau avec array_filter

array_filter garde seulement les éléments qui respectent une condition.

<?php

$prices = [14.50, 9.95, 7.00];

$expensive = array_filter($prices, fn($price) => $price > 8);

// [14.50, 9.95]

▲ Attention aux clés

array_filter() conserve les clés du tableau original.
Si on veut réindexer le résultat comme une liste normale, on peut utiliser array_values().

<?php

$expensive = array_filter($prices, fn($price) => $price > 8);
$expensive = array_values($expensive);

// [14.50, 9.95]

Obtenir les clés ou les valeurs d’un tableau associatif

<?php

$product = [
    "name" => "Café",
    "price" => 3.50,
    "available" => true
];

array_keys($product);      // ["name", "price", "available"]
array_values($product);    // ["Café", 3.50, true]

array_values est aussi utile après un filtre, lorsque les index numériques ne sont plus consécutifs.

Trier un tableau

Certaines fonctions de tri modifient directement le tableau. Elles ne retournent pas une nouvelle copie triée.

<?php

$prices = [14.50, 9.95, 7.00];

sort($prices);       // trie en ordre croissant
// [7.00, 9.95, 14.50]

rsort($prices);      // trie en ordre décroissant
// [14.50, 9.95, 7.00]

Tableaux associatifs

Pour les tableaux associatifs, il existe des fonctions qui préservent ou utilisent les clés.

<?php

$productPrices = [
    "Café" => 3.50,
    "Thé" => 2.75,
    "Muffin" => 4.25
];

asort($productPrices);     // trie par valeur en conservant les clés
ksort($productPrices);     // trie par clé

Pour un tri personnalisé, on peut utiliser usort.

<?php

$products = [
    ["name" => "Café", "price" => 3.50],
    ["name" => "Thé", "price" => 2.75],
    ["name" => "Muffin", "price" => 4.25]
];

usort($products, fn($a, $b) => $a["price"] <=> $b["price"]);

Ajouter et retirer des éléments

<?php

$names = ["Alice", "Bob"];

$names[] = "Charlie";             // ajoute à la fin
array_push($names, "Diane");      // ajoute aussi à la fin

$last = array_pop($names);        // retire et retourne le dernier élément
$first = array_shift($names);     // retire et retourne le premier élément

array_unshift($names, "Zoé");    // ajoute au début

En PHP, la syntaxe $array[] = ... est souvent plus simple que array_push lorsqu’on ajoute un seul élément.

Combiner, découper et modifier des tableaux

<?php

$first = ["Alice", "Bob"];
$second = ["Charlie", "Diane"];

$merged = array_merge($first, $second);
// ["Alice", "Bob", "Charlie", "Diane"]

<?php

$names = ["Alice", "Bob", "Charlie", "Diane"];

$slice = array_slice($names, 1, 2);
// ["Bob", "Charlie"]

array_splice modifie le tableau original.

<?php

$names = ["Alice", "Bob", "Charlie", "Diane"];

array_splice($names, 1, 2, ["Béatrice"]);

// ["Alice", "Béatrice", "Diane"]

Convertir entre chaîne et tableau

Même si ce ne sont pas strictement des fonctions de tableau, explode et implode sont souvent utilisées avec des tableaux.

<?php

$line = "Alice,Bob,Charlie";

$names = explode(",", $line);
// ["Alice", "Bob", "Charlie"]

$text = implode(", ", $names);
// "Alice, Bob, Charlie"

Résumé des fonctions fréquentes

Fonction	Rôle
count($array)	Compter les éléments
in_array($value, $array, true)	Vérifier si une valeur est présente
array_search($value, $array)	Trouver l’index ou la clé d’une valeur
array_key_exists($key, $array)	Vérifier si une clé existe
array_map($callback, $array)	Transformer chaque élément
array_filter($array, $callback)	Garder seulement certains éléments
array_reduce($array, $callback, $initial)	Réduire le tableau à une seule valeur
array_sum($array)	Calculer la somme
array_keys($array)	Obtenir les clés
array_values($array)	Obtenir ou réindexer les valeurs
array_column($array, $key)	Extraire une colonne
sort($array)	Trier une liste en ordre croissant
rsort($array)	Trier une liste en ordre décroissant
asort($array)	Trier par valeur en conservant les clés
ksort($array)	Trier par clé
usort($array, $callback)	Trier avec une fonction personnalisée
array_merge($a, $b)	Fusionner des tableaux
array_slice($array, $start, $length)	Extraire une partie du tableau
array_splice($array, $start, $length, $replacement)	Remplacer une partie du tableau
array_unique($array)	Retirer les doublons
array_reverse($array)	Inverser l’ordre
array_pop($array)	Retirer le dernier élément
array_shift($array)	Retirer le premier élément
array_unshift($array, $value)	Ajouter au début
$array[] = $value	Ajouter à la fin

Fonctions pures et fonctions qui modifient le tableau

Certaines fonctions retournent un nouveau tableau, comme array_map, array_filter, array_merge ou array_slice. D’autres modifient directement le tableau reçu, comme sort, rsort, asort, ksort, usort, array_pop, array_shift, array_unshift et array_splice.

Les fonctions

<?php
function computeTotal($price, $quantity = 1) {
  return $price * $quantity;
}

echo computeTotal(9.95);       // 9.95 (quantity vaut 1 par défaut)
echo computeTotal(9.95, 3);    // 29.85

En JavaScript :

function computeTotal(price, quantity = 1) {
  return price * quantity;
}

console.log(computeTotal(9.95));      // 9.95
console.log(computeTotal(9.95, 3));   // 29.85

Presque identique

La déclaration de fonction est très proche : mot-clé function, paramètres, valeurs par défaut, return. La seule différence visible est le $ sur les paramètres en PHP. On peut aussi typer : function computeTotal(float $price, int $quantity = 1): float.

La portée des variables : une vraie différence

C’est ici que PHP et JavaScript divergent nettement.

<?php
$taux = 0.15;

function pourboire($montant) {
  // $taux n'existe PAS ici : les fonctions PHP ne voient pas
  // les variables extérieures.
  return $montant * 0.15;
}

En JavaScript, une fonction capture les variables de son entourage (une closure) :

let taux = 0.15;

function pourboire(montant) {
  return montant * taux;   // taux est visible ici
}

Passez les données par paramètres et récupérez les résultats par return plutôt que de compter sur des variables globales : le code reste prévisible et testable.

Quiz. En PHP, comment une fonction accède-t-elle à une variable déclarée à l'extérieur ?

• Automatiquement, comme une closure JavaScript
• En la recevant en paramètre, ou via use pour une fonction anonyme
• Ce n'est jamais possible

Quiz. En PHP, le tableau indexé et le tableau associatif sont...

• Deux types distincts, comme Array et Object en JavaScript
• Un seul et même type : array
• Réservés aux bases de données