Module 3 – Tableaux & chaînes de caractères

Niveau 1 – PHP fondamentaux

---

Objectifs

Tableaux (indexés et associatifs), chaînes de caractères et fonctions utiles : array_map, array_filter, explode, implode, et les fonctions mb_* pour le texte UTF-8. On voit comment parcourir et modifier des tableaux proprement.

---

Théorie

Tableaux (arrays)

En PHP, un tableau est une structure qui associe des clés à des valeurs. Les clés peuvent être des entiers (tableau indexé) ou des chaînes (tableau associatif), ou un mélange.

Tableau indexé

Les clés sont des entiers, par défaut à partir de 0.

$fruits = ["apple", "pear", "banana"];
// Equivalent to:
$fruits = [0 => "apple", 1 => "pear", 2 => "banana"];

echo $fruits[0];  // apple
echo $fruits[1];  // pear

Ajouter un élément :

$fruits[] = "kiwi";   // append, key = 3
array_push($fruits, "orange");  // same

Nombre d'éléments :

count($fruits);  // 5

Tableau associatif

Les clés sont des chaînes (ou des entiers personnalisés). Idéal pour représenter un « enregistrement ».

$user = [
    "first_name" => "Mary",
    "last_name"  => "Doe",
    "age"        => 28,
];
echo $user["first_name"];  // Mary

Vérifier si une clé existe :

if (array_key_exists("email", $user)) {
    echo $user["email"];
}
// Ou isset($user["email"])

Parcourir un tableau

Indexé :

foreach ($fruits as $fruit) {
    echo $fruit . "\n";
}
foreach ($fruits as $index => $fruit) {
    echo "$index : $fruit\n";
}

Associatif :

foreach ($user as $key => $value) {
    echo "$key = $value\n";
}

---

Fonctions utiles sur les tableaux

Fonction	Rôle	Exemple
count($arr)	Nombre d'éléments	count([1,2,3]) → 3
in_array($val, $arr)	La valeur existe ?	in_array("a", ["a","b"]) → true
array_push($arr, $v)	Ajouter en fin
array_pop($arr)	Retirer le dernier
array_merge($a, $b)	Fusionner deux tableaux
array_map(fn, $arr)	Appliquer une fonction à chaque élément	voir ci-dessous
array_filter($arr, fn)	Garder les éléments qui passent un test	voir ci-dessous
array_keys($arr)	Liste des clés
array_values($arr)	Liste des valeurs (ré-indexée)

array_map – Transformer chaque élément :

$numbers = [1, 2, 3, 4, 5];
$squares = array_map(fn($n) => $n * $n, $numbers);
// $squares = [1, 4, 9, 16, 25]

array_filter – Keep only matching elements:

$numbers = [1, 2, 3, 4, 5, 6];
$evens = array_filter($numbers, fn($n) => $n % 2 === 0);
// $evens = [2, 4, 6] (keys preserved: 1, 3, 5)
$evens = array_values($evens);  // re-index: [0=>2, 1=>4, 2=>6]

Sorting:

sort($fruits);     // sort by value (keys re-indexed)
asort($user);      // sort by value, keys preserved
ksort($user);      // sort by key
rsort($fruits);    // descending

---

Chaînes de caractères (strings)

Délimitation

