Les Variables
Présentation
Les variables jouent un rôle fondamental au sein du processus de programmation, agissant comme des éléments clés de stockage et de manipulation des données. Chacune d'entre elles peut être assimilée à une boîte soigneusement étiquetée, offrant un emplacement destiné à contenir une valeur spécifique. Cette valeur peut adopter différentes natures, telles qu'un nombre entier, un nombre décimal, du texte, etc.
Au cours de l'exécution d'un programme, les valeurs à l'intérieur des variables ne sont pas fixes. Elles peuvent être modifiées, actualisées et manipulées au fur et à mesure que le programme progresse. En PHP, les variables peuvent même changer de nature au fil du temps, ce qui ajoute une flexibilité particulièrement puissante.
Nomenclature des variables
Lors de la création d'une variable, son nom doit être pertinent et respecter les règles suivantes :
- Les noms de variables sont toujours préfixés par le symbole $ et doivent commencer par une lettre ou un tiret bas _.
- Les caractères suivants peuvent être des lettres (sans accents de préférence), des chiffres ou des tirets bas _.
- Les variables sont sensibles à la casse : $maVariable et $mavariable sont deux variables distinctes.
- Il est déconseillé d'utiliser les noms réservés aux variables prédéfinies de PHP ($_GET, $_POST, $_FILES, etc.).
Pour plus de lisibilité, il est recommandé de suivre ces conventions courantes :
- Utiliser des noms descriptifs (ex. $nombreArticles plutôt que $na).
- Écrire les noms composés en camelCase (ex. $totalPanier, $dateCreation).
- Éviter les caractères accentués ou spéciaux, même s'ils sont techniquement autorisés.
Les Nombres (INT & FLOAT)
Commençons par les nombres. Pour assigner une valeur à une variable, vous devez utiliser le symbole égal = pour séparer la variable de sa valeur. De plus, à la fin de chaque instruction PHP, n'oubliez pas d'ajouter un point-virgule ;. Assurez-vous également d'encapsuler votre code PHP entre les balises appropriées : <?php et ?>.
<?php
$reponseUltime = 42;
?>
Nous venons d'assigner la valeur 42 à notre variable $reponseUltime. Il n'est pas nécessaire de préciser à PHP qu'il s'agit d'un nombre, il l'identifie automatiquement.
Si nous exécutons le code, rien ne s'affiche. C'est normal, car nous avons seulement assigné une valeur à notre variable. Pour afficher le contenu d'une variable, nous utilisons l'instruction echo, suivie d'un espace et du nom de la variable :
<?php
$reponseUltime = 42;
echo $reponseUltime; // Affiche : 42
?>
Maintenant, lorsque vous exécutez le code, la valeur de notre variable devrait être affichée.
Pour assigner un nombre réel à une variable, le principe est le même :
<?php
$nombreReel = 0.5;
?>
Les opérations arithmétiques
Il est possible d'effectuer différentes opérations arithmétiques à partir de nombres stockés dans des variables. PHP propose notamment l'addition +, la soustraction -, la multiplication *, la division /, le modulo % et la puissance **.
<?php
$a = 10;
$b = 3;
$addition = $a + $b; // 13
$soustraction = $a - $b; // 7
$multiplication = $a * $b; // 30
$division = $a / $b; // 3.3333333333333...
$reste = $a % $b; // 1
$puissance = $a ** $b; // 1000
?>
L'opérateur %, appelé modulo, renvoie le reste d'une division entière. Par exemple, 10 % 3 vaut 1, car 10 peut être divisé 3 fois par 3 et il reste 1. Cet opérateur est notamment pratique pour déterminer si un nombre est pair ou impair. Un nombre pair donne un reste de 0 lorsqu'il est divisé par 2.
<?php
$nombre = 8;
$reste = $nombre % 2;
echo $reste; // Affiche : 0
?>
Les opérateurs d'affectation combinée
Lorsqu'une opération utilise la valeur actuelle d'une variable pour ensuite réaffecter le résultat à cette même variable, PHP permet d'utiliser une écriture raccourcie appelée opérateur d'affectation combinée.
<?php
$a += $b; // Équivaut à : $a = $a + $b;
$a -= $b; // Équivaut à : $a = $a - $b;
$a *= $b; // Équivaut à : $a = $a * $b;
$a /= $b; // Équivaut à : $a = $a / $b;
$a %= $b; // Équivaut à : $a = $a % $b;
$a **= $b; // Équivaut à : $a = $a ** $b;
?>
Ces écritures modifient directement la valeur déjà stockée dans $a.
Incrémenter et décrémenter une variable
Lorsqu'on souhaite simplement augmenter ou diminuer une variable d'une unité, PHP propose encore deux raccourcis. L'opérateur ++ permet d'incrémenter une valeur tandis que l'opérateur -- permet de la décrémenter.
<?php
$compteur = 5;
$compteur++; // Même effet ici que $compteur = $compteur + 1;
echo $compteur; // Affiche 6
$compteur--; // Même effet ici que $compteur = $compteur - 1;
echo $compteur; // Affiche 5
?>
Lorsque l'opérateur est utilisé seul comme une instruction, les écritures $compteur++ et ++$compteur ont toutes les deux pour effet d'augmenter la variable d'une unité.
<?php
$compteur = 5;
$compteur++;
echo $compteur; // Affiche 6
$compteur = 5;
++$compteur;
echo $compteur; // Affiche également 6
?>
Une différence apparaît lorsque l'incrémentation est utilisée au sein d'une expression, par exemple lorsqu'on affecte son résultat à une autre variable.
Avec la post-incrémentation $compteur++, la valeur actuelle de la variable est d'abord utilisée dans l'expression. La variable est ensuite incrémentée.
<?php
$compteur = 5;
$resultat = $compteur++;
echo $resultat; // Affiche 5
echo $compteur; // Affiche 6
?>
Avec la pré-incrémentation ++$compteur, la variable est d'abord incrémentée. Sa nouvelle valeur est ensuite utilisée dans l'expression.
<?php
$compteur = 5;
$resultat = ++$compteur;
echo $resultat; // Affiche 6
echo $compteur; // Affiche 6
?>
Le même principe s'applique à la décrémentation. $compteur-- utilise d'abord la valeur actuelle avant de la diminuer, tandis que --$compteur diminue d'abord la valeur avant de l'utiliser.
Priorité des opérations
Comme en mathématiques, toutes les opérations ne sont pas effectuées dans l'ordre où elles sont écrites. Les multiplications, divisions et modulos sont par exemple évalués avant les additions et les soustractions. Lorsque l'ordre d'un calcul doit être explicite, il est conseillé d'utiliser des parenthèses.
Il est ainsi possible d'effectuer plusieurs opérations à partir des valeurs de différentes variables :
<?php
$noteCoursFrancais = 6;
$noteCoursMath = 4;
$moyenne = ($noteCoursFrancais + $noteCoursMath) / 2;
echo $moyenne; // Affiche : 5
?>
Les chaînes de caractère (string)
Attribuer une chaîne de caractères à une variable
Il est également possible d'assigner du texte (une chaîne de caractères) à une variable. Pour que PHP comprenne qu'il a affaire à du texte, il faut encapsuler les chaînes de caractères par des guillemets simples :
<?php
$uneChaineDeCaracteres = 'Saperlipopette !';
echo $uneChaineDeCaracteres; // Affiche : Saperlipopette !
?>
Suite à l'exécution du code, echo $uneChaineDeCaracteres affichera bien: Saperlipopette !
Si nous tentons d'englober une chaîne de caractères qui contient des guillemets simples, nous rencontrerons un problème. PHP va interpréter que la chaîne de caractères s'interrompt à ce moment-là et ne saura pas quoi faire du reste ce qui provoquera une erreur :
<?php
$repliqueDeGroot = 'Je s'appelle Groot !';
echo $repliqueDeGroot; // Affiche : PHP Parse error: syntax error, unexpected identifier "appelle"...
?>
Pour que le guillemet simple contenu dans la chaîne soit interprété de façon littérale, il faut échapper le caractère en le faisant précéder d'un antislash \ :
<?php
$repliqueDeGroot = 'Je s\'appelle Groot !';
echo $repliqueDeGroot; // Affiche : Je s'appelle Groot !
?>
La concaténation
Maintenant, nous aimerions initialiser une variable avec une valeur provenant de la composition de deux autres chaînes de caractères. En programmation, cette "composition" de chaînes de caractères est appelée la concaténation. Comme nous l'avons vu pour les nombres, il est possible d'utiliser des opérateurs arithmétiques. Cependant, essayons d'additionner deux chaînes de caractères et observons le résultat :
<?php
$prenom = 'Claudy';
$nom = 'Focan';
$nomEtPrenom = $prenom + $nom;
echo $nomEtPrenom; // Affiche : Fatal error: Uncaught TypeError: Unsupported operand types: string + string in ...
?>
Après l'exécution du code, le terminal renverra une erreur car il a détecté des caractères non numériques au sein des chaînes. Si les chaînes de caractères avaient été uniquement composées de valeurs numériques, l'addition aurait pu se réaliser comme s'il s'agissait de deux nombres :
<?php
$noteCoursFrancais = '6';
$noteCoursMath = '4';
$sommeDesNotes = $noteCoursFrancais + $noteCoursMath;
echo $sommeDesNotes; // Affiche : 10
?>
Malgré le fait que les valeurs additionnées soient bien des chaînes de caractères, l'exécution se déroule sans problème. Notez que le type du résultat sera un entier et non plus une chaîne de caractères. Pour en être sûr, vous pouvez utiliser la fonction gettype() qui renvoie le type de la variable placée entre les parenthèses :
<?php
$noteCoursFrancais = '6';
$noteCoursMath = '4';
$sommeDesNotes = $noteCoursFrancais + $noteCoursMath;
echo gettype($sommeDesNotes); // Affiche : integer
?>
Si vous désirez afficher une valeur ainsi que son type, il existe une autre fonction var_dump() :
<?php
$noteCoursFrancais = '6';
$noteCoursMath = '4';
$sommeDesNotes = $noteCoursFrancais + $noteCoursMath;
var_dump($sommeDesNotes); // Affiche : int(10)
?>
Revenons maintenant à notre tentative de concaténation de chaînes de caractères. Au lieu d'utiliser l'opérateur d'addition, nous utiliserons l'opérateur de concaténation représenté par le point . :
<?php
$prenom = 'Claudy';
$nom = 'Focan';
$nomEtPrenom = $prenom . $nom;
echo $nomEtPrenom; // Affiche : ClaudyFocan
?>
Pour ajouter un espace entre le prénom et le nom lors de la concaténation, il suffit d'insérer une chaîne de caractères contenant un espace entre les deux variables :
<?php
$prenom = 'Claudy';
$nom = 'Focan';
$nomEtPrenom = $prenom . ' ' . $nom;
echo $nomEtPrenom; // Affiche : Claudy Focan
?>
Il existe un second opérateur de chaînes, l'opérateur d'affectation concaténant. Celui-ci permet de concaténer une chaîne de caractères à une variable existante sans avoir besoin d'une variable intermédiaire pour stocker le résultat.
Cela peut être utile lorsque vous avez besoin de construire une chaîne de caractères progressive au fur et à mesure que votre programme s'exécute, sans avoir à créer de nouvelles variables à chaque étape de la concaténation :
<?php
$cadavreExquis = 'Claudy';
$cadavreExquis .= ' aime';
$cadavreExquis .= ' les poneys';
echo $cadavreExquis; // Affiche : Claudy aime les poneys
?>
Remarquez qu'au moment d'insérer une opération arithmétique au sein de chaînes de caractères, il est conseillé de les encadrer de parenthèses pour éviter toute ambiguïté. Cette approche améliore la clarté du code tout en prévenant d'eventuelles erreurs d'interprétation de PHP :
<?php
$personnage = 'Claudy';
$nombreDePoneys = 1;
$nombreDePoules = 2;
echo $personnage . ' a ' . ($nombreDePoneys + $nombreDePoules) . ' animaux !'; // Affiche : Claudy a 3 animaux !
?>
Néanmoins, malgré cette approche, le code peut parfois devenir difficile à lire, en particulier lorsque des calculs complexes sont impliqués. Dans de tels cas, il peut être judicieux de créer des variables intermédiaires pour simplifier la lecture et la maintenance du code :
<?php
$personnage = 'Claudy';
$nombreDePoneys = 1;
$nombreDePoules = 2;
$nombreAnimaux = $nombreDePoneys + $nombreDePoules;
echo $personnage . ' a ' . $nombreAnimaux . ' animaux !'; // Affiche : Claudy a 3 animaux !
?>
Interprétation des variables avec les doubles guillemets
Plutôt que d'utiliser l'opérateur de concaténation, ne serait-il pas plus lisible d'insérer directement les variables entre les guillemets ?
<?php
$prenom = 'Claudy';
$nom = 'Focan';
$nomEtPrenom = '$prenom $nom';
echo $nomEtPrenom; // Affiche : $prenom $nom
?>
Lorsque les variables sont encapsulées entre des guillemets simples, elles sont interprétées de façon littérale, c'est-à-dire qu'elles ne sont pas remplacées par leurs valeurs.
Pour que les variables soient interprétées dynamiquement, c'est-à-dire en remplaçant leur nom par leur valeur réelle, il faut les encapsuler entre des guillemets doubles :
<?php
$prenom = 'Claudy';
$nom = 'Focan';
$nomEtPrenom = "$prenom $nom";
echo $nomEtPrenom; // Affiche : Claudy Focan
?>
Bien que l'utilisation de guillemets doubles soit légèrement plus gourmande en termes de performance que celle des guillemets simples, cette différence est généralement minime et rarement significative dans la plupart des scénarios. Il est plus important de choisir le bon type de guillemet en fonction de vos besoins (littéral ou dynamique).
Les séquences d'échappement
Encapsuler les chaînes de caractères avec des guillemets doubles permet également d'interpréter différentes séquences d'échappement ( https://www.php.net/manual/fr/language.types.string.php#language.types.string.syntax.double), telles que le retour à la ligne \n.
<?php
$prenom = 'Claudy';
$nom = 'Focan';
$nomEtPrenom = "$prenom\n$nom";
echo $nomEtPrenom;
/*
Affiche :
Claudy
Focan
*/
?>
La constante prédéfinie PHP_EOL
Un retour à la ligne n'est pas représenté de la même manière selon le système d'exploitation :
- Windows : \r\n (retour chariot suivi d'un saut de ligne).
- Unix/Linux/macOS récents : \n (saut de ligne seul).
- Ancien macOS (avant OS X) : \r (retour chariot seul).
Pour éviter d'avoir à se soucier de cette différence entre systèmes, PHP met à disposition la constante prédéfinie PHP_EOL (End Of Line). Cette constante prend automatiquement la valeur attendue par le système lors de l'exécution du script :
<?php
$prenom = 'Claudy';
$nom = 'Focan';
// Retour à la ligne adapté au système
$nomEtPrenom = $prenom . PHP_EOL . $nom;
echo $nomEtPrenom;
/*
Code exécuté sous Windows (\r\n) :
Claudy
Focan
Code exécuté sous Linux/macOS (\n) :
Claudy
Focan
*/
?>
Historiquement, la constante PHP_EOL avait une vraie utilité. Sous Windows, de nombreux outils système anciens (par exemple certains parseur ou un script batch) s'attendaient à trouver \r\n pour marquer la fin d'une ligne. Un simple \n pouvait alors être mal interprété, rendant les fichiers journaux ou exportés difficiles à exploiter correctement.
C'est pour éviter ce genre de problème que de nombreux anciens codes PHP utilisaient PHP_EOL, afin de produire des fichiers parfaitement conformes aux conventions du système. Aujourd'hui, ce n'est plus un véritable problème, la plupart des éditeurs, des parseurs modernes et même les outils Windows récents acceptent sans difficulté les fichiers contenant uniquement \n.
Il reste néanmoins utile de connaître PHP_EOL. Vous pouvez encore la rencontrer dans d'anciens projets, et elle illustre la volonté de PHP de s'adapter automatiquement aux conventions des systèmes d'exploitation.
Certains développeurs continuent de l'utiliser aujourd'hui, principalement dans deux situations :
- pour afficher du texte dans le terminal en mode CLI (Command Line Interface),
- pour générer des fichiers de logs locaux.
Dans la plupart des autres cas, il est préférable d'écrire directement la séquence adaptée au contexte :
- \n pour les formats web (JSON, XML, etc.),
- \r\n pour les protocoles qui l'exigent (HTTP, SMTP, etc.).
Exercices - Part 01
Exo-variables-01
- Objectif : Manipuler des variables simples, effectuer plusieurs calculs et afficher leurs valeurs dans le terminal avec var_dump().
- Instructions :
- Créez un fichier nommé exo-variables-01.php.
-
Dans ce fichier, ouvrez un bloc PHP
<?php // Votre code viendra ici ?> - À l'intérieur du bloc PHP, déclarez deux variables nommées $a et $b et affectez-leur les valeurs suivantes $a = 5 et $b = 3.
- Créez une variable $somme qui contient le résultat de $a + $b.
- Créez une variable $difference qui contient le résultat de $a - $b.
- Créez une variable $produit qui contient le résultat de $a * $b.
- Créez une variable $quotient qui contient le résultat de $a / $b.
- Créez une variable $reste qui contient le reste de la division de $a par $b à l'aide de l'opérateur modulo %.
- Affichez, avec var_dump(), la valeur de chacune des variables suivantes : $a, $b, $somme, $difference, $produit, $quotient et $reste.
- Dans votre terminal, placez-vous dans le dossier qui contient le fichier puis exécutez php exo-variables-01.php. Modifiez ensuite plusieurs fois les valeurs de $a et $b, enregistrez le fichier puis relancez la commande pour vérifier que les résultats affichés changent correctement.
Exo-variables-02
- Objectif : Observer le type des variables avec var_dump() et gettype() et voir l'effet d'un calcul sur une chaîne numérique.
- Instructions :
- Créez un fichier nommé exo-variables-02.php.
- Déclarez une variable $valeur contenant une chaîne de caractères numérique (ex.: "10").
- Affichez son type avec echo gettype($valeur); puis faites aussi var_dump($valeur);.
- Déclarez une variable $addition qui vaut $valeur + 5.
- Affichez le type et le contenu de $addition avec gettype() et var_dump().
- Affichez enfin le type de $valeur après ce calcul pour vérifier s'il a changé ou non.
- Ajoutez quelques commentaires dans le fichier pour expliquer ce que vous observez différences entre gettype() et var_dump() et ce qui se passe quand on fait un calcul avec une chaîne numérique.
Exo-variables-03
- Objectif : Pratiquer l'incrémentation, la décrémentation et les affectations raccourcies avec ++, --, += et -=.
- Instructions :
- Créez un fichier exo-variables-03.php.
- Déclarez une variable $compteur initialisée à 0 elle représentera par exemple un nombre de visites.
- Dans le terminal, affichez le texte "Compteur actuel : " suivi de la valeur de $compteur, puis ajoutez un retour à la ligne adapté au système d'exploitation grâce à la constante PHP_EOL.
- Utilisez l'opérateur d'incrémentation (++) pour augmenter $compteur d'une unité puis réaffichez sa valeur.
- Utilisez ensuite += pour ajouter 5 directement à $compteur puis affichez encore une fois sa valeur.
- Utilisez l'opérateur de décrémentation -- pour diminuer $compteur d'une unité puis réaffichez sa valeur.
- Utilisez enfin -= pour retirer 2 directement à $compteur, puis affichez une dernière fois sa valeur.
- Ajoutez un commentaire pour expliquer, avec vos mots, ce que font $compteur++, $compteur--, $compteur += 5 et $compteur -= 2.
Exo-variables-04
- Objectif : Combiner deux variables chaînes dans une troisième variable à l'aide de l'opérateur de concaténation ., en ajoutant un espace au milieu.
- Instructions :
- Créez un fichier exo-variables-04.php.
- Déclarez une première variable chaîne nommée $mot1 et affectez-lui la valeur "Bonjour". Affichez sa valeur avec var_dump().
- Déclarez une deuxième variable chaîne nommée $mot2 et affectez-lui la valeur "tout le monde". Affichez sa valeur avec var_dump().
- Créez une troisième variable nommée $message qui combine le contenu de $mot1, un espace écrit en dur " ", puis le contenu de $mot2, en utilisant l'opérateur de concaténation .. La variable $message doit contenir au final le texte "Bonjour tout le monde".
- Affichez la valeur de $message avec var_dump().
- Ajoutez un commentaire dans votre fichier pour expliquer, avec vos mots, comment l'opérateur . et la chaîne " " ont été utilisés pour assembler les deux mots dans une seule variable.
Exo-variables-05
- Objectif : Utiliser l'opérateur de concaténation raccourci .= pour chaîner plusieurs morceaux de texte.
- Instructions :
- Créez un fichier exo-variables-05.php.
- Déclarez une variable $message avec la chaîne de caractères "Bienvenue".
- Utilisez l'opérateur de concaténation raccourci .= pour ajouter un espace suivi d'un prénom à la fin de la chaîne de caractères stockée dans la variable $message (ex.: " Alice").
- Ajoutez encore du texte à la fin de la chaîne contenue dans $message (ex.: ", vous êtes connecté!").
- Affichez le message final avec echo.
- Ajoutez un commentaire dans le code pour expliquer ce que fait l'opérateur .= étape par étape.
Exo-variables-06
- Objectif : Utiliser la concaténation implicite dans les chaînes entre guillemets doubles et la comparer à la concaténation explicite avec l'opérateur de concaténation.
- Instructions :
- Créez un fichier exo-variables-06.php.
- Déclarez trois variables chaînes par exemple $prenom, $nom et $ville et donnez-leur des valeurs de votre choix.
- Affichez une phrase de bienvenue qui utilise ces trois informations en écrivant une seule chaîne entre guillemets doubles dans laquelle les variables sont placées directement (concaténation implicite).
- Dans un second echo, affichez une phrase équivalente mais cette fois en assemblant le texte et les variables avec l'opérateur de concaténation ..
- Ajoutez un commentaire dans votre fichier qui explique la différence entre les deux approches concaténation implicite avec guillemets doubles et concaténation explicite avec l'opérateur ..
- Testez votre script dans le terminal et vérifiez que les deux phrases s'affichent correctement.
Exo-variables-07
- Objectif : Découvrir les retours à la ligne dans les chaînes de caractères avec \n et la constante PHP_EOL en générant un petit rapport textuel lisible dans un terminal.
-
Instructions :
- Créez un fichier nommé exo-variables-07.php.
- Créez trois variables contenant des informations simples telles que $nom, $age et $ville.
-
Créez une variable
$rapport
qui assemble ces informations
($nom,
$age,
$ville)
en un petit rapport réparti sur plusieurs lignes
en utilisant \n.
Le résultat attendu, une fois affiché dans le terminal, devra ressembler à :Nom: Alice Age: 22 Ville: Bruxelles - Utilisez echo avec la variable $rapport pour permettre son affichage dans le terminal.
- Exécutez le fichier dans un terminal avec php exo-variables-07.php et vérifiez que le texte s'affiche bien sur plusieurs lignes.
- Créez une seconde version du rapport nommée $rapportSysteme, cette fois en utilisant PHP_EOL à la place de \n et affichez le aussi avec echo.
- Utilisez json_encode() pour afficher la valeur brute de $rapportSysteme. Vous devriez voir apparaître la séquence exacte utilisée pour le retour à la ligne (\n sous Linux et macOS, \r\n sous Windows), ce qui montre que PHP_EOL s'adapte à votre système.
Exo-variables-08
- Objectif : Intégrer un calcul directement dans une concaténation à l'aide de l'opérateur de concaténation.
- Instructions :
- Créez un fichier exo-variables-08.php.
- Déclarez deux variables $prixUnitaire et $quantite.
- Affichez une phrase indiquant le total à payer en utilisant l'opérateur de concaténation (.). Formez cette phrase à partir de la chaîne "Total à payer : ", du résultat de la multiplication de $prixUnitaire par $quantite (sans utiliser de variable intermédiaire), puis du caractère "€".
- Testez votre script en l'exécutant dans le terminal et vérifiez que la phrase s'affiche correctement avec le bon total.
Exo-variables-09
- Objectif : Rendre le code plus lisible en calculant d'abord le total dans une variable, puis en l'affichant à l'aide d'une concaténation implicite.
- Instructions :
- Créez un fichier exo-variables-09.php.
- Déclarez deux variables $prixUnitaire et $quantite.
- Créez une variable $total contenant le résultat de la multiplication de $prixUnitaire par $quantite.
- Affichez une phrase indiquant le total à payer en utilisant l'opérateur de concaténation (.). Formez cette phrase à partir de la chaîne "Total à payer : ", du résultat de la multiplication de $prixUnitaire par $quantite (sans utiliser de variable intermédiaire), puis du caractère "€".
- Affichez une phrase indiquant le total à payer en utilisant la concaténation implicite (la valeur de la variable est insérée directement au sein des doubles guillemets, sans utilisation de l'opérateur de concaténation .). Formez cette phrase à partir de la chaîne "Total à payer : ", suivi de la variable $total, puis du caractère "€".
- Testez votre script en l'exécutant dans le terminal et vérifiez que la phrase s'affiche correctement avec le bon total.
Exo-variables-10
- Objectif : Utiliser la concaténation implicite dans une chaîne qui contient aussi des guillemets doubles et apprendre à échapper ces guillemets.
- Instructions :
- Créez un fichier exo-variables-10.php.
- Déclarez une variable $nomFichier avec un nom de fichier de votre choix et une variable $utilisateur avec un prénom ou un pseudo.
- Construisez une chaîne qui contient ces informations avec des guillemets doubles autour des valeurs. Par exemple $message = "Le fichier \"$nomFichier\" a été créé pour l'utilisateur \"$utilisateur\".";
- Affichez cette chaîne avec echo $message;.
- Ajoutez un commentaire qui explique pourquoi les guillemets doubles à l'intérieur de la chaîne doivent être précédés d'un antislash \.
Exo-variables-11
- Objectif : Comprendre que l'affectation d'une variable dans une autre se fait par copie et non par référence.
- Instructions :
- Créez un fichier exo-variables-11.php.
- Déclarez une variable $a et affectez-lui la valeur 1.
- Déclarez une variable $b et affectez-lui la valeur de $a avec $b = $a;.
- Affichez le contenu et le type de $a et $b avec var_dump().
- Modifiez ensuite $a en lui donnant la valeur 5.
- Affichez à nouveau $a et $b avec var_dump().
- Ajoutez un commentaire en fin de fichier pour expliquer ce que vous avez observé
- quelle valeur garde $b après modification de $a,
- ce que cela signifie pour la manière dont PHP copie les valeurs des variables simples.
Exo-variables-12
- Objectif : Utiliser la documentation pour découvrir des fonctions prédéfinies
de manipulation de chaînes et comprendre qu'elles retournent une nouvelle valeur
sans modifier la variable d'origine.
- Dans cet exercice, vous allez utiliser trois fonctions prédéfinies différentes. Le but est de chercher comment elles fonctionnent en consultant la documentation officielle de PHP ou des ressources fiables sur le web.
- Si vous utilisez un outil comme ChatGPT, évitez de demander simplement la solution complète. Formulez plutôt des questions qui vous aident à apprendre, par exemple en demandant le rôle de la fonction, sa syntaxe et un exemple d'utilisation.
- Instructions :
- Créez un fichier exo-variables-12.php.
-
Copiez le code suivant dans le fichier que vous venez de créer :
<?php $message = 'coucou petite perruche !'; ?> - Recherchez la fonction prédéfinie str_replace(). Utilisez-la pour remplacer le mot "coucou" par "Au revoir" dans la variable $message. Enregistrez le résultat dans une nouvelle variable $messageRemplace et affichez cette nouvelle variable avec echo.
- Recherchez la fonction prédéfinie ucfirst(). Utilisez-la pour créer une variable $messageMajPremiereLettre qui contient la phrase avec une majuscule sur le premier caractère. Affichez cette variable pour vérifier le résultat.
- Recherchez la fonction prédéfinie strtoupper(). Utilisez-la pour créer une variable $messageMajuscules où tous les caractères sont en majuscule. Affichez cette variable pour vérifier le résultat.
- Affichez ensuite la valeur de la variable d'origine $message. Observez si cette variable a changé ou non après l'utilisation des fonctions précédentes.
- Ajoutez un commentaire à la fin du fichier pour expliquer ce que vous avez compris sur le comportement de ces fonctions de chaînes par rapport à la variable d'origine et sur la nécessité de stocker leur résultat dans une nouvelle variable ou de réaffecter le résultat à la même variable.
Les booléens (bool)
Un booléen est un type de donnée qui ne peut contenir que deux valeurs : true (vrai) ou false (faux). Il permet de représenter un état qui possède deux possibilités, par exemple savoir si un utilisateur est connecté, si une option est activée ou si une condition est remplie.
<?php
$estConnecte = true;
$aAccepteLaCharte = false;
var_dump($estConnecte); // Affiche : bool(true)
var_dump($aAccepteLaCharte); // Affiche : bool(false)
?>
La valeur null
La valeur spéciale null permet de représenter l'absence de valeur. Elle peut être utilisée lorsqu'une variable existe mais qu'aucune valeur utile ne lui est encore associée.
<?php
$numeroTelephone = null;
var_dump($numeroTelephone); // Affiche : NULL
?>
Les tableaux (array)
En PHP, un tableau est une structure de données qui permet de stocker plusieurs valeurs dans une seule variable. Cela évite de créer une variable par information et facilite les traitements sur des ensembles de données.
Un même tableau peut contenir différents types de valeurs, par exemple des nombres, des chaînes de caractères ou même d'autres tableaux. Les tableaux sont donc très utilisés dès que l'on doit manipuler des listes d'informations.
Les tableaux indexés
Un tableau indexé est un tableau dont chaque élément est repéré par une clé numérique. Lorsque PHP attribue automatiquement ces clés, la première commence à zéro puis les suivantes augmentent d'une unité. Ce type de tableau convient bien lorsque l'ordre des éléments est important et que l'on parcourt souvent la liste du début à la fin.
Créer un tableau indexé
Pour créer un tableau, ses éléments doivent être encadrés par des crochets ouverts [ et des crochets fermés ], en séparant chacun d'eux par une virgule ,.
<?php
$fourreTout = ['Claudy', 42, false, 'Jean-Claude', null];
?>
Une alternative pour l'initialisation d'un tableau est d'utiliser la fonction array(). Cependant, cette méthode est plus ancienne et moins concise :
<?php
$fourreTout = array('Claudy', 42, false, 'Jean-Claude', null);
?>
Compter le nombre d'éléments d'un tableau
La fonction prédéfinie count() permet de connaître le nombre d'éléments contenus dans un tableau.
<?php
$laFineEquipe = ['Claudy', 'Jean-Claude', 'Laurence'];
echo count($laFineEquipe); // Affiche : 3
?>
Accéder à une valeur dans un tableau indexé
Dans un tableau, chaque élément peut être ciblé individuellement à l'aide de sa clé. En PHP, le premier élément d'un tableau dont les clés ont été attribuées automatiquement se situe à l'index 0 (index = clé numérique).
Pour cibler la valeur du tableau $laFineEquipe en index 1, écrivez le nom du tableau suivi de l'index désiré entre crochet :
<?php
/*
Index | 0 | 1 | 2 |
Valeurs | 'Claudy' | 'Jean-Claude' | 'Laurence' |
*/
$laFineEquipe = ['Claudy', 'Jean-Claude', 'Laurence'];
echo($laFineEquipe[1]); // Affiche : Jean-Claude
?>
Modifier une valeur dans un tableau indexé
Pour modifier la valeur d'un élément dans un tableau, il faut cibler l'élément spécifique que l'on souhaite changer et lui assigner la nouvelle valeur souhaitée. Dans l'exemple suivant, nous avons un tableau contenant trois valeurs, et l'objectif est de modifier la dernière valeur. En PHP, comme les index de tableau commencent à 0, dans ce cas l'index du dernier élément sera 2.
Une fois que la valeur est modifiée, nous souhaitons afficher le tableau avec toutes ses valeurs. Cependant, il est important de noter que l'instruction echo, que nous avons utilisée tout au long du cours, est principalement destinée à afficher des valeurs simples, telles que des nombres ou des chaînes de caractères. Si vous devez afficher des structures de données plus complexes, comme un tableau complet, vous pouvez utiliser la fonction print_r() :
<?php
$laFineEquipe = ['Claudy', 'Jean-Luc', 'Laurence'];
// Modifier la valeur du 3ème élément du tableau.
// Cet élément est situé à l'index 2 puisque le tableau débute à l'index 0.
$laFineEquipe[2] = 'Stef';
print_r($laFineEquipe);
/*
Affiche :
Array
(
[0] => Claudy
[1] => Jean-Luc
[2] => Stef
)
*/
?>
Notez que lorsqu'on modifie un tableau existant, que ce soit en ajoutant un élément, en changeant une valeur ou en supprimant une entrée, on parle de mutation. Autrement dit, le tableau conserve son identité, mais son contenu est transformé.
Ajouter une nouvelle entrée dans un tableau indexé
Pour ajouter un élément à un tableau, il vous suffit d'ouvrir et de fermer des crochets à la suite du tableau, puis d'assigner une nouvelle valeur. Cela vous permet d'étendre dynamiquement la taille du tableau en y ajoutant de nouvelles données au fur et à mesure de vos besoins.
<?php
$laFineEquipe = ['Claudy', 'Jean-Luc', 'Laurence'];
// Ajouter la chaîne 'Stef' en fin de tableau.
$laFineEquipe[] = 'Stef';
// Ajouter la chaîne 'Greg' en fin de tableau.
$laFineEquipe[] = 'Greg';
print_r($laFineEquipe);
/*
Affiche :
Array
(
[0] => Claudy
[1] => Jean-Luc
[2] => Laurence
[3] => Stef
[4] => Greg
)
*/
?>
Les nouveaux index ont bien été ajoutés automatiquement à la suite de ceux déjà présents.
Supprimer un élément dans un tableau
Pour supprimer un élément d'un tableau, on utilise la fonction prédéfinie unset(). Cette fonction supprime l'élément ciblé par son index. Attention, l'index supprimé n'est pas automatiquement réattribué. Par exemple, si vous supprimez l'élément à l'index 1 dans un tableau de 3 éléments, les clés des deux éléments restant seront 0 et 2, ce qui crée un "trou" dans la numérotation.
<?php
$laFineEquipe = ['Claudy', 'Jean-Luc', 'Laurence'];
// Supprimer l'index 1 ('Jean-Luc').
unset($laFineEquipe[1]);
print_r($laFineEquipe);
/*
Affiche :
Array
(
[0] => Claudy
[2] => Laurence
)
*/
?>
Comme vous pouvez le voir, la clé 1 a bien été supprimée, mais elle n'a pas été remplacée automatiquement. Le tableau présente donc un "trou" dans sa numérotation.
Dans certains cas, cela ne pose aucun problème. En revanche, si vous devez parcourir le tableau avec une boucle for ou l'exporter en JSON, il est important que la numérotation soit continue.
Voici un exemple du problème qui apparaît lorsqu'on convertit en JSON un tableau à index numérique après avoir supprimé un élément sans réindexation :
<?php
/* 1. Convertir un tableau au format JSON et afficher le résultat */
$laFineEquipe = ['Claudy', 'Jean-Luc', 'Laurence'];
// Convertir le tableau au format JSON.
$laFineEquipeCompleteJson = json_encode($laFineEquipe, JSON_PRETTY_PRINT);
// Afficher la version JSON du tableau.
// On utilise "var_dump" pour obtenir le type ainsi que la valeur de $laFineEquipeCompleteJson,
// on remarque ainsi que json_encode() retourne une chaîne de caractères.
var_dump($laFineEquipeCompleteJson);
/*
string(48) "[
"Claudy",
"Jean-Luc",
"Laurence"
]"
*/
/* 2. Supprimer un élément du tableau avant de le convertir au format JSON et afficher le résultat */
// Supprimer 'Jean-Luc' du tableau (situé à l'index 1).
unset($laFineEquipe[1]);
// Convertir le tableau au format JSON après la suppression de 'Jean-Luc'.
$laFineEquipeIncompleteJson = json_encode($laFineEquipe, JSON_PRETTY_PRINT);
// Afficher la version JSON du tableau.
// Après la suppression d'un élément sans réindexation, le tableau n'est plus traité
// comme un tableau à index numérique, mais comme un OBJET JSON.
// Les accolades englobantes et les clés numériques converties en chaînes de caractères le montrent.
var_dump($laFineEquipeIncompleteJson);
/*
string(42) "{
"0": "Claudy",
"2": "Laurence"
}"
*/
?>
Pour éviter ce désagrément, il suffit de réindexer le tableau. Vous pouvez pour cela utiliser la fonction prédéfinie array_values().
<?php
$laFineEquipe = ['Claudy', 'Jean-Luc', 'Laurence'];
// Supprimer l'index 1 ('Jean-Luc').
unset($laFineEquipe[1]);
// Réindexer le tableau.
$laFineEquipe = array_values($laFineEquipe);
// Afficher le tableau réindexé après avoir supprimé "Jean-Luc".
print_r($laFineEquipe);
/*
Affiche :
Array
(
[0] => Claudy
[1] => Laurence
)
*/
?>
Les tableaux associatifs
En PHP, on distingue principalement deux types de tableaux. Les tableaux indexés utilisent des indices numériques (0, 1, 2, etc.) pour accéder aux valeurs. Chaque élément est repéré par un nombre entier, ce qui convient bien pour lister des valeurs dans un ordre précis.
Les tableaux associatifs fonctionnent différemment. Ils utilisent des clés textuelles pour associer chaque valeur à un nom explicite. Cette approche permet de donner un sens clair à chaque entrée du tableau et de retrouver les informations sans devoir mémoriser la position des éléments.
Créer un tableau associatif
Pour introduire les tableaux associatifs, imaginons que nous voulions stocker plusieurs informations concernant un utilisateur, comme son âge, son adresse et son code postal. Avec un tableau indexé, chaque information serait rangée à une position différente et il faudrait se souvenir que l'indice 0 représente l'âge, l'indice 1 l'adresse, l'indice 2 le numéro de rue, et ainsi de suite.
<?php
// 0: âge, 1: adresse, 2: numéro, 3: code postal
$claudy = [52, 'Rue des Carjackeys', 12, 1000];
?>
Dans ce genre de cas, il est plus judicieux d'utiliser un tableau associatif, car nous pouvons employer des noms de clés pertinents pour identifier les données.
<?php
$claudy = ['age' => 52, 'adresse' => 'Rue des Carjackeys', 'numero' => 12, 'codePostal' => 1000];
print_r($claudy);
/*
Affiche :
Array
(
[age] => 52
[adresse] => Rue des Carjackeys
[numero] => 12
[codePostal] => 1000
)
*/
?>
Pour améliorer la lisibilité de notre code et rendre les données plus facilement accessibles, il est fortement recommandé d'indenter le code de la manière suivante.
<?php
$claudy = [
'age' => 52,
'adresse' => 'Rue des Carjackeys',
'numero' => 12,
'codePostal' => 1000
];
?>
Accéder à une valeur dans un tableau associatif
Pour récupérer une information existante dans un tableau associatif, il suffit de cibler la clé textuelle correspondante à l'aide des crochets. Par exemple, si l'on souhaite afficher l'âge de Claudy, on utilise la clé 'age' entre crochets comme ceci : $claudy['age'].
<?php
$claudy = [
'age' => 52,
'adresse' => 'Rue des Carjackeys',
'numero' => 12,
'codePostal' => 1000
];
// Afficher la valeur associée à la clé 'age'.
echo $claudy['age']; // Affiche : 52
?>
Modifier une valeur dans un tableau associatif
Pour modifier une information existante dans un tableau associatif, il suffit de réaffecter une nouvelle valeur à la clé concernée. Par exemple, si l'on souhaite mettre à jour l'âge de Claudy, on cible la clé textuelle correspondante à l'aide des crochets en écrivant $claudy['age'] = 53;.
<?php
$claudy = [
'age' => 52,
'adresse' => 'Rue des Carjackeys',
'numero' => 12,
'codePostal' => 1000
];
// Modifier la valeur associée à la clé 'age'.
$claudy['age'] = 53;
print_r($claudy);
/*
Affiche :
Array
(
[age] => 53
[adresse] => Rue des Carjackeys
[numero] => 12
[codePostal] => 1000
)
*/
?>
Ajouter une nouvelle entrée dans un tableau associatif
Pour ajouter une information supplémentaire dans un tableau associatif, il suffit de choisir une nouvelle clé qui n'existe pas encore dans le tableau et de lui affecter une valeur. Par exemple, pour préciser la ville où habite Claudy, on peut ajouter la clé 'ville' de la manière suivante.
<?php
$claudy = [
'age' => 52,
'adresse' => 'Rue des Carjackeys',
'numero' => 12,
'codePostal' => 1000
];
// Ajouter une nouvelle entrée avec la clé 'ville'.
$claudy['ville'] = 'Bruxelles';
print_r($claudy);
/*
Affiche :
Array
(
[age] => 52
[adresse] => Rue des Carjackeys
[numero] => 12
[codePostal] => 1000
[ville] => Bruxelles
)
*/
?>
Supprimer une entrée dans un tableau associatif
Pour supprimer une information dans un tableau associatif, on utilise la fonction unset() en ciblant la clé à retirer à l'aide des crochets. Par exemple, si l'on ne souhaite plus conserver le numéro de rue, on peut supprimer l'entrée associée à la clé 'numero' avec unset($claudy['numero']).
<?php
$claudy = [
'age' => 52,
'adresse' => 'Rue des Carjackeys',
'numero' => 12,
'codePostal' => 1000
];
// Supprimer l'entrée ayant la clé 'numero'.
unset($claudy['numero']);
print_r($claudy);
/*
Affiche :
Array
(
[age] => 52
[adresse] => Rue des Carjackeys
[codePostal] => 1000
)
*/
?>
Contrairement aux tableaux numérotés, il n'est pas nécessaire de réindexer un tableau associatif, car chaque clé textuelle est indépendante et les autres données ne sont pas affectées.
Les tableaux multidimensionnels
Un tableau multidimensionnel est un tableau qui contient lui-même d'autres tableaux. On peut ainsi représenter des structures plus riches, comme un planning, une grille de valeurs ou une liste de personnes avec leurs informations détaillées.
Le principe reste le même qu'avec un tableau simple. À chaque niveau supplémentaire, on ajoute une paire de crochets pour accéder aux données. On lit donc les indices ou les clés dans l'ordre, du tableau parent vers le tableau imbriqué.
Imbriquer des tableaux indexés
Dans l'exemple suivant, chaque sous-tableau représente une semaine et chaque valeur correspond au nombre de ventes d'une journée. Le tableau parent est indexé et chaque sous-tableau est lui aussi indexé.
<?php
$ventes = [
[10, 12, 9, 14, 8], // Semaine 1
[7, 11, 13, 6, 9], // Semaine 2
[15, 9, 10, 12, 11] // Semaine 3
];
print_r($ventes);
/*
Affiche quelque chose comme
Array
(
[0] => Array
(
[0] => 10
[1] => 12
[2] => 9
[3] => 14
[4] => 8
)
[1] => Array
(
[0] => 7
[1] => 11
[2] => 13
[3] => 6
[4] => 9
)
[2] => Array
(
[0] => 15
[1] => 9
[2] => 10
[3] => 12
[4] => 11
)
)
*/
?>
Pour accéder à une valeur précise, on commence par cibler l'indice du tableau parent, puis l'indice à l'intérieur du sous-tableau. On lit les crochets de gauche à droite.
Par exemple, pour accéder au nombre de ventes du troisième jour de la deuxième semaine, on utilise d'abord l'indice 1 pour la deuxième semaine, puis l'indice 2 pour le troisième jour : $ventes[1][2].
<?php
// Nombre de ventes du troisième jour de la deuxième semaine
echo $ventes[1][2]; // Affiche : 13
?>
Imbriquer des tableaux associatifs
Il est également possible d'imbriquer des tableaux associatifs. Dans l'exemple suivant, un utilisateur possède un sous-tableau associatif pour ses informations de contact.
<?php
$utilisateur = [
'nom' => 'Dupont',
'prenom' => 'Alice',
'contact' => [
'email' => 'alice.dupont@example.com',
'telephone' => '0470 12 34 56'
]
];
print_r($utilisateur);
/*
Affiche :
Array
(
[nom] => Dupont
[prenom] => Alice
[contact] => Array
(
[email] => alice.dupont@example.com
[telephone] => 0470 12 34 56
)
)
*/
?>
Pour accéder à l'adresse e-mail, on cible d'abord la clé 'contact' dans le tableau principal, puis la clé 'email' dans le tableau imbriqué. On écrit donc $utilisateur['contact']['email'].
<?php
// Accéder à l'adresse e-mail
echo $utilisateur['contact']['email']; // Affiche : alice.dupont@example.com
?>
Combiner tableaux indexés et associatifs
On peut enfin combiner tableaux indexés et tableaux associatifs. C'est très courant lorsqu'on manipule une liste d'enregistrements, par exemple plusieurs utilisateurs, chacun représenté par un tableau associatif.
<?php
$distribution = [
[
'prenom' => 'Claudy',
'age' => 52,
'adresse' => 'Rue des Carjackeys',
'numero' => 12,
'codePostal' => 1000
],
[
'prenom' => 'Jean-Luc',
'age' => 45,
'adresse' => 'Avenue des nerveux',
'numero' => 8,
'codePostal' => 6000
],
[
'prenom' => 'Laurence',
'age' => 38,
'adresse' => 'Rue de la Justice',
'numero' => 7,
'codePostal' => 1000
]
];
print_r($distribution);
/*
Affiche :
Array
(
[0] => Array
(
[prenom] => Claudy
[age] => 52
[adresse] => Rue des Carjackeys
[numero] => 12
[codePostal] => 1000
)
[1] => Array
(
[prenom] => Jean-Luc
[age] => 45
[adresse] => Avenue des nerveux
[numero] => 8
[codePostal] => 6000
)
[2] => Array
(
[prenom] => Laurence
[age] => 38
[adresse] => Rue de la Justice
[numero] => 7
[codePostal] => 1000
)
)
*/
?>
Le tableau $distribution est un tableau indexé. Chaque élément de ce tableau est lui-même un tableau associatif décrivant une personne.
Pour accéder à une information précise, on procède étape par étape. On commence par cibler la personne à l'aide de son indice dans le tableau parent, puis on utilise la clé textuelle correspondant au champ souhaité.
Par exemple, pour récupérer l'âge de la deuxième personne, on cible d'abord l'indice 1 dans le tableau $distribution, puis la clé 'age'. Cela donne $distribution[1]['age'].
<?php
// Afficher l'âge de la deuxième personne
echo $distribution[1]['age']; // Affiche : 45
?>
Concaténation implicite et éléments de tableau
Il est tout à fait possible d'utiliser, au sein d'une concaténation implicite, des expressions plus complexes que de simples variables. Cependant, il faut être prudent lorsque ces expressions impliquent un accès à un tableau.
<?php
$personnage = [
'prenom' => 'Claudy',
'nom' => 'Focan',
'age' => 52
];
// Le script s'arrête lors de la tentative de concaténation implicite avec un message du type :
// Parse error: syntax error, unexpected string content...
$message = "Le personnage s'appelle $personnage['prenom'] $personnage['nom'] et a $personnage['age'] ans.";
echo $message;
?>
Lorsque l'on tente d'insérer un accès à un élément de tableau directement dans une chaîne entre guillemets doubles, PHP ne parvient pas à analyser correctement l'expression. Dans une interpolation, l'interpréteur accepte uniquement un nom de variable ou un indice numérique simple (ex.: $tableau[0]). En revanche, une clé textuelle comme $personnage['prenom'] forme une expression plus complexe que PHP n'est pas capable d'interpréter dans ce contexte. L'analyse devient alors incohérente et PHP déclenche une erreur de type Parse error.
Pour éviter ce problème, il suffit d'entourer l'expression complète avec des accolades. PHP sait alors exactement où commence et où se termine la partie à interpréter comme du code. Les accolades indiquent à l'analyseur que tout ce qui se trouve à l'intérieur correspond à une expression PHP à évaluer, par exemple {$personnage['prenom']}.
<?php
$personnage = [
'prenom' => 'Claudy',
'nom' => 'Focan',
'age' => 52
];
$message = "Le personnage s'appelle {$personnage['prenom']} {$personnage['nom']} et a {$personnage['age']} ans.";
echo $message; // Affiche : Le personnage s'appelle Claudy Focan et a 52 ans.
?>
Exercices-part-02
Exo-variables-13
- Objectif : Manipuler un tableau indexé à une dimension création, modification, ajout, suppression et réindexation dans le terminal.
- Instructions :
- Créez un fichier exo-variables-13.php.
- Créez un tableau indexé $fruits contenant trois fruits ("citron", "pomme", "fraise").
- Affichez le tableau dans le terminal avec print_r();.
- Ajoutez le fruit "Mangue" à la fin du tableau.
- Affichez à nouveau le tableau dans le terminal pour vous assurer que le fruit a bien été ajouté au tableau.
- Remplacez "citron" par "orange" en ciblant l'élément correspondant à l'aide de son index.
- Affichez à nouveau le tableau dans le terminal pour vous assurer que "orange" remplace bien "citron".
- Supprimez le fruit "pomme" du tableau avec la fonction prédéfinie unset().
- Affichez à nouveau le tableau dans le terminal et observer les indices (index) du tableau.
- Réindexez le tableau avec la fonction prédéfinie array_values(); .
- Affichez à nouveau le tableau dans le terminal afin de vérifier que la réindexation a bien été effectuée.
Exo-variables-14
- Objectif : Manipuler un tableau associatif à une dimension création, modification, ajout et suppression dans le terminal.
- Instructions :
- Créez un fichier exo-variables-14.php.
-
Créez un tableau associatif $utilisateur contenant les paires
clé/valeur suivantes :
- 'prenom' : 'Alice'
- 'nom' : 'Dupont'
- 'age' : 30
- Affichez le tableau dans le terminal avec print_r();.
- Modifiez l'âge de l'utilisateur pour qu'il vaille 31 en ciblant la clé 'age'.
- Affichez à nouveau le tableau dans le terminal afin de vérifier que la nouvelle valeur a bien été prise en compte.
- Ajoutez une nouvelle entrée au tableau en ajoutant la clé 'ville' avec la valeur 'Bruxelles'.
- Affichez à nouveau le tableau dans le terminal pour vous assurer que la clé 'ville' et sa valeur sont bien présentes.
- Supprimez l'entrée correspondant à la clé 'nom' à l'aide de la fonction prédéfinie unset();.
- Affichez à nouveau le tableau dans le terminal et observez que les autres clés du tableau associatif ne sont pas modifiées.
Exo-variables-15
- Objectif : Manipuler un tableau associatif à une dimension et former une phrase à l'aide de la concaténation implicite.
- Instructions :
- Créez un fichier exo-variables-15.php.
-
Créez un tableau associatif $personnage contenant les paires
clé/valeur suivantes :
- 'prenom' : 'Youssef'
- 'nom' : 'El Amrani'
- 'age' : 28
- 'profession' : 'Développeur'
- Déclarez une variable $message dans laquelle vous tenterez de construire la phrase "Youssef El Amrani a 28 ans et travaille comme Développeur." en utilisant uniquement la concaténation implicite (c'est-à-dire en insérant directement les valeurs du tableau dans la chaîne, sans utiliser l'opérateur de concaténation .).
- Exécutez votre fichier pour observer l'erreur générée lorsque vous insérez directement $personnage['prenom'] ou toute autre clé textuelle dans une chaîne entre guillemets doubles.
- Corrigez ensuite la construction de votre variable $message en entourant chaque accès au tableau avec des accolades {…} afin de permettre à PHP d'interpréter correctement les expressions.
- Terminez l'exercice en affichant votre phrase complète avec une instruction echo.
Exo-variables-16
- Objectif : Découvrir une fonction prédéfinie pour combiner deux tableaux.
- Instructions :
- Créez un fichier exo-variables-16.php.
- Créez deux tableaux indexés
$groupeA et $groupeB
contenant chacun trois prénoms :
- $groupeA contient les prénoms "Sofia", "Alice", "Lucie".
- $groupeB contient les prénoms "Marc", "Yanis", "Damien".
- Affichez chaque tableau séparément dans le terminal avec print_r().
- Utilisez la fonction array_merge() pour créer un tableau $groupeComplet qui rassemble les deux groupes.
- Affichez le tableau fusionné $groupeComplet avec print_r().
Exo-variables-17
- Objectif : Utiliser une fonction prédéfinie pour vérifier si un élément est présent dans un tableau.
- Instructions :
- Créez un fichier exo-variables-17.php.
- Créez un tableau $roles avec quelques rôles par exemple "admin", "editor", "user".
- Utilisez la fonction in_array() pour vérifier si "admin" est présent dans le tableau. Affichez le résultat avec var_dump() afin d'observer la valeur booléenne retournée.
- Faites la même chose pour un rôle inexistant, par exemple "guest", puis observez la différence entre les deux résultats.
- Ajoutez un commentaire pour expliquer ce que retourne in_array() lorsque la valeur recherchée est présente et lorsqu'elle est absente du tableau.
Exo-variables-18
- Objectif : Manipuler un tableau à deux dimensions uniquement indexé.
- Instructions :
- Créez un fichier exo-variables-18.php.
-
Créez un tableau $notes qui contient trois sous-tableaux indexés.
Chaque sous-tableau représente les notes d'un élève sur trois tests :
- Élève 1 : 12, 15, 18
- Élève 2 : 9, 14, 11
- Élève 3 : 16, 13, 17
- Affichez le tableau $notes avec print_r().
- Modifiez la deuxième note du premier élève pour qu'elle vaille 20.
- Affichez uniquement les notes du premier élève en ciblant son sous-tableau avec les crochets puis en utilisant print_r() pour vérifier la modification.
- Ajoutez une nouvelle note au deuxième élève, avec la valeur 19, dans son sous-tableau.
- Affichez uniquement les notes du deuxième élève en ciblant son sous-tableau avec les crochets puis en utilisant print_r() pour vérifier l'ajout.
- Supprimez la deuxième note du troisième élève en utilisant unset() sur l'élément correspondant.
- Affichez uniquement les notes du troisième élève en ciblant son sous-tableau avec les crochets puis en utilisant print_r() pour vérifier la suppression.
- Affichez uniquement la troisième note du premier élève en utilisant les deux index sur le tableau $notes.
- Calculez la moyenne des notes du deuxième élève et stockez-la dans une variable $moyenne.
- Créez une variable $message contenant une phrase complète construite uniquement avec la concaténation implicite (sans utiliser l'opérateur .). Les valeurs affichées dans la phrase doivent provenir directement du tableau $notes en ciblant chaque élément à l'aide des crochets, ainsi que de la variable $moyenne elle-même insérée en concaténation implicite. La phrase attendue est : "La moyenne des notes (9, 14, 11, 19) du deuxième élève est 13.25"
- Affichez la variable $message dans le terminal.
Exo-variables-19
- Objectif : Manipuler un tableau à deux dimensions uniquement associatif.
- Instructions :
- Créez un fichier exo-variables-19.php.
-
Créez un tableau $produits dans lequel chaque clé représente
le nom d'un produit (
'cahier',
'stylo' et
'gomme')
et chaque valeur est un tableau associatif contenant son prix ('prix') et son stock ('stock').
Utilisez la structure suivante :
-
'cahier' :
- 'prix' : 2
- 'stock' : 30
-
'stylo' :
- 'prix' : 3
- 'stock' : 30
-
'gomme' :
- 'prix' : 1
- 'stock' : 50
-
'cahier' :
- Affichez le tableau $produits avec print_r().
- Modifiez le prix des cahier pour qu'il vaille 2.5 en ciblant d'abord la clé du cahier ('cahier') et ensuite la clé du prix ('prix') (d'abord la clé du produit, puis la clé pour le prix).
- Affichez uniquement les informations du cahier avec print_r() pour vérifier que le prix a bien été modifié.
-
Ajoutez un nouveau produit dans le tableau
$produits :
-
'crayon'
- 'prix' : 1
- 'stock' : 20
-
'crayon'
- Affichez le tableau $produits avec print_r() pour vérifier que le produit a bien été ajouté.
- Supprimez la gomme du tableau $produits en utilisant la fonction prédéfinie unset().
- Affichez à nouveau le tableau $produits avec print_r() pour vérifier que le tableau contenant les informations de la gomme a bien été supprimé.
- Affichez uniquement le stock des stylos à partir du tableau $produits
- Calculez la valeur totale du stock des stylos en multipliant son prix par son stock, en utilisant directement les valeurs présentes dans Stockez le résultat dans une variable $valeurTotaleStylos.
- Créez une variable $message contenant une phrase complète construite uniquement avec la concaténation implicite (sans utiliser l'opérateur de concaténation .). Les valeurs affichées dans la phrase doivent provenir directement du tableau $produits en ciblant les clés avec les crochets, ainsi que de la variable $valeurTotaleStylos elle-même insérée en concaténation implicite. La phrase attendue : "La valeur totale du stock de stylo est 90€".
- Affichez la variable $message dans le terminal avec echo.
Exo-variables-20
- Objectif : Manipuler un tableau à deux dimensions mêlant index et clés associatives.
- Instructions :
- Créez un fichier exo-variables-20.php.
-
Créez un tableau $classe dans lequel chaque élément est un
tableau associatif représentant un élève. Utilisez la structure suivante :
-
Élève à l'index 0
- 'prenom' : 'Salma'
- 'age' : 21
- 'ville' : 'Bruxelles'
-
Élève à l'index 1
- 'prenom' : 'Sara'
- 'age' : 19
- 'ville' : 'Liège'
-
Élève à l'index 2
- 'prenom' : 'Christian'
- 'age' : 22
- 'ville' : 'Namur'
-
Élève à l'index 0
- Affichez le tableau $classe avec print_r().
- Modifiez l'âge du deuxième élève (Sara) pour qu'il vaille 20 en ciblant d'abord l'index 1 puis la clé 'age'.
- Affichez uniquement les informations du deuxième élève (Sara) avec print_r() pour vérifier que l'âge a bien été modifié.
-
Ajoutez un nouvel élève en fin de tableau $classe
avec les informations suivantes :
- 'prenom' : 'Karim'
- 'age' : 22
- 'ville' : 'Charleroi'
- Affichez le tableau $classe avec print_r() pour vérifier que le nouvel élève a bien été ajouté.
- Supprimez le troisème éléve (Christian) du tableau $classe en utilisant la fonction prédéfinie unset().
- Affichez à nouveau le tableau $classe avec print_r() pour vérifier que l'élève a bien été supprimé.
- Calculez la moyenne d'âge des élèves restants et stockez-la dans une variable $moyenneAge. Utilisez directement les valeurs présentes dans le tableau $classe en ciblant les index et la clé 'age'.
- Créez une variable $message contenant une phrase complète construite uniquement avec la concaténation implicite (sans utiliser l'opérateur de concaténation .). Les valeurs affichées dans la phrase doivent provenir directement du tableau $classe en ciblant l'index de tous les élèves suivi de la clé associative correspondant aux prénoms, ainsi que de la variable $moyenneAge insérée elle aussi en concaténation implicite. La phrase attendue : "Salma, Sara et Karim ont une moyenne d'âge de 21 ans."
- Affichez la variable $message dans le terminal avec echo.