Aller au contenu
Framework côté serveur

Structures de contrôle

Les structures de contrôle

Les structures de contrôle permettent de contrôler l'exécution d'un script. Elles permettent de tester une condition et d'exécuter un bloc de code si la condition est vraie, ou de répéter un bloc de code un nombre précis de fois.

Voici une liste des principales structures de contrôle en PHP :

  1. if : permet de tester une condition et d'exécuter un bloc de code si la condition est vraie.
  2. if...else : permet de tester une condition et d'exécuter un premier bloc de code si la condition est vraie, et un second bloc de code si la condition est fausse.
  3. if...elseif...else : permet de tester plusieurs conditions et d'exécuter un bloc de code correspondant à la première condition qui est vraie. Si aucune condition n'est vraie, un dernier bloc de code peut être exécuté.
  4. switch : permet de tester plusieurs valeurs possibles pour une expression et d'exécuter un bloc de code correspondant à la première valeur qui correspond.
  5. match : permet de tester une valeur et d'exécuter un bloc de code correspondant à la première valeur qui correspond. Cette structure est disponible à partir de PHP 8.0.
  6. while : permet de répéter un bloc de code tant qu'une condition est vraie.
  7. do...while : permet de répéter un bloc de code au moins une fois, puis de continuer à le répéter tant qu'une condition est vraie.
  8. for : permet de répéter un bloc de code un certain nombre de fois en spécifiant une condition de fin et un compteur.
  9. foreach : permet de parcourir les éléments d'un tableau ou d'un objet et de les traiter un à un.

Les conditions

Les conditions permettent de tester une valeur ou une expression et d'exécuter un bloc de code si la condition est vraie.

La structure if

La structure if permet de tester une condition et d'exécuter un bloc de code si cette condition est vraie. La syntaxe de base de la structure if est la suivante :

if (condition) {
// code à exécuter si la condition est vraie
}

Par exemple, si on veut vérifier si une variable $age est supérieure à 18 et afficher un message en conséquence, on peut utiliser la structure if de la façon suivante :

if ($age > 18) {
echo "Vous êtes majeur.";
}

Il est également possible d'ajouter une clause else pour exécuter un bloc de code si la condition est fausse :

if ($age > 18) {
echo "Vous êtes majeur.";
} else {
echo "Vous êtes mineur.";
}

Il est possible d'ajouter autant de clauses elseif que nécessaire pour tester plusieurs conditions :

if ($age > 18) {
    echo "Vous êtes majeur.";
} elseif ($age == 18) {
echo "Vous avez 18 ans.";
} else {
echo "Vous êtes mineur.";
}

la structure switch

La structure switch permet de tester plusieurs valeurs possibles pour une expression et d'exécuter un bloc de code correspondant à la première valeur qui correspond. Elle peut être utilisée pour remplacer plusieurs instructions if...elseif...else.

Voici la syntaxe de base de la structure switch :

switch (expression) {
    case valeur1:
        // code à exécuter si expression vaut valeur1
        break;
    case valeur2:
        // code à exécuter si expression vaut valeur2
        break;
    // ...
    default:
        // code à exécuter si aucune des valeurs ne correspond
        break;
}

L'instruction break permet de quitter la structure switch une fois que le bloc de code correspondant à la valeur de l'expression a été exécuté. Si break n'est pas utilisé, le code suivant sera également exécuté.

Voici un exemple d'utilisation de la structure switch pour afficher un message en fonction de la valeur d'une variable $note :

switch ($note) {
    case 0:
    case 1:
    case 2:
        echo "Insuffisant.";
        break;
    case 3:
    case 4:
        echo "Moyen.";
        break;
    case 5:
    case 6:
        echo "Assez bien.";
        break;
    case 7:
    case 8:
    case 9:
        echo "Bien.";
        break;
    case 10:
        echo "Très bien.";
        break;
    default:
        echo "Note non valide.";
        break;
}

Lorsqu'une structure switch est exécutée, l'expression spécifiée est évaluée et sa valeur est comparée aux valeurs des différents case. Si une valeur correspond, le bloc de code associé est exécuté. Si aucune valeur ne correspond, le bloc de code associé à la clause default est exécuté (si elle est présente).

La structure match

La structure match permet de tester une valeur et d'exécuter un bloc de code correspondant à la première valeur qui correspond. Elle est similaire à la structure switch, mais offre une syntaxe différente et de nouvelles fonctionnalités.

Voici la syntaxe de base de la structure match :

match (expression) {
    valeur1 => bloc de code,
    valeur2 => bloc de code,
    // ...
    default => bloc de code,
}

Voici un exemple d'utilisation de la structure match pour afficher un message en fonction de la valeur d'une variable $note :

match ($note) {
    0 | 1 | 2  => echo "Insuffisant.",
    3 | 4      => echo "Moyen.",
    5 | 6      => echo "Assez bien.",
    7 | 8 | 9  => echo "Bien.",
    10         => echo "Très bien.",
    default    => echo "Note non valide.",
}

La structure match est souvent plus appropriée que la structure switch lorsque l'expression à tester est complexe et que la comparaison de valeurs doit se faire à l'aide d'opérateurs de comparaison ou de fonctions de test.

Par exemple, si on veut vérifier si une variable $x est supérieure à 10 et inférieure à 20, on peut utiliser la structure match de la façon suivante :

match ($x) {
    $x > 10 and $x < 20   => echo "x est compris entre 10 et 20.",
    default               => echo "x n'est pas compris entre 10 et 20.",
}