• Guillemets doubles "..." : les variables sont interpolées et les séquences \n, \t sont interprétées.
• Guillemets simples '...' : pas d’interpolation, pas d’échappement (sauf \' et \\).

$firstName = "Mary";
echo "Hello $firstName";   // Hello Mary
echo 'Hello $firstName';   // Hello $firstName (literal)

Concaténation

$start = "Hello ";
$end = "!";
$message = $start . "Mary" . $end;  // Hello Mary!

Fonctions essentielles

Fonction	Rôle	Exemple
strlen($s)	Longueur (octets)	strlen("abc") → 3
mb_strlen($s)	Longueur en caractères (UTF-8)	mb_strlen("é") → 1
strpos($s, $needle)	Position de la sous-chaîne	strpos("hello", "ll") → 2
str_contains($s, $needle)	Contient ? (PHP 8+)	str_contains("hello", "ell") → true
substr($s, $start, $len)	Extraire une partie	substr("hello", 1, 3) → "ell"
str_replace($search, $replace, $s)	Replace	str_replace("a","o","hello") → "hello" (no 'a')
explode($sep, $s)	Chaîne → tableau	explode(",", "a,b,c") → ["a","b","c"]
implode($sep, $arr)	Tableau → chaîne	implode("-", [1,2,3]) → "1-2-3"
trim($s)	Enlever espaces début/fin	trim(" hi ") → "hi"
strtolower($s) / strtoupper($s)	Minuscules / majuscules

explode / implode – Très utilisés :

$line = "Mary;Doe;28";
$parts = explode(";", $line);
// ["Mary", "Doe", "28"]

$str = implode(" - ", ["a", "b", "c"]);
// "a - b - c"

Attention : pour du texte UTF-8 (accents, etc.), privilégier les fonctions mb_* (mb_strlen, mb_substr, etc.) pour compter ou découper par caractères et non par octets.

---

Exemples pas à pas

Exemple 1 : Liste d’utilisateurs et recherche

$users = [
    ["first_name" => "Mary",  "city" => "Lyon"],
    ["first_name" => "Paul",  "city" => "Paris"],
    ["first_name" => "Lea",   "city" => "Lyon"],
];
$fromLyon = array_filter($users, fn($u) => $u["city"] === "Lyon");
foreach ($fromLyon as $u) {
    echo $u["first_name"] . " - " . $u["city"] . "\n";
}

Exemple 2 : Extraire les initiales (prénom + nom)

function getInitials(string $firstName, string $lastName): string {
    $p = mb_substr(trim($firstName), 0, 1);
    $n = mb_substr(trim($lastName), 0, 1);
    return mb_strtoupper($p . $n);
}
echo getInitials("  mary  ", "Doe");  // MD

Exemple 3 : Parser une ligne CSV simple

$line = "Mary;Doe;28;Lyon";
$cols = explode(";", $line);
$person = [
    "first_name" => $cols[0],
    "last_name"  => $cols[1],
    "age"        => (int) $cols[2],
    "city"       => $cols[3],
];

---

Bonnes pratiques

1. Vérifier les clés avec array_key_exists() ou isset() avant d’accéder à $arr["key"].
2. UTF-8 : utiliser mb_* pour les longueurs et découpages de chaînes avec accents.
3. array_map / array_filter : préférer ces fonctions pour transformer/filtrer plutôt que des boucles manuelles quand c’est lisible.
4. explode : vérifier que la chaîne contient bien le séparateur, sinon gérer le cas (une seule valeur, etc.).

---

Exercices

Exercice 1 – Écrire une fonction average(array $values): float qui retourne la moyenne des valeurs du tableau (supposé non vide).

Exercice 2 – À partir de $sentence = "Hello world", utiliser explode et implode pour remplacer les espaces par - (résultat : "Hello-world").

Exercice 3 – Écrire une fonction maxArray(array $arr): ?float qui retourne le maximum des nombres du tableau, ou null si le tableau est vide.

Exercice 4 – Soit $words = ["php", "laravel", "web"]. Avec array_map, produire un tableau où chaque mot commence par une majuscule : ["Php", "Laravel", "Web"].

Solutions

Ex 1 :

function average(array $values): float {
    return array_sum($values) / count($values);
}

Ex 2 :

$sentence = "Hello world";
$result = implode("-", explode(" ", $sentence));

Ex 3 :

function maxArray(array $arr): ?float {
    if (count($arr) === 0) return null;
    return max($arr);
}

Ex 4 :

$words = ["php", "laravel", "web"];
$capitalized = array_map(fn($w) => ucfirst($w), $words);

---

Quiz – Module 3

Q1. Quelle est la différence entre un tableau indexé et un tableau associatif ?
Q2. Que retourne explode(",", "a,b,c") ?
Q3. Comment ajouter un élément à la fin d’un tableau sans préciser la clé ?
Q4. Pour du texte UTF-8, quelle famille de fonctions faut-il privilégier pour la longueur et les sous-chaînes ?
Q5. À quoi sert array_filter ?

Réponses

R1. Indexé : clés entières (souvent 0, 1, 2…). Associatif : clés chaînes (ou entiers personnalisés) pour représenter des champs nommés.

R2. Le tableau ["a", "b", "c"].

R3. $tab[] = $valeur; ou array_push($tab, $valeur);

R4. Les fonctions mb_* : mb_strlen, mb_substr, etc.

R5. À garder uniquement les éléments d’un tableau qui satisfont un critère (fonction de callback retournant true/false).

---

Examen pratique (partie Module 3)

À l’examen, vous pourrez avoir à créer et parcourir un tableau avec foreach, utiliser explode/implode, ou écrire une fonction avec array_map/array_filter. Les exercices du module sont un bon entraînement.

---

Suite

Module 4 – PHP & Formulaires : GET, POST, validation, XSS, formulaire d’inscription sécurisé.