1.1Variables, types & opérateurs
L'essentiel en 30 secondes
- Variable = $ + nom clair, typage dynamique : $prixTotal = 1200; — PHP déduit le type de la valeur (string, int, float, bool, array, null, object).
- Concaténer avec le POINT, jamais + : 'Bonjour ' . $nom — le + n'assemble pas les chaînes en PHP.
- Comparer en STRICT par défaut : === (valeur ET type, prévisible) plutôt que == (conversion automatique, bugs et failles).
Mini-cas filé — Riad, développeur web à Constantine
Riad, développeur web à Constantine, prépare le devis d'un site vitrine : il stocke le prix HT dans $prixHT, calcule la TVA avec les opérateurs arithmétiques, puis affiche « Total : » suivi du montant. Pressé, il assemble le message avec + et compare le code promo saisi ("5") au nombre 5 avec == : l'affichage donne 0 au lieu du texte, et un code promo inattendu passe la comparaison. Il corrige en concaténant avec le point et en comparant avec === : le devis s'affiche correctement et seuls les vrais codes promos sont acceptés.
Ce même cas revient dans le cours, le schéma, le script et le défi 48h — et continue en 1.2, 1.3, 1.4 et 1.5.
1. Variables & types
Une variable commence toujours par $ ($nom), affectée avec = ($age = 30;). PHP a un typage dynamique : le type suit la valeur, sans déclaration préalable — une variable peut changer de type au fil du code. Types à connaître : string (texte), int (entier), float (décimal), bool (true/false), array (tableau), null, object. Nommez vos variables clairement ($prixTotal plutôt que $x) : le nommage explicite est une clé de lisibilité.
Riad stocke $prixHT = 10000; et $client = "Yasmine"; : des noms qui disent ce qu'ils contiennent, relus sans effort trois semaines plus tard quand le client demande une modification.
2. Opérateurs, === et guillemets
Opérateurs : arithmétiques (+ - * / % **), affectation (=, +=…), comparaison, logiques (&& || !). La concaténation utilise le POINT . (pas + !). CRUCIAL : == compare avec conversion de type (« lâche », résultats surprenants) ; === compare valeur ET type (« strict ») — privilégier ===. Guillemets doubles interprètent les variables ("Bonjour $nom") ; simples = littéral ('Bonjour $nom').
Riad remplace son + par un . pour assembler « Total : » et le montant, et son == par === pour le code promo : l'affichage devient correct et la comparaison prévisible.
🔎 Exemple concret — 🔎 Exemple concret — === vs == et guillemets
Éviter les surprises, comme Riad sur son devis.
$nom = 'Riad';
echo "Bonjour $nom"; // Bonjour Riad (interprete)
echo 'Bonjour $nom'; // Bonjour $nom (litteral)
$message = 'Total : ' . 12000; // concatenation au point
echo $message;
var_dump('5' == 5); // true (conversion lache)
var_dump('5' === 5); // false (type different)Lecture : les doubles affichent la valeur, les simples le texte brut ; le point assemble, === verrouille le type.
Leçon : des comparaisons prévisibles et un affichage maîtrisé — le réflexe === par défaut.
Vocabulaire de la section
- Variable ($)
- Stocke une donnée ; commence toujours par $ ($nom), affectée avec =. Nom sensible à la casse, à choisir clair et parlant.
Exemple simple : Le $prixHT et le $client du devis de Riad.
Ce que ce n'est pas : un $x cryptique dont personne ne devine le contenu.
Réflexe : toujours $, nom explicite, casse cohérente.
- Typage dynamique
- PHP détermine le type selon la valeur (pas de déclaration préalable) ; une variable peut changer de type. Types : string, int, float, bool, array, null, object.
Exemple simple : Le $prixHT de Riad, entier puis décimal après la TVA.
Ce que ce n'est pas : déclarer le type à l'avance comme en langage compilé.
Réflexe : penser valeur d'abord, vérifier avec var_dump en cas de doute.
- Opérateurs
- Arithmétiques (+ - * / % **), affectation (=, +=…), comparaison (==, ===, !=, <, >…), logiques (&& || !).
Exemple simple : Le calcul de TVA de Riad ($prixHT * 1.19).
Ce que ce n'est pas : utiliser + pour assembler deux chaînes.
Réflexe : calculer avec les opérateurs, assembler avec le point.
- Concaténation (.)
- En PHP, on assemble les chaînes avec le POINT . (pas +) : 'Bonjour ' . $nom.
Exemple simple : Le « Total : » . $montant affiché par Riad.
Ce que ce n'est pas : 'Total : ' + $montant, qui calcule au lieu d'assembler.
Réflexe : chaînes à assembler = point, toujours.
- == vs === / guillemets
- == compare avec conversion de type (lâche, surprenant) ; === compare valeur ET type (strict, à privilégier). Doubles interprètent les variables, simples = littéral.
Exemple simple : Le code promo testé en === par Riad ; son message en doubles.
Ce que ce n'est pas : valider un jeton sensible avec ==.
Réflexe : === par défaut ; doubles pour interpréter, simples sinon.
En pratique — En pratique — Manipuler variables, types et opérateurs
- Déclarez des variables de différents types (string, int, float, bool) avec `$` et affichez-les ; observez le typage dynamique.
- Faites des calculs avec les opérateurs arithmétiques (dont % modulo) et concaténez des chaînes avec le POINT `.` (pas `+`).
- Comparez avec `==` puis `===` sur une chaîne et un nombre (ex. '5' et 5) : observez la différence (conversion vs strict) et privilégiez `===`.
- Testez les guillemets : `"Bonjour $nom"` (interprète la variable) vs `'Bonjour $nom'` (littéral) — constatez la différence.
Script prêt à dire — justifier === en revue de code (30 s)
« Je propose qu'on compare en === partout ici : avec ==, PHP convertit les types et un code promo inattendu peut passer. Le strict rend la comparaison prévisible, et pour les valeurs sensibles c'est aussi une question de sécurité. »
À dire en revue de code ; montrer le var_dump('5' == 5) face à ===.
Modèle copier-coller — variables, concaténation, comparaison stricte
Devis à Constantine
Comme Riad : prix HT, TVA et total dans des variables nommées, message assemblé au point — le client relit un devis net, sans chiffre fantaisiste.
Code promo à valider
Comparer la saisie au code attendu en === : aucune conversion surprise, seuls les codes exacts passent.
Affichage avec variables
Doubles quand le texte contient des variables ("Bonjour $nom"), simples pour le texte pur — et concaténation explicite en alternative.
Doute sur un type
Un var_dump($variable) en local tranche : le typage dynamique se vérifie, il ne se devine pas.
✓ Bonnes pratiques
- Privilégier === / !== par défaut (comparaison stricte, prévisible).
- Concaténer les chaînes avec le point (jamais +).
- Nommer les variables clairement et rester cohérent (casse).
✗ Pièges fréquents
- Utiliser == et subir une conversion de type surprenante.
- Concaténer avec + (n'existe pas pour les chaînes en PHP).
- S'attendre à ce que 'Bonjour $nom' (guillemets simples) affiche la valeur.
Points clés à retenir
- Une VARIABLE commence toujours par `$` (`$nom`), affectée avec `=`. PHP a un TYPAGE DYNAMIQUE (le type suit la valeur). Types : string, int, float, bool, array, null, object.
- CONCATÉNATION des chaînes avec le POINT `.` (PAS `+` !). Opérateurs : arithmétiques (+ - * / % **), affectation (+=…), comparaison, logiques (&& || !).
- CRUCIAL : `==` compare avec conversion de type (lâche, surprenant) ; `===` compare valeur ET type (strict) — PRIVILÉGIER `===` / `!==`.
- Guillemets DOUBLES interprètent les variables (`"Bonjour $nom"`) ; guillemets SIMPLES = littéral (`'Bonjour $nom'`). Nommer les variables clairement (lisibilité).
Défi 48h — appliquez demain
Reprenez un de vos scripts (modèle ci-dessus) : remplacez chaque == par === (sauf conversion voulue), chaque + entre chaînes par un point, et renommez une variable cryptique. Exécutez en local et vérifiez l'affichage. 20 minutes suffisent.
- Je peux expliquer $ , le typage dynamique et la concaténation au point.
- Je compare en === par défaut et je sais pourquoi.
- Je choisis doubles (interprètent) vs simples (littéral) sans hésiter.
Questions fréquentes
Pourquoi privilégier === plutôt que == en PHP, et quels bugs cela évite-t-il ?
`==` compare deux valeurs en effectuant une CONVERSION de type automatique si les types diffèrent (comparaison « lâche »), ce qui donne des résultats surprenants et contre-intuitifs. `===` compare la valeur ET le type, SANS conversion (« strict »), donc prévisible. Les bugs que `==` peut causer : comparer une chaîne et un nombre (conversions déroutantes), les pièges des valeurs « falsy » (0, '', '0', null, [] considérés « faux »), et surtout des cas dangereux — historiquement, des comparaisons de hachages ou de jetons mal faites avec `==` ont causé des failles de sécurité. PHP 8 a corrigé certains cas absurdes, mais le principe demeure : `==` convertit, `===` non. Bonne pratique : utilisez `===` (et `!==`) par DÉFAUT ; si vous devez comparer des types mêlés, CONVERTISSEZ explicitement d'abord (contrôle) plutôt que de subir la conversion implicite.
Guillemets simples ou doubles : quelle différence et laquelle utiliser ?
Guillemets DOUBLES `"..."` : INTERPRÈTENT le contenu — les variables (`"Bonjour $nom"` insère la valeur) et les séquences d'échappement (`\n`, `\t`). Guillemets SIMPLES `'...'` : prennent le contenu LITTÉRALEMENT — `'Bonjour $nom'` affiche le texte « Bonjour $nom » (pas la valeur). Bonnes pratiques : guillemets SIMPLES par défaut pour du texte pur (plus prévisible) ; guillemets DOUBLES quand vous voulez interpréter des variables ; alternative recommandée : la CONCATÉNATION avec le point (`'Bonjour ' . $nom`), explicite et prévisible. Vigilance : un `$` accidentel en guillemets doubles peut causer un comportement inattendu.
Quelle comparaison privilégier en PHP moderne ?