La structure match est disponible à partir de PHP 8.0.

Les boucles

Les boucles permettent d'exécuter plusieurs fois un bloc de code. Elles sont très utiles pour traiter des tableaux.

Voici une liste des principales boucles disponibles en PHP :

  • while : permet de répéter un bloc de code tant qu'une condition est vraie.
  • do...while : permet de répéter un bloc de code au moins une fois, puis de continuer à le répéter tant qu'une condition est vraie.
  • for : permet de répéter un bloc de code un certain nombre de fois en spécifiant une condition de fin et un compteur.
  • foreach : permet de parcourir les éléments d'un tableau ou d'un objet et de les traiter un à un.
  • goto : permet de sauter à un endroit précis du code. Elle est déconseillée, car elle rend le code difficile à lire et à maintenir. Elle est également considérée comme une mauvaise pratique en programmation.

Source : https://xkcd.com/292/

La boucle while

La boucle while permet de répéter un bloc de code tant qu'une condition est vraie. La syntaxe de base de la boucle while est la suivante :

while (condition) {
    // code à exécuter tant que la condition est vraie
}

Voici un exemple d'utilisation de la boucle while pour afficher les entiers de 1 à 10 :

$i = 1;
while ($i <= 10) {
    echo $i;
    $i++;
}

Il est important de noter que la condition doit être mise à jour à l'intérieur de la boucle pour éviter une boucle infinie. Si la condition n'est jamais mise à jour, la boucle continuera à s'exécuter indéfiniment.

La boucle do...while

La boucle do...while permet de répéter un bloc de code au moins une fois, puis de continuer à le répéter tant qu'une condition est vraie. La syntaxe de base de la boucle do...while est la suivante :

do {
    // code à exécuter au moins une fois
} while (condition);

Voici un exemple d'utilisation de la boucle do...while pour afficher les entiers de 1 à 10 :

$i = 1;
do {
    echo $i;
    $i++;
} while ($i <= 10);

Il est important de noter que la condition est vérifiée à la fin de chaque itération, ce qui signifie que le bloc de code sera exécuté au moins une fois même si la condition est fausse.

La boucle for

La boucle for permet de répéter un bloc de code un certain nombre de fois en spécifiant une condition de fin et un compteur. La syntaxe de base de la boucle for est la suivante :

for (initialisation; condition; incrémentation) {
    // code à exécuter tant que la condition est vraie
}

Voici un exemple d'utilisation de la boucle for pour afficher les entiers de 1 à 10 :

for ($i = 1; $i <= 10; $i++) {
    echo $i;
}

La boucle for est souvent utilisée lorsque le nombre de répétitions est connu à l'avance, car elle permet de spécifier une condition de fin et un compteur de manière claire et concise.

La boucle for est similaire à la boucle while, mais elle permet de regrouper toutes les informations nécessaires à la boucle (initialisation, condition et incrémentation) en un seul endroit. Elle est donc souvent plus lisible et plus facile à comprendre que la boucle while.

La boucle for précédente peut être réécrite de la façon suivante en utilisant une boucle while :

$i = 1;
while ($i <= 10) {
    echo $i;
    $i++;
}

Il est parfois nécessaire d'inverser l'ordre de parcours d'une boucle, c'est-à-dire de commencer par la fin et de se déplacer vers le début. Cela peut être utile lorsque l'on veut parcourir un tableau ou une chaîne de caractères à l'envers, par exemple.

Pour inverser une boucle, il suffit de changer l'opérateur de comparaison de la condition de fin de la boucle. Par exemple, pour inverser une boucle for qui compte de 1 à 10, il suffit de changer l'opérateur de comparaison de <= à >= :

for ($i = 10; $i >= 1; $i--) {
    echo $i;
}

Il est également possible d'inverser une boucle while en modifiant la condition de la même manière. Par exemple :

$i = 10;
while ($i >= 1) {
    echo $i;
    $i--;
}

Il est important de noter que l'incrémentation ou la décrémentation de la variable de compteur doit être modifiée en conséquence pour qu'elle corresponde à l'ordre de parcours inverse de la boucle.

Il est possible d'imbriquer plusieurs boucles for, c'est-à-dire de mettre une boucle for à l'intérieur d'une autre boucle for. Cette technique est souvent utilisée pour parcourir des tableaux à plusieurs dimensions, comme un tableau à deux dimensions.

Voici un exemple de boucles for imbriquées qui parcourent un tableau à deux dimensions :

$tableau = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
for ($i = 0; $i < count($tableau); $i++) {
    for ($j = 0; $j < count($tableau[$i]); $j++) {
        echo $tableau[$i][$j];
    }
}

Dans cet exemple, la boucle for externe parcourt chaque ligne du tableau à deux dimensions, tandis que la boucle for interne parcourt chaque colonne de chaque ligne. Le résultat de cette boucle sera l'affichage des entiers de 1 à 9 dans l'ordre.

Les boucles imbriquées sont utiles lorsqu'il est nécessaire de parcourir des tableaux à plusieurs dimensions ou lorsqu'il est nécessaire de répéter un bloc de code plusieurs fois pour chaque valeur d'une variable. Elles peuvent également être utilisées pour créer des motifs ou des structures de données complexes.

Il est important de noter que les boucles imbriquées peuvent être difficiles à comprendre et à déboguer si elles sont mal utilisées.

La boucle foreach

