Si vous ne savez pas de quel type est une variable, vous pouvez utiliser la fonction var_dump() qui vous renverra le type de votre variable ainsi que le contenu de la variable.

$variable = "42";
var_dump($variable); // Affiche string(2) "42"

$prenom = "John";
$nom = "Doe";
$dizaines = 40;
$unites = 2;
$age = $dizaines + $unites; // addition de nombres

echo "Bonjour, je m'appelle $prenom $nom et j'ai $age ans.";

Si vous devez rassembler plusieurs chaines de caractères (la concaténation), l'opérateur à utiliser, contrairement à d'autres langages, cela ne sera pas le '+' mais le simple point '.'

echo 'Bonjour, je suis ' . $prenom . ' ' . $nom; // addition de chaines

Les conditions et les boucles

Pas de miracle, les conditions sont comme pour tous les autres langages : if, else, elseif. Par contre, la différence est l'utilisation du test avec l'égalité. PHP dispose d'un test avec == mais aussi ===. Le premier == va mettre en corrélation la valeur testée à droite avec la valeur de gauche pourvu qu'elles soient à peu près égales, à savoir PHP va interpoler les valeurs pour essayer de les mettre en correspondance. L'utilisation de === va en plus vérifier que les types des éléments testés sont identiques. C'est pourquoi avec PHP vous utiliserez plutôt la triple égalité plutôt que la double pour que le test soit plus précis.

Dans l'exemple ci-dessous le test avec $note repose sur une interpolation réalisée par PHP qui gère la valeur chaine comme un entier et qui détermine une égalité entre un entier et une valeur chaine qui représente un entier. Il y aura donc égalité.

$note = readline('Entrez une note : '); // $note sera une chaine
if ($note >= 10) {
  echo "Bravo vous avez au moins la moyenne.";
} elseif ($note == 10) {
  echo "La moyenne, peut mieux faire...";
} else {
  echo "Va falloir travailler un peu plus maintenant.";
}

Maintenant si le test doit être parfaitement sûr, il faudra utiliser une comparaison de valeur et de type, ce qui sera fait avec la triple égalité ===. Il faut faire en sorte que la valeur saisie soit transformée en entier avant la condition. Nous réalisons cela avec une conversion de type (un cast)

$note = (int)readline('Entrez une note : '); // $note sera un entier
if ($note >= 10) {
  echo "Bravo vous avez au moins la moyenne.";
} elseif ($note === 10) { // Comparaison avec une valeur entière en plus de la valeur elle-même
  echo "La moyenne, peut mieux faire...";
} else {
  echo "Va falloir travailler un peu plus maintenant.";
}

Une autre façon de faire des tests est de choisir la solution de branchement sélectif, utile lorsqu'il y a potentiellement beaucoup de tests à enchainer avec des if. C'est la notion de switch...case.

$action = (int)readline('Que faites-vous : (1:run, 2:fight, 3:examine, 4:talk, 5:quit)');
switch ($action) {
  case 1:
    echo "Je pars en courant.";
    break;
  case 2:
    echo "Banzaï je cogne!";
    break;
  case 3:
    echo "Je regarde de plus près.";
    break;
  case 4:
    echo "Allô non mais allô quoi ?";
    break;
  case 5:
    echo "Bye bye.";
    break;
  default:
    echo "Je n'ai pas compris...";
    break;
}

Si vous voulez associer des conditions entre elles, il est possible d'affecter des conditions avec des ET logiques et des OU logiques.

• Un ET logique rendra vrai uniquement si les deux valeurs testées sont vraies. Il se note &&
• Un OU logique rendra vrai si au moins une des valeurs est vraie. Il se note ||
• Un NOT logique prendra l'inverse de la valeur récupérée, transformant un vrai en faux et inversement.

$a = 1;
$b = 2;

if ($a === 1 && $b === 2) {
  echo "Les deux valeurs sont vraies donc je valide.";
} else {
  if ($a === 1 || $b === 2) {
    echo "Une des deux valeurs est vraie alors je peux passer.";
  }
}

Pour la création de boucle nous disposons de

• une boucle tant que (while) indiquant une condition d'arrêt
• une boucle avec une valeur de départ pour une série de valeurs (for)
• une boucle pour chaque valeur d'un ensemble (foreach)

Pour les deux premiers types de boucles nous retrouvons la même syntaxe que pour l'ensemble des autres langages de programmation. Par contre pour le parcours d'un ensemble, nous aurons une notation particulière qui va signaler que, pour chaque élément d'un ensemble, une variable locale va être créée pour nous permettre de manipuler la valeur de l'ensemble. La syntaxe fonctionne à l'envers sachant que, si vous avez déjà développé quelques programmes en C#, c'est la notation opposée qui est utilisée. foreach ($ensemble as $variable) { }. Ainsi la variable nommée $variable va se voir affecter chaque index de l'ensemble successivement.

Si le tableau est de type associatif c'est-à-dire avec des clés identifiant les valeurs plutôt que simplement des indices, alors la boucle foreach sera plutôt de ce type foreach ($ensemble as $cle => $variable) permettant de récupérer la clé en plus de la variable.

$valeur = 0;
// Boucle tant que la valeur est toujours inférieure à 42
while ($valeur <= 42) {
  $valeur += 2;
}

// Boucle pour toutes les valeurs de 0 à 42
for ($i = 0; $i <= 42; $i++) {
  echo $i;
}

// Parcours d'un ensemble de données
$notes = [10, 12, 16, 20, 16];
foreach ($notes as $note) { // La variable $note prendra successivement la valeur de chaque index du tableau
  echo $note;
}

$eleves = [
  'CM1' => 'John',
  'CM2' => 'Jane'
];
foreach ($eleves as $classe => $eleve) {
  echo "$eleve est dans la classe de $classe\n";
}