La boucle foreach permet de parcourir les éléments d'un tableau ou d'un objet et de les traiter un à un. La syntaxe de base de la boucle foreach est la suivante :

foreach (tableau ou objet as $variable) {
    // code à exécuter pour chaque élément du tableau ou de l'objet
}

Voici un exemple d'utilisation de la boucle foreach pour afficher les éléments d'un tableau :

$tableau = [1, 2, 3, 4, 5];
foreach ($tableau as $element) {
    echo $element;
}

Dans cet exemple, la boucle foreach parcourt chaque élément du tableau et affiche sa valeur.

Il est également possible de parcourir les éléments d'un tableau associatif en utilisant la boucle foreach. Un tableau associatif est un tableau qui a des clés et des valeurs, au lieu d'avoir des indices numériques comme dans un tableau ordinaire.

Voici un exemple de boucle foreach qui parcourt les clés et les valeurs d'un tableau associatif :

$tableau = ["cle1" => "valeur1", "cle2" => "valeur2", "cle3" => "valeur3"];
foreach ($tableau as $cle => $valeur) {
    echo "$cle : $valeur";
}

Dans cet exemple, la boucle foreach parcourt chaque élément du tableau associatif et affiche la clé et la valeur de chaque élément.

Break et continue

Break

Le mot-clé break permet d'interrompre l'exécution d'une boucle. Il peut être utilisé dans une boucle for, une boucle while, une boucle do...while ou une boucle foreach.

Voici un exemple de boucle for qui affiche les entiers de 1 à 10 et qui s'arrête lorsque la valeur de la variable de compteur est égale à 5 :

for ($i = 1; $i <= 10; $i++) {
    if ($i == 5) {
        break;
    }
    echo $i;
}

// Affiche 1234

Continue

Le mot-clé continue permet d'interrompre l'exécution de l'itération courante d'une boucle et de passer à l'itération suivante. Il peut être utilisé dans une boucle for, une boucle while, une boucle do...while ou une boucle foreach.

Voici un exemple de boucle for qui affiche les entiers de 1 à 10 et qui saute l'itération courante lorsque la valeur de la variable de compteur est égale à 5 :

for ($i = 1; $i <= 10; $i++) {
    if ($i == 5) {
        continue;
    }
    echo $i;
}

// Affiche 1234678910

Exercices de lecture

If / elseif / else

1.1. Donnez le résultat de l’exécution du programme suivant :

$age = 25;

if ($age < 18) {
    echo "Vous êtes mineur.";
} elseif ($age >= 18 && $age < 30) {
    echo "Vous êtes un adulte jeune.";
} else {
    echo "Vous êtes un adulte.";
}

1.2. Donnez le résultat de l’exécution du programme suivant :

$x = 5;

if ($x > 10) {
    $x = 10;
}

if ($x < 0) {
    $x = 0;
}

if ($x % 2 == 0) {
    echo "La valeur de x est paire et égale à " . $x;
} else {
    echo "La valeur de x est impaire et égale à " . $x;
}

1.3. Donnez le résultat de l’exécution du programme suivant :

$score = 75;

if ($score > 100) {
    $score = 100;
}

if ($score < 0) {
    $score = 0;
}

if ($score >= 90) {
    echo "Vous avez obtenu un A!";
} elseif ($score >= 80) {
    echo "Vous avez obtenu un B!";
} elseif ($score >= 70) {
    echo "Vous avez obtenu un C!";
} elseif ($score >= 60) {
    echo "Vous avez obtenu un D!";
} else {
    echo "Vous avez obtenu un E (échec)";
}

1.4. Donnez le résultat de l’exécution du programme suivant :

$orderTotal = 250;
$couponCode = "DISCOUNT10";

if ($couponCode == "FREESHIPPING") {
    echo "La livraison est gratuite!";
} elseif ($couponCode == "DISCOUNT10") {
    $orderTotal = $orderTotal - ($orderTotal * 0.1);
    echo "10% de remise appliquée! Montant total de la commande : $" . $orderTotal;
} else {
    echo "Aucun coupon valide n'a été entré. Montant total de la commande : $" . $orderTotal;
}

1.5. Donnez le résultat de l’exécution du programme suivant :

$a = 5;
$b = 10;
$c = 15;

if (($a + $b > $c) && ($a + $c > $b) && ($b + $c > $a)) {
    if (($a ** 2 + $b ** 2 == $c ** 2) || ($a ** 2 + $c ** 2 == $b ** 2) || ($b ** 2 + $c ** 2 == $a ** 2)) {
        echo "Les nombres sont des côtés d'un triangle rectangle.";
    } else {
        echo "Les nombres sont des côtés d'un triangle quelconque.";
    }
} else {
    echo "Les nombres ne peuvent pas être des côtés d'un triangle.";
}

1.6. Donnez le résultat de l’exécution du programme suivant :

$temp = -10;
$unit = "C";
$convertedTemp = 0;

if ($unit == "F") {
    $convertedTemp = ($temp - 32) * (5/9);
    echo $temp . " degrés Fahrenheit est égal à " . round($convertedTemp, 2) . " degrés Celsius.";
} elseif ($unit == "K") {
    $convertedTemp = $temp - 273.15;
    echo $temp . " degrés Kelvin est égal à " . round($convertedTemp, 2) . " degrés Celsius.";
} else {
    echo $temp . " degrés Celsius est déjà en degrés Celsius.";
}

1.7. Donnez le résultat de l’exécution du programme suivant :

$text = "This is an example of text";

if (strpos($text, "example") !== false) {
    $text = str_replace("example", "EXAMPLE", $text);
}

if (strlen($text) > 20) {
    $text = substr($text, 0, 20) . "...";
}

echo $text . PHP_EOL;

Switch

2.1. Donnez le résultat de l’exécution du programme suivant :

$item = "Orange";
$price = 0;

switch ($item) {
    case "Apple":
        $price = 0.5;
        break;
    case "Banana":
        $price = 0.25;
        break;
    case "Orange":
        $price = 0.75;
        break;
    case "Mango":
        $price = 1.5;
        break;
    default:
        echo "Invalid item.";
}

$quantity = 10;
$total = $price * $quantity;

echo "Item: " . $item . "<br>";
echo "Price: $" . $price . "<br>";
echo "Quantity: " . $quantity . "<br>";
echo "Total: $" . $total . "<br>";

2.2. Donnez le résultat de l’exécution du programme suivant :

$input = "b";
$output = "";

switch ($input) {
    case "a":
    case "e":
    case "i":
    case "o":
    case "u":
        $output = "Input is a vowel.";
        break;
    case "1":
    case "2":
    case "3":
    case "4":
    case "5":
    case "6":
    case "7":
    case "8":
    case "9":
    case "0":
        $output = "Input is a number.";
        break;
    default:
        $output = "Input is a consonant.";
}
echo $output;

2.3. Donnez le résultat de l’exécution du programme suivant :

$char = '?';
$code = ord($char);

switch (true) {
    case ($code > 64 && $code < 91):
        echo "Input is an uppercase letter";
        break;
    case ($code > 96 && $code < 123):
        echo "Input is a lowercase letter";
        break;
    case ($code > 47 && $code < 58):
        echo "Input is a number";
        break;
    case ($code > 32 && $code < 48) || ($code > 57 && $code < 65) || ($code > 90 && $code < 97) || ($code > 122 && $code < 127):
        echo "Input is a special character";
        break;
    default:
        echo "Invalid input";
}

Match

3.1. Donnez le résultat de l’exécution du programme suivant :

$vehicle = "motorcycle";

$result = match ($vehicle) {
    "car" => "This is a car",
    "truck" => "This is a truck",
    "motorcycle" => "This is a motorcycle",
    "bicycle" => "This is a bicycle",
    default => "This is not a car, truck, motorcycle or bicycle"
};

echo $result;

3.2. Donnez le résultat de l’exécution du programme suivant :

$student = [
    'name' => 'John Doe',
    'age' => 22,
    'gender' => 'male',
    'grade' => 'A',
    'absences' => 2,
];

$result = match (true) {
    $student['age'] < 18 => 'Student is under 18 years old',
    $student['gender'] == 'male' && $student['grade'] == 'A' => 'Male student with grade A',
    $student['gender'] == 'female' && $student['absences'] == 0 => 'Female student with no absences',
    $student['age'] >= 18 && $student['grade'] == 'F' && $student['absences'] > 5 => 'Adult student with grade F and more than 5 absences',
    default => 'Student does not fit in any specific category'
};

echo $result;

While

4.1.1. Donnez le résultat de l’exécution du programme suivant :

$i = 1;
while ($i <= 5) {
    echo $i . PHP_EOL;
    $i++;
}

4.2. Donnez le résultat de l’exécution du programme suivant :

$numbers = [3, 9, 15, 5, 8, 14];
$i = 0;
while ($i < count($numbers)) {
    if ($numbers[$i] % 2 == 0) {
        echo $numbers[$i] . " is even" . PHP_EOL;
    } else {
        echo $numbers[$i] . " is odd" . PHP_EOL;
    }
    $i++;
}

4.3. Donnez le résultat de l’exécution du programme suivant :

$list = [1, 2, 3, 4, 5];
$i = 0;
$sum = 0; // (max/2)*(max+1)
$max = 0;
$min = PHP_INT_MAX;

while($i < count($list)) {
    if($list[$i] > $max) {
        $max = $list[$i];
    }

    if($list[$i] < $min) {
        $min = $list[$i];
    }

    $sum += $list[$i];
    $i++;
}

$average = $sum / count($list);
echo "The sum of numbers is: " . $sum . PHP_EOL;
echo "The minimum number is: " . $min . PHP_EOL;
echo "The maximum number is: " . $max . PHP_EOL;
echo "The average of numbers is: " . $average . PHP_EOL;

4.4. Donnez le résultat de l’exécution du programme suivant :

$input = [
    ['name' => 'John', 'age' => 25, 'gender' => 'male'],
    ['name' => 'Jane', 'age' => 20, 'gender' => 'female'],
    ['name' => 'Mike', 'age' => 27, 'gender' => 'male'],
    ['name' => 'Emily', 'age' => 31, 'gender' => 'female'],
    //...
];
$i = 0;
$totalAge = 0;
$totalMales = 0;
$totalFemales = 0;

while ($i < count($input)) {
    $totalAge += $input[$i]['age'];
    if($input[$i]['gender'] === 'male') {
        $totalMales++;
    } else {
        $totalFemales++;
    }
    $i++;
}
$averageAge = $totalAge / count($input);
echo "Total number of males: " . $totalMales . PHP_EOL;
echo "Total number of females: " . $totalFemales . PHP_EOL;
echo "Average age of all individuals: " . $averageAge . PHP_EOL;

Do While

5.1. Donnez le résultat de l’exécution du programme suivant :

$password = "";
do {
    $password = readline("Entrez votre mot de passe (au moins 8 caractères, une majuscule, une minuscule et un chiffre): ");
} while (!preg_match("/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)[A-Za-z\d]{8,}$/", $password));

echo "Mot de passe valide!";

For

6.1. Donnez le résultat de l’exécution du programme suivant :

for ($i = 1; $i < 10; $i++) {
    echo $i . PHP_EOL;
}

6.2. Donnez le résultat de l’exécution du programme suivant :

$text = "This is a example of text";

for ($i = 0; $i < strlen($text); $i++) {
    echo $text[$i] . '-';
}

6.3. Donnez le résultat de l’exécution du programme suivant :

$text = "This is a example of text";
$vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'];
$newText = '';

for ($i = 0; $i < strlen($text); $i++) {
    if (!in_array($text[$i], $vowels)) {
        $newText .= $text[$i];
    }
}
echo $newText;

6.4. Donnez le résultat de l’exécution du programme suivant :

$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

for ($i = count($numbers) - 1; $i >= 0; $i--) {
    if ($numbers[$i] % 2 == 0) {
        echo $numbers[$i] . ' is even' . PHP_EOL;
    } else {
        echo $numbers[$i] . ' is odd' . PHP_EOL;
    }
}

6.5. Donnez le résultat de l’exécution du programme suivant :

$text = "ThiS IS An exAMPle Of TeXT";
$search = "text";
$newText = "";

if(preg_match('/[A-Z]/', $text)){
    $text = strtolower($text);
}

if (strpos($text, $search) !== false) {
    $text = str_replace($search, strtoupper($search), $text);
}

for ($i = 0; $i < strlen($text); $i++) {
    if ($i % 2 == 0) {
        $newText .= strtoupper($text[$i]);
    } else {
        $newText .= $text[$i];
    }
}

echo $newText . PHP_EOL;

6.6. Donnez le résultat de l’exécution du programme suivant :

$numbers = [5, 3, 2, 1];

for ($i = 0; $i < count($numbers); $i++) {
    for ($j = $i+1; $j < count($numbers); $j++) {
        echo $numbers[$i] . ' * ' . $numbers[$j] . ' = ' . $numbers[$i] * $numbers[$j] . PHP_EOL;
    }
}

Foreach

7.1. Donnez le résultat de l’exécution du programme suivant :

$fruits = ['apple', 'banana', 'orange', 'strawberry'];
foreach ($fruits as $fruit) {
    echo $fruit . PHP_EOL;
}

7.2. Donnez le résultat de l’exécution du programme suivant :

$employees = [
    ['name' => 'John Doe', 'salary' => 70000, 'position' => 'Manager'],
    ['name' => 'Jane Smith', 'salary' => 60000, 'position' => 'Developer'],
    ['name' => 'Bob Ross', 'salary' => 55000, 'position' => 'Designer'],
    ['name' => 'Charlie Brown', 'salary' => 65000, 'position' => 'Developer'],
];
$totalSalary = 0;
foreach ($employees as $employee) {
    if($employee['position'] === "Developer"){
        echo $employee['name'] . " - " . $employee['salary'] . PHP_EOL;
        $totalSalary += $employee['salary'];
    }
}
echo "Total salaire des développeurs: " . $totalSalary;

7.3. Donnez le résultat de l’exécution du programme suivant :

$data = [
    ['first_name' => 'John', 'last_name' => 'Doe', 'age' => 25],
    ['first_name' => 'Jane', 'last_name' => 'Smith', 'age' => 30],
    ['first_name' => 'Bob', 'last_name' => 'Ross', 'age' => 35],
    ['first_name' => 'Charlie', 'last_name' => 'Brown', 'age' => 40],
    ['first_name' => 'Maggie', 'last_name' => 'Simpson', 'age' => 3],
];
$oldest_person = "";
$youngest_person = "";
$oldest_age = 0;
$youngest_age = PHP_INT_MAX;
foreach ($data as $item) {
    $fullname = $item['first_name'] . ' ' . $item['last_name'];
    if($item['age'] > $oldest_age) {
        $oldest_age = $item['age'];
        $oldest_person = $fullname;
    }
    if($item['age'] < $youngest_age) {
        $youngest_age = $item['age'];
        $youngest_person = $fullname;
    }
}
echo "The oldest person is $oldest_person with age $oldest_age \n";
echo "The youngest person is $youngest_person with age $youngest_age";

7.4. Donnez le résultat de l’exécution du programme suivant :

$data = [
    ['first_name' => 'John', 'last_name' => 'Doe', 'age' => 25, 'gender' => 'male'],
    ['first_name' => 'Jane', 'last_name' => 'Smith', 'age' => 30, 'gender' => 'female'],
    ['first_name' => 'Bob', 'last_name' => 'Ross', 'age' => 35, 'gender' => 'male'],
    ['first_name' => 'Charlie', 'last_name' => 'Brown', 'age' => 40, 'gender' => 'male'],
    ['first_name' => 'Maggie', 'last_name' => 'Simpson', 'age' => 20, 'gender' => 'female'],
];
$male_counter = 0;
$female_counter = 0;
$male_age_sum = 0;
$female_age_sum = 0;
foreach ($data as $item) {
    if($item['gender'] == 'male') {
        $male_counter++;
        $male_age_sum += $item['age'];
    }
    elseif ($item['gender'] == 'female') {
        $female_counter++;
        $female_age_sum += $item['age'];
    }
}
$male_age_avg = $male_age_sum / $male_counter;
$female_age_avg = $female_age_sum / $female_counter;
echo "The average age of males is $male_age_avg \n";
echo "The average age of females is $female_age_avg";

7.5. Donnez le résultat de l’exécution du programme suivant :

$employees = [
    ['first_name' => 'John', 'last_name' => 'Doe', 'projects' => ['project1', 'project2', 'project3']],
    ['first_name' => 'Jane', 'last_name' => 'Smith', 'projects' => ['project2', 'project4', 'project5']],
    ['first_name' => 'Bob', 'last_name' => 'Ross', 'projects' => ['project1', 'project3']],
    ['first_name' => 'Charlie', 'last_name' => 'Brown', 'projects' => ['project4', 'project6']],
    ['first_name' => 'Maggie', 'last_name' => 'Simpson', 'projects' => ['project2']],
];
$project1 = [];
$project2 = [];
$project3 = [];
$project4 = [];
$project5 = [];
$project6 = [];
foreach ($employees as $employee) {
    foreach ($employee['projects'] as $project) {
        if($project == 'project1') {
            $project1[] = $employee['first_name'] . ' ' . $employee['last_name'];
        } elseif($project == 'project2') {
            $project2[] = $employee['first_name'] . ' ' . $employee['last_name'];
        } elseif($project == 'project3') {
            $project3[] = $employee['first_name'] . ' ' . $employee['last_name'];
        } elseif($project == 'project4') {
            $project4[] = $employee['first_name'] . ' ' . $employee['last_name'];
        } elseif($project == 'project5') {
            $project5[] = $employee['first_name'] . ' ' . $employee['last_name'];
        } elseif($project == 'project6') {
            $project6[] = $employee['first_name'] . ' ' . $employee['last_name'];
        }
    }
}
echo "Employees working on project1: " . implode(", ",$project1) . "\n";
echo "Employees working on project2: " . implode(", ",$project2) . "\n";
echo "Employees working on project3: " . implode(", ",$project3) . "\n";
echo "Employees working on project4: " . implode(", ",$project4) . "\n";
echo "Employees working on project5: " . implode(", ",$project5) . "\n";
echo "Employees working on project6:

Exercices

If/elseif/else

Le système de notation

Dans cet exercice, vous allez créer un programme PHP qui fonctionne en ligne de commande. Le programme lira une note entrée par l'utilisateur et renverra une appréciation en fonction de cette note.

Voici les étapes de l'exercice :

  1. Commencez par lire une note entrée par l'utilisateur. Vous pouvez utiliser la fonction fgets(STDIN) pour cela.

  2. Ensuite, vérifiez si la note est valide. Une note valide est un nombre entre 0 et 20. Si la note n'est pas valide, affichez un message d'erreur et arrêtez le programme.

  3. Si la note est valide, utilisez des instructions if pour déterminer l'appréciation à afficher. Voici les appréciations correspondant à chaque intervalle de notes :

    • 0 à 10 : "Malheureusement, vous avez échoué."
    • 10 à 12 : "Vous avez juste réussi!"
    • 12 à 14 : "C'est un assez bien!"
    • 14 à 16 : "C'est un bien!"
    • 16 à 20 : "C'est un très bien!"

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer une note : ";
$note = fgets(STDIN);

// Vérifiez si la note est valide ici

// Utilisez des instructions if pour déterminer l'appréciation à afficher

Le calculateur de remise avancé

Dans cet exercice, vous allez créer un programme PHP qui fonctionne en ligne de commande. Le programme lira le prix d'un article et le statut de l'utilisateur (étudiant ou non) et calculera le prix final de l'article après remise.

Voici les étapes de l'exercice :

  1. Commencez par lire le prix de l'article et le statut de l'utilisateur. Vous pouvez utiliser la fonction fgets(STDIN) pour cela.

  2. Ensuite, utilisez des instructions if et elseif pour déterminer le taux de remise. Voici les remises correspondant à chaque intervalle de prix :

    • Plus de 100€ : 20% de remise
    • Entre 50€ et 100€ : 10% de remise
    • Moins de 50€ : pas de remise

  3. Si l'utilisateur est un étudiant, ajoutez une remise supplémentaire de 5%.

  4. Calculez le prix final de l'article après remise et affichez-le.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer le prix de l'article : ";
$prix = fgets(STDIN);

echo "L'utilisateur est-il un étudiant ? (oui/non) : ";
$estEtudiant = trim(fgets(STDIN)) == "oui";

// Déterminez le taux de remise ici

// Calculez le prix final ici

Le système de réservation de billets de cinéma

Dans cet exercice, vous créerez un programme PHP qui fonctionne en ligne de commande. Le programme lira le jour de la semaine, l'heure de la journée et l'âge du client, puis calculera le prix du billet de cinéma.

Voici les étapes de l'exercice :

  1. Commencez par lire le jour de la semaine, l'heure de la journée et l'âge du client. Vous pouvez utiliser la fonction fgets(STDIN) pour cela.

  2. Ensuite, utilisez des instructions if pour déterminer le prix de base du billet. Le prix de base est de 15€ les samedis et dimanches, et de 10€ les autres jours.

  3. Si l'heure est 20h ou plus, ajoutez un supplément de 2€ au prix du billet.

  4. Si le client est un enfant (12 ans ou moins) ou un senior (65 ans ou plus), appliquez une remise de 50% au prix du billet.

  5. Affichez le prix final du billet.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer le jour de la semaine : ";
$jour = trim(fgets(STDIN));

echo "Veuillez entrer l'heure de la journée : ";
$heure = fgets(STDIN);

echo "Veuillez entrer l'âge du client : ";
$age = fgets(STDIN);

// Déterminez le prix de base du billet ici

// Appliquez le supplément pour les heures tardives ici

// Appliquez la remise pour les enfants et les seniors ici

// Affichez le prix final du billet ici

Switch

Convertisseur de jours de la semaine

Dans cet exercice, vous créerez un programme qui convertit un nombre de 1 à 7 en jour de la semaine correspondant. Vous utiliserez l'instruction switch pour effectuer la conversion.

Voici les étapes de l'exercice :

  1. Demandez à l'utilisateur d'entrer un nombre de 1 à 7 pour représenter un jour de la semaine.

  2. Utilisez l'instruction switch pour convertir le nombre en jour de la semaine correspondant. Voici les correspondances :

    • 1 : "Lundi"
    • 2 : "Mardi"
    • 3 : "Mercredi"
    • 4 : "Jeudi"
    • 5 : "Vendredi"
    • 6 : "Samedi"
    • 7 : "Dimanche"

  3. Si l'utilisateur entre un nombre en dehors de la plage de 1 à 7, affichez un message d'erreur.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer un nombre de 1 à 7 : ";
$numeroJour = fgets(STDIN);

// Utilisez l'instruction switch pour convertir le nombre en jour de la semaine

Une fois que vous aurez terminé l’exercice, écrivez le en utilisant l’expression match.

Match

Gestion des catégories d'âge

Dans cet exercice, vous allez créer un programme qui prend en entrée l'âge d'une personne et détermine sa catégorie d'âge en utilisant la structure match. Vous explorerez comment match peut être une alternative plus concise et lisible par rapport à l'utilisation d'un if ou d'un switch.

Voici les étapes de l'exercice :

  1. Demandez à l'utilisateur d'entrer son âge.

  2. Utilisez la structure match pour déterminer la catégorie d'âge en fonction de l'âge de la personne. Voici les catégories d'âge et leurs plages correspondantes :

    • Moins de 18 ans : "Mineur"
    • De 18 à 64 ans : "Adulte"
    • 65 ans et plus : "Senior"

  3. Affichez la catégorie d'âge correspondante.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer votre âge : ";
$age = fgets(STDIN);

// Utilisez la structure match pour déterminer la catégorie d'âge

While

Calcul de la somme des entiers jusqu'à un nombre donné

Dans cet exercice, vous allez créer un programme qui calcule la somme des entiers de 1 jusqu'à un nombre donné par l'utilisateur en utilisant une boucle while.

Voici les étapes de l'exercice :

  1. Demandez à l'utilisateur d'entrer un nombre entier positif.

  2. Utilisez une boucle while pour calculer la somme des entiers de 1 jusqu'au nombre donné.

  3. Affichez la somme calculée.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer un nombre entier positif : ";
$nombre = intval(fgets(STDIN));

// Vérifiez si le nombre est positif ici

// Initialisez la somme et le compteur

// Utilisez une boucle while pour calculer la somme

// Affichez la somme calculée

Une fois l’exercice terminé, regardez comment le résoudre sans boucle.

Lancez la version avec une boucle en donnant des nombres de plus en plus grands jusqu’à ce que l’exécution prenne plus de 10 secondes.

Affichage des puissances de 2 jusqu'à un certain exposant

Dans cet exercice, vous allez créer un programme qui affiche les puissances de 2 jusqu'à un certain exposant donné par l'utilisateur en utilisant une boucle while.

Voici les étapes de l'exercice :

  1. Demandez à l'utilisateur d'entrer un exposant entier positif.

  2. Utilisez une boucle while pour afficher les puissances de 2, en commençant par 2^0 jusqu'à 2^exposant.

  3. Affichez chaque puissance de 2 à chaque itération de la boucle.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer un exposant entier positif : ";
$exposant = intval(fgets(STDIN));

// Vérifiez si l'exposant est positif ici

// Initialisez le compteur et la puissance

// Utilisez une boucle while pour afficher les puissances de 2

// Affichez chaque puissance de 2

Do while

Validation d'un mot de passe

Dans cet exercice, vous allez créer un programme qui demande à l'utilisateur de saisir un mot de passe et valide si ce mot de passe répond à certaines conditions prédéfinies. Vous utiliserez une boucle do while pour permettre à l'utilisateur de réessayer tant que le mot de passe n'est pas valide.

Voici les étapes de l'exercice :

  1. Définissez les conditions pour un mot de passe valide. Par exemple, le mot de passe doit avoir une longueur minimale de 8 caractères et contenir au moins une lettre majuscule, une lettre minuscule et un chiffre.

  2. Demandez à l'utilisateur de saisir un mot de passe.

  3. Utilisez une boucle do while pour valider le mot de passe. La boucle doit se répéter tant que le mot de passe ne répond pas aux conditions définies.

  4. Affichez un message indiquant si le mot de passe est valide ou non.

For

Calcul de la factorielle

Dans cet exercice, vous allez créer un programme qui calcule la factorielle d'un nombre donné par l'utilisateur en utilisant une boucle for.

La factorielle d'un nombre entier positif n, notée n!, est le produit de tous les entiers positifs de 1 à n. La formule pour calculer la factorielle est la suivante :

n! = n (n-1) (n-2) ... 2 * 1

Voici les étapes de l'exercice :

  1. Demandez à l'utilisateur d'entrer un nombre entier positif.

  2. Utilisez une boucle for pour calculer la factorielle du nombre donné.

  3. Affichez le résultat de la factorielle.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer un nombre entier positif : ";
$nombre = intval(fgets(STDIN));

// Vérifiez si le nombre est positif ici

// Initialisez la variable pour stocker le résultat de la factorielle

// Utilisez une boucle for pour calculer la factorielle

// Affichez le résultat de la factorielle

Inversion d'une chaîne de caractères

Dans cet exercice, vous allez créer un programme qui inverse une chaîne de caractères donnée par l'utilisateur en utilisant une boucle for.

Voici les étapes de l'exercice :

  1. Demandez à l'utilisateur d'entrer une chaîne de caractères.

  2. Utilisez une boucle for pour inverser la chaîne de caractères.

  3. Affichez la chaîne de caractères inversée.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

echo "Veuillez entrer une chaîne de caractères : ";
$chaine = trim(fgets(STDIN));

// Initialisez la variable pour stocker la chaîne de caractères inversée

// Utilisez une boucle for pour inverser la chaîne de caractères

// Affichez la chaîne de caractères inversée

Recherche dans un carnet d'adresses

Dans cet exercice, vous allez créer un programme qui permet de rechercher une personne dans un petit carnet d'adresses contenant le nom et l'adresse e-mail des personnes. Vous utiliserez une boucle for pour parcourir le carnet d'adresses et effectuer la recherche.

Voici les étapes de l'exercice :

  1. Déclarez un tableau associatif contenant les noms et les adresses e-mail des personnes.
$carnetAdresses = [
    "Alice" => "alice@example.com",
    "Bob" => "bob@example.com",
    "Charlie" => "charlie@example.com",
    "David" => "david@example.com"
];

  1. Demandez à l'utilisateur d'entrer le nom d'une personne à rechercher.

  2. Utilisez une boucle for pour parcourir le carnet d'adresses et rechercher la personne.

  3. Affichez l'adresse e-mail de la personne si elle est trouvée, ou un message indiquant que la personne n'a pas été trouvée.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

$carnetAdresses = [
    "Alice" => "alice@example.com",
    "Bob" => "bob@example.com",
    "Charlie" => "charlie@example.com",
    "David" => "david@example.com"
];

echo "Veuillez entrer le nom d'une personne à rechercher : ";
$nomRecherche = trim(fgets(STDIN));

// Utilisez une boucle for pour rechercher la personne dans le carnet d'adresses

// Affichez l'adresse e-mail de la personne si elle est trouvée

Partie 2: Distance de Levenshtein

Modifiez l’exercice précédent en utilisant la distance de Levenshtein. Cela va permettre de rendre la recherche résistante aux fautes de frappe.

La distance de Levenshtein est une mesure de la différence entre deux chaînes de caractères. Elle représente le nombre minimum d'opérations (insertion, suppression ou substitution d'un caractère) nécessaires pour transformer une chaîne en une autre.

En PHP, vous pouvez utiliser la fonction levenshtein() pour calculer la distance de Levenshtein entre deux chaînes. Voici un exemple d'utilisation :

$chaine1 = "chat";
$chaine2 = "chien";

$distance = levenshtein($chaine1, $chaine2);

echo "La distance de Levenshtein entre '$chaine1' et '$chaine2' est de $distance";

Dans cet exemple, la fonction levenshtein() calcule la distance de Levenshtein entre les chaînes "chat" et "chien". Le résultat affiché sera "La distance de Levenshtein entre 'chat' et 'chien' est de 2", car il faut deux opérations (une substitution et une insertion) pour transformer "chat" en "chien".

Foreach

Recherche du plus grand élément dans un tableau

Dans cet exercice, vous allez créer un programme qui recherche le plus grand élément dans un tableau donné en utilisant la boucle foreach.

Voici les étapes de l'exercice :

  1. Déclarez un tableau contenant plusieurs nombres.

  2. Initialisez une variable pour stocker le plus grand élément et assignez-lui une valeur initiale.

  3. Utilisez la boucle foreach pour parcourir le tableau et mettre à jour la variable du plus grand élément si un élément plus grand est trouvé.

  4. Affichez le plus grand élément trouvé.

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

$nombres = [15, 7, 22, 13, 9];

// Initialisez la variable pour stocker le plus grand élément

// Utilisez la boucle foreach pour rechercher le plus grand élément

// Affichez le plus grand élément

Calcul de la moyenne des notes

Dans cet exercice, vous allez créer un programme qui calcule la moyenne des notes d'un groupe d'étudiants en utilisant la boucle foreach.

Voici les étapes de l'exercice :

Voici un exemple de structure de code que vous pouvez utiliser pour commencer :

$notes = [
    "Alice" => 15.5,
    "Bob" => 12.8,
    "Charlie" => 18.2,
    "David" => 14.9
];

// Initialisez la variable pour stocker la somme des notes

// Initialisez la variable pour compter le nombre d'étudiants

// Utilisez la boucle foreach pour calculer la somme des notes et compter le nombre d'étudiants

// Calculez la moyenne en divisant la somme des notes par le nombre d'étudiants

// Affichez la moyenne calculée