Les variables, constantes et tableaux en PHP

Une variable permet de stocker une valeur en mémoire.
Une constante stocke également une valeur mais son contenu initial ne peut pas être modifié ensuite.
PHP propose deux types de tableaux : les tableaux indicés et les tableaux associatifs.
Les séquences à valeurs uniques ('set') n'existent pas en PHP mais une fonction permet de supprimer à postériori les doublons éventuels dans un tableau.

Les variables simples

Dans le chapitre précédent ("quelques bonnes raisons d'utiliser PHP") j'ai déjà survolé la notion de variable.
Rappelez vous la table de multiplication par 8. <?php for ($i=1; $i<=50; $i++) { $produit = 8 *$i ; echo "<tr>"; echo "<td>8</td>"; echo "<td>". $i ."</td>"; echo "<td>" . $produit ."</td>"; echo "</tr>" ; } ?>

$i et $produit sont des variables simples PHP.
Le premier caractère d'une variable PHP doit être le symbole $

Règles de nommage d'une variable

Le nom doit être préfixé par le caractère $.
Le nom ne doit pas contenir d'espace, ni de caractères spéciaux (-, !, %, etc.) sauf le _ (underscore).
Par ailleurs une variable peut seulement commencer par une lettre ou un underscore ; les chiffres sont autorisés mais pas en premier caractère.
les noms de variables sont sensibles à la casse. Ainsi $nom et $NOM sont deux variables différentes.

Type d'une variable

Le type d'une variable peut donc évoluer en fonction de sa valeur. Le typage des variables est implicite et dynamique en PHP. Il n’est donc pas nécessaire de déclarer le type au préalable.

La fonction gettype()

Le code de l'exemple

...
<h3>Le type dynamique des variables en PHP</h3>
<h4>
<?php
	$variable = 99; $type = gettype($variable);
	echo "Type de $variable est $type <br>" ; 

	$variable=3.14; $type = gettype($variable);
	echo "Type de $variable est $type <br>" ; 
			
	$variable ="Bonjour mes amis"; $type =gettype($variable);
	echo "Type de $variable est $type <br>" ; 
	
	$variable = true ; $type = gettype($variable);
	echo "Type est $type <br>" ; 
	
	$variable = FALSE ; $type = gettype($variable);
	echo "Type est $type <br>" ; 
	
	$variable = 'false' ; $type = gettype($variable);
	echo "Type de $variable est $type <br>" ; 
		
	$variable = [8,16,12]; $type = gettype($variable);
	echo "Type est $type <br>" ; 
	
	$variable = NULL; $type =gettype($variable);
	echo "Type est $type <br>" ; 
	
	$variable ="Bonjour" ; 
	var_dump($variable); 
?>
</h4>
...

Notez l'emploi de la fonction gettype(variable) qui retourne le type d'une variable OU plutôt le type de donnée contenu dans cette variable.
Pour créer un booléen il faut saisir true/false et surtout ne pas délimiter par des guillemets.
Les mots true / false sont insensibles à la casse.
La fonction var_dump() argumentée avec une variable donne beaucoup d'infos sur celle-ci : type, longueur et contenu.
Notez la balise ouvrante H4 avant le début du script et la la balise fermante H4 après le script. Ainsi tous les instructions echo du script se voient appliquer le style défini pour le sélecteur H4.

Le rendu

integer (entier)
double (nombre décimal) ; surtout un point comme séparateur décimal
string (chaine de caractères)
boolean (booléen)
array (tableau)
NULL (variable vide)

L'avant avant dernière instruction retourne "array". En effet j'ai affecté dans $variable une liste de valeurs entre crochets (un tableau indicé).
Les tableaux sont abordés en deuxième partie de ce chapitre.

Les constantes en PHP

Lapalisse aurait pu dire : "une constante est une variable constante". Plus sérieusement une constante est un type particulier de variable qui ne peut être modifiée après avoir été initialisée.

Exemple - le code

...
<h3>Les constantes</h3>
<h4>
<?php
define('FR',6.56); 
$montant_euro = 10000; 
$montant_franc = $montant_euro * FR; 
echo "<br>$montant_euro donne en francs : $montant_franc "; 
echo '<br>Valeur retournée par la fonction   pi() : ' . pi(); 
?>
</h4>
...

On définit une constante avec la fonction define('nom',valeur)
Le nom d'une constante ne commence pas par le symbole $ ; par convention les lettres sont en majuscules.
Il est inutile de définir sous forme d'une constante PI car une fonction mathématique (pi()) retourne la valeur de PI.

Le rendu

Les opérations en PHP

La concaténation

Pour assembler des expressions (chaines, variables, balisage) il faut les relier avec l'opérateur de concaténation qui est le point : "." (et non pas "+").

Exemple - le code

...
<h3>Concaténation ou  pas ? </h3>
<h4>
<?php
	$age = 70; 
	echo 'Mon âge est ' . $age . ' ans' .'<br>' ; 
	echo 'Mon âge est $age ans <br>'; 
	echo "Mon âge est $age ans <br>"; 
?>
</h4>
...

Premier echo : emploi de l'opérateur de concaténation pour assembler chaine, variable et balisage ; la syntaxe est lourde.
Deuxième echo : la variable $age est insérée dans une chaine délimitée par des guillemets simples.
Troisième echo : la variable $age insérée dans une chaine délimitée par des guillements doubles.

Le rendu

Premier echo : affichage correct mais syntaxe lourde car concaténation.
Deuxième echo : bug (affichage du nom de la variable et non pas son contenu).
Troisième écho : affichage correct et syntaxe succincte : une seule chaine intégrant variables et et balises.

Les opérateurs arithmétiques

Il s'agit des opérateurs +, -, *,/ pour respectivement addition, soustraction, multiplication et division.
Pour obtenir le reste de la division entière il faut utiser l'opérateur % (modulo).
Exemple : $reste = 10%3 ; $reste récupère 1 car le reste de la division entière de 10 par 3 est 1.

Pour élever à la puissance N il faut utiliser **
Exemple : $resultat = 10**6 ; $resultat récupère 1 000 000 (10 à la puissance 6)

Les opérateurs combinés

Ce sont des opérateurs qui effectuent un traitement mais aussi une affectation.
Leur utilisation simplifie les instructions.

$variable += 2 : ajouter 2 à $variable ; remplace $variable = $variable+2
$variable -= 2: retirer 2 à $variable ; remplace $variable = $variable-2
$variable ++ : incrémenter $variable de 1 ; équivaut à $variable = $variable+1
$variable -- : décrémenter $variable de 1 ; équivaut à $variable = $variable-1

Exemple

...
<h3>Opérateurs combinés</h3>
<h4>
<?php
	// incrémentation
	$init = 20;
	echo "valeur initiale : $init <br>";
	$init = $init + 1 ;
	echo "nouvelle valeur :  $init <br>";
	$init +=1; 
	echo "nouvelle valeur :  $init <br>";
	$init ++; 
	echo "nouvelle valeur :  $init <br>";
	
	echo '<hr>'; 
	// décrémentation 
	$init2 = 30;
	echo "valeur initiale : $init2 <br>";
	$init2 = $init2 - 1 ;
	echo "nouvelle valeur :  $init2 <br>";
	$init2 -=1; 
	echo "nouvelle valeur :  $init2 <br>";
	$init2 --; 
	echo "nouvelle valeur :  $init2 <br>";
	
?>
</h4>
...

J'incrémente trois fois $init avec trois syntaxes différentes.
Je décrémente trois fois $init2 avec trois syntaxes différentes.

Le rendu

Les tableaux indicés

Un tableau indicé stocke plusieurs valeurs.
Ces valeurs peuvent être des nombres, des chaines voire d'autres tableaux.
Chaque élément est référencé par un indice ; il ne faut pas saisir les indices c'est PHP qui gère.

Exemple - le code

Dans ce script : création de tableaux indicés et quelques manipulations. ... <h3>Création de tableaux indicés</h3> <p>Et premières manipulations. <h4> <?php //création d'un tableau indicé avec la fonction array $equipe1 =array('Louis', 'Daniel', 'Marc', 'François', 'Patrick', 'Benoît'); // création d'un tableau avec syntaxe crochets $equipe2= ['Lionel', 'Denis', 'Marcel','Frédéric', 'Paul', 'Bernard']; // La fonction print_r pour afficher la totalité d'un tableau print_r ($equipe1); echo '<hr>'; print_r ($equipe2); echo '<hr>'; //Parcourir le premier tableau : afficher valeurs echo "Liste des membres de l'équipe 1 <br>"; foreach ($equipe1 as $element) { echo "$element - " ; } echo "<hr>"; //Parcourir le deuxième tableau : afficher indices et valeurs echo "Liste des membres de l'équipe 2 <br>"; foreach ($equipe2 as $indice=>$valeur) { echo "$indice : $valeur - " ;} echo "<hr>"; // afficher certains éléments echo "Deuxième de l'équipe 1 : $equipe1[1] <br>"; echo "Troisième de l'équipe 2 : $equipe2[2] <br>"; ?> </h4> ...

Je vous montre deux façons de créer un tableau indicé.
Dans le premier tableau j'utilise la fonction array suivi de la liste de toutes les valeurs du tableau.
Dans l'autre tableau j'utilise la notation 'crochets'.
Notez que les indices ne sont pas saisis.

Pour afficher en une seule instruction la totalité d'un tableau il suffit d'utiliser le fonction print_r(nomTableau) qui affiche pour chaque élément son indice et la valeur correspondante.
Le premier élément d'un tableau indicé à l'indice 0.

Pour parcourir un tableau, PHP propose la structure foreach.
Vous pouvez alors vous contenter d'afficher les valeurs OU afficher pour chaque élément : indice & valeur.

Le rendu

Autres manipulations de tableaux indicés

On peut appliquer à un tableau indicé de nombreuses fonctions.

Le code de l'exemple

...
<h4>
<php
	$notes = array(12,8,7,11,5,9,6,10);
	echo "affichage du tableau indicé : <br>";
	print_r($notes); 
	
	//ajout au tableau
	$notes[]=13;
	$notes[]=4;
	echo "<hr>affichage du tableau suite aux ajouts : <br>";
	foreach ($notes as $element) {echo "$element - " ;}
	
	echo "<hr>"; 
	$n = count($notes);
	echo "nouvelle taille du tableau : $n " ;
	
	// moyenne des notes
	echo "<hr>";
	$somme = array_sum($notes);
	echo "cumul des notes  : $somme <br>" ;
	$moyenne = $somme /$n ;
	echo "moyenne des notes  : $moyenne" ; 
	
		
	// déplacement dans le tableau
	$premier = reset($notes);
	$suivant = next($notes);
	echo "<hr>Premier élément du array : $premier" ;
	echo "<br>Elément suivant le premier : $suivant" ;
	$dernier = end($notes); 
	$precedent =prev($notes);
	echo "<br>Dernier élément du array : $dernier" ;
	echo "<br>Elément précédent le dernier : $precedent" ;	
	$maxi = max($notes);
	$mini = min($notes);
	echo "<br>Valeur maxi dans array : $maxi" ;
	echo "<br>Valeur mini dans array : $mini" ;	
	
	// tri du tableau indicé par valeurs croissantes
	sort($notes);
	echo "<hr>Affichage du tableau trié (croissanét) :  <br>";	
	foreach ($notes as $element) {echo "$element - " ; }
	
	// tri du tableau indicé par valeurs décroissantes
	rsort($notes);
	echo "<hr>Affichage du tableau trié (décroissant) :  <br>";	
	foreach ($notes as $element) {echo "$element - " ; }

	// emploi de var_dump
	echo "<hr>Infos détaillées sur le tableau : <br>" 
	var_dump($notes); 
?>
</h4>

Notez que systématiquement les chaines qui suivent l'instruction echo sont délimitées par des guillemets doubles afin de pouvoir y insérer des variables et du balisage HTML.
Pour afficher le contenu d'un tableau je privilégie la structure foreach().
Je vous montre aussi que l'on peut appliquer la fonction var_dump() à un tableau (indicé ou associatif).

Il est toujours possible d'ajouter des éléments à un tableau avec la syntaxe $tableau[] = valeur, PHP gérant l'indice.

print_r() permet d'afficher la totalité d'un tableau
count() retourne le nombre d'éléments d'un tableau
array_sum() additionne les valeurs numériques d'un tableau
sort() permet de trier par valeurs croissantes les éléments d'un tableau indicé
rsort() permet de trier par valeurs décroissantes les éléments d'un tableau indicé
end() retourne le dernier élément
reset() retourne le premier élément
max() retourne la valeur maxi
min() retourne la valeur mini
next() retourne élément suivant
prev() retourne élément précédent

La liste ci-dessus n'est pas exhaustive ; il existe d'autres fonctions qui seront abordées en fin de chapitre.

Le rendu

Notez que j'ai calculé la moyenne simple des notes en combinant les fonctions array_sum & count
La fonction var_dump() précise la longueur du tableau et précise pour chaque élément : indidce, type et valeur.

Les tableaux associatifs

Chaque élément est identifié non pas par un indice mais par un mot (une clé).
On parle de paires de "clé-valeur" !
Ainsi pour identifier un individu on utilise son nom, son prénom et sa civilité (Monsieur ou Madame).

Dans la page ci-dessous on décrit sous forme de tableaux associatifs deux individus.

Le script PHP

...
<h3>Création de tableaux associatifs</h3>
<h4>
<?php
	// premier tableau associatif
	$dupont =array('nom' =>'Dupont','prenom' =>'marie','civilite' =>'Mme');
	
	// deuxième tableau associatif
	$jeannot = ['nom' =>'Jeannot','prenom' =>'louis','civilite' =>'Mr'];
		
	// parcourir premier tableau sans affichage des valeurs
	echo "Fiche de Jeannot  : <br>" ; 
	foreach ($jeannot as $valeur)		{echo "$valeur <br>" ;   }
	
	// parcourir deuxième tableau avec affichage des clés & valeurs
	echo "<hr>";
	echo "Fiche de Dupont : <br>" ; 
	foreach ($dupont as $cle=>$valeur)		{echo "$cle  : $valeur <br>" ;   }
	
	// ajout d'une nouvelle paire de clé-valeur
	$jeannot['mail'] = 'jeannotlouis@gmail.com'; 
	$dupont['mail'] = 'dupont.marie@hotmail.fr'; 
	
	// utilisation de var_dump et print_r
	echo '<hr> Infos detailléees sur $dupont : <br>' ; 
	print_r($dupont); 
	echo '<hr> Infos detailléees sur $jeannot : <br>' ;
	var_dump($jeannot); 
	
?>
</h4>

une seule instruction avec utilisation de la fonction array().
une seule instruction sans utilisation de cette fonction ; il faut alors délimiter les données par une paire de crochets.

Dans les deux cas notez l'opérateur => avec la clé devant et la valeur après.
Pour les deux tableaux les clés sont : nom, prenom, civilite
Quant au parcours d'un tableau associatif on utilise aussi la boucle foreach() et on peut afficher pour chaque paire uniquement la valeur OU clé & valeur.
Pour obtenir des infos détaillées sur un tableau associatif on peut utiliser les fonctions print_r ou mieux encore var_dump().

Le rendu

La fonction print_r() se contente d'afficher les clés et les valeurs.
La fonction var_dump() précise la longueur du tableau (nombre de paires) et pour chaque valeur le type et la longueur.

les infos retournées par les fonctions print_r() & var_dump() sont précieuses mais on ne peut pas dire que la présentation qui en découle soit esthétique ...
Ces fonctions sont des outils de débogage essentiels mais réservées à la phase de développement.

Manipulation de tableaux associatifs

Compte tenu de la structure d'un tableau associatif (séquence de paires "clé=>valeur") certaines fonctions sont spécifiques à ce type de tableau et en particulier les fonctions de tri.

Le script

...
<h3>Manipuler les tableaux associatifs</h3>
<h4>
<?php
	$capitales = array('fr' =>'Paris','gb' =>'Londres','al' =>'Berlin','es' =>'Madrid');
	echo "<hr>"; 
	echo "affichage du tableau :<br>";
	print_r($capitales); 
	
	// ajout au tableau 
	$capitales['be'] = "Bruxelles";
	$capitales['it'] = "Rome";
	$capitales['ir'] ="Dublin"; 
	$capitales['da'] ="Copenhague"; 
	echo "<hr>Affichage du tableau après ajouts :<br>";
	foreach ($capitales as $cle=> $contenu)		
		{ echo "$cle : $contenu <br>" ;   }
	
	// taille du tableau
	$n = count($capitales);
	echo "<hr>Nouvelle taille du tableau : $n" ;
	
	// déplacer dans le tableau
	$premier = reset($capitales); 
	$dernier = end($capitales);
	$maxi = max($capitales);
	$mini = min($capitales);
	echo "<hr>Valeur de première paire : $premier"; 
	echo "<br>Valeur de dernière paire : $dernier";
	echo "<br>Valeur minimale dans array : $mini "; 
	echo "<br>Valeur maximale dans array : $maxi "; 
	
	// tri du tableau par valeurs croissantes
	asort($capitales);
	echo "<hr>Affichage du tableau trié par valeurs croisssantes <br>" ;
	foreach ($capitales as $cle=>$valeur)		
		{ echo "$cle : $valeur <br>" ;   }
			
	// tri du tableau par clés croissantes
	ksort($capitales);
	echo "<hr>Affichage du tableau trié par clés croissantes <br>" ;
	foreach ($capitales as $cle=>$valeur)		
		{ echo "$cle : $valeur <br>" ;   }
?>
</h4>
...

Pour un tableau associatif on peut trier par valeurs ou par clés, par ordre croissant ou par ordre décroissant.
Il y a donc quatre fonctions de tri :

asort() : tri croissant par valeurs
arsort() : tri décroissant par valeurs
ksort() : tri décroissant par clés
krsort() : tri décroissant par clés

Par contre certaines fonctions sont partagées par les tableaux indicées et les tableaux associatifs.
Citons entre autres : reset(), end(), max(), min() count() , nex(), prev(), etc.

Le rendu

Tableaux multidimensionnels

Un tableau indicé peut avoir pour éléments des tableaux indicés ou associatifs.

Exemple

...
<h3>Les tableaux multidimensionnels</h3>
<h4>
<?php
// un tableau indicé ayant pour éléments trois tableaux associatifs
$membres = 
[
    ['nom' => 'Marchand', 'prenom' => 'marie'],
    ['nom' => 'Laval', 'prenom' => 'pierre'],
    ['nom' => 'André', 'prenom' => 'jacques']
];
	
//afficher certains tableaux associatifs
// uniquement les valeurs 
$individu = $membres[0];
foreach ($individu as $valeur)	{echo "$valeur - " ;}
echo "<hr>";
	
// avec les clés et valeurs
$individu = $membres[2];
foreach ($individu as $cle=>$valeur) {echo "$cle  : $valeur - " ;}
echo "<hr>";

// avec print_r
$individu = $membres[1];
print_r($individu); 
echo '<hr>'; 
	
// parcours du tableau bidimensionnel
foreach($membres as $individu)
{
    foreach ($individu as $cle=>$valeur)  {echo "$cle: $valeur - ";}
    echo '<br>'; 
}
?>
</h4>
...

$membres est un tableau indicé comprennant trois tableaux associatifs.
J'affiche le détail de chaque tableau associatif avec différentes techniques.
Puis je parcoure le tableau bidimensionnel avec deux foreach imbriqués.

Le rendu

Autres traitements sur tableaux

La fonction array_unique()

Comparons différents langages

En Python les séquences de valeurs uniques se nomment "set" ; il en est de même en JavaScript.
Dans ces deux langages les 'sets' sont des séquences où l'ajout aboutissant à des doublons est impossible.
En PHP on ne peut pas véritablement créer de structures équivalentes. Mais on peut supprimer les doublons à postériori avec la fonction array_unique().

Exemple - le code

...
<h3>Les 'array' de valeurs uniques</h3>
<h4>
<?php
$multiple =[1,2,3,4,1,2,5];
$unique = array_unique($multiple); 
echo '<hr>Affichage du tableau $multiple <br> " ; 
foreach ($multiple as $element) {echo "$element - " ;}

echo '<hr>Affichage du tableau $unique : <br> ' ; 
foreach ($unique as $element) {echo "$element - " ;}

// insertions dans le tableau $unique 
$unique[] = 5; 
$unique[] = 6;
echo '<hr>Affichage du tableau $unique suite aux ajouts : <br>'; 
foreach ($unique as $element) {echo "$element - " ;}
// de nouveau des doublons

// suppression des doublons dans $unique
$unique = array_unique($unique); 
// le même tableau est source et destination de la commande
echo '<hr>Affichage du tableau $unique après correction : <br>'; 
foreach ($unique as $element) {echo "$element - " ;}
?>
</h4>
...

La fonction array_unique() supprime les doublons dans le tableau précisé.
Suite à des ajouts, des doublons peuvent de nouveau apparaitre. Le même 'array' peut être source et destination de la commande array_unique()

	$unique = array_unique($unique); 
	// suppression des doublons dans $unique

Le rendu

La fonction range()

La fonction range() crée un tableau contenant une plage d'éléments à partir de trois arguments : range(début,fin,pas). Le pas est facultatif (par défaut =1).
Si le paramètre début est supérieur au paramètre fin alors la liste est décroissante.
Les paramètres début et fin peuvent être des lettres minuscules ou majuscules.

Le code

...
<h4>
<?php 
echo '<hr>Affichage de $entiers <br>'; 
$entiers = range(1,10); 
foreach ($entiers as $element) {echo "$element - " ;}

echo '<hr>Affichage de $rebours<br>'; 
$rebours = range(9,1); 
foreach ($rebours as $element) {echo "$element - " ;}

echo '<hr>Affichage des majuscules<br>'; 
$majuscules = range('A','Z'); 
foreach ($majuscules as $element) {echo "$element - " ;}

echo '<hr>Affichage des minuscules<br>'; 
$minuscules = range('a','z'); 
foreach ($minuscules as $element) {echo "$element - " ;}

echo '<hr>Affichage de  $impairs <br>'; 
$impairs = range(1,20,2); 
foreach ($impairs as $element) {echo "$element - " ;}

echo '<hr>Affichage de $pairs <br>'; 
$pairs = range(2,20,2); 
foreach ($pairs as $element) {echo "$element - " ;}

echo '<hr> Affichage de $fusion'; 
$fusion = array_merge($entiers,$rebours); 

echo '<br>De $fusion avec doublons : <br>' ;
foreach ($fusion as $element) {echo "$element - " ;}

echo '<br>De $fusion triée : <br>' ;
sort($fusion); 
foreach ($fusion as $element) {echo "$element - " ;}

echo '<br>De $fusion - valeurs uniques : <br>';
$fusion = array_unique($fusion); 
foreach ($fusion as $element) {echo "$element - " ;}

$cherche = 5; 
if(in_array($cherche,$fusion)) 
	{echo "<br>$cherche existe dans ce tableau"; }
	else {echo "<br>$cherche n'existe pas dans ce tableau"; }
	else {echo "<br>$cherche n'existe pas dans ce tableau"; }
?>
</h4>
...

Pour créer rapidement des tableaux indicés j'ai utilisé la fonction range().
Je montre aussi comment fusionner deux tableaux en un seul avec la fonction array_merge().
Piqure de rappel sur sort() & array_unique().

La fonction in_array(valeur cherchée, tableau) retourne un booléen ; donc il faut l'intégrer dans un test !

Le rendu

Le rendu indique que 5 existe dans ce tableau.
Essayez avec 11 !Simuler le tirage au sort d'une carte

Le code

...
<h3>Simulation du tirage au sort d'une carte dans un  jeu de 32 cartes
<br><i>Actualisez la page pour simuler un nouveeau tirage</i></h3>
<h4>
<?php
// une carte a une enseigne et un rang
// il faut donc deux arrays
$enseignes = ['pique', 'coeur', 'carreau', 'trèfle'] ;
$rangs = ['As', 'Roi', 'Dame', 'Valet', '10', '9', '8' , '7'] ;

//prendre un indice au hasar dans chaque tableau
$i = array_rand($enseignes); 
$j = array_rand($rangs); 
echo "<br>Indice au hasard dans premier tableau : $i ; indice au hasard dans deuxième tableau : $j "; 

// convertir indice en valeur 
$enseigne_carte = $enseignes[$i]; 
$rang_carte = $rangs[$j]; 

// nommer la carte tirée
$carte_tiree = $rang_carte . ' de '. $enseigne_carte ; 
echo "<br>La carte tirée est : $carte_tiree " ; 
?gt;
</h4>
...

Une carte c'est une enseigne (ou couleur) et un rang (as, roi, ... 7).
La fonction array_rand() prend au hasard dans un tableau un indice (ou clé). Il faut donc récupérer ensuite la valeur correspondant à cet indice : valeur = tableau[indice]

Le rendu dans un autre onglet

Testez le code !

Pour aller plus loin : simuler le poker

Thème : simuler le tirage au sort de 5 cartes (une main au poker) et Il ne doit y avoir de doublons !
Il ne faut pas boucler 5 fois mais boucler tant que le tableau "$ma_main" ne comprend pas encore cinq valeurs distinctes ; en effet le hasard peut générer plusieurs fois la même carte.

Le rendu dans un autre onglet

Testez le code !

Exemple de rendu

La carte tirée est : Roi de coeur
La carte tirée est : As de coeur
La carte tirée est : 10 de trèfle
La carte tirée est : Dame de carreau
La carte tirée est : 10 de trèfle
La carte tirée est : As de coeur
La carte tirée est : 7 de carreau
Ma main est :
Roi de coeur - As de coeur - 10 de trèfle - Dame de carreau - 7 de carreau -

Il a fallu 7 passages dans la boucle pour générer 5 cartes distinctes ! Donc une structure for() qui boucle 5 fois n'est pas envisageable.

Le code

À vous de travailler !
Vous devriez être capable de réaliser ce script surtout si vous avez également étudié le chapitre sur les structures de contrôle qui évoque entre autes les boucles infinies ...
Tests & boucles

Variables superglobales

$_GET si envoi avec la méthode GET
$_POST si envoi avec la méthode POST
$_FILES si envoi d'un fichier

Les tableaux associatifs $_GET, $_POST, $_FILE sont dans le jargon PHP des variables superglobales.
Les variables superglobales sont des tableaux associatifs qui sont créés automatiquement par PHP dans certaines circonstances.
Il existe aussi $_COOKIE et $_SESSION.
Les variables superglobales sont accessibles partout et doivent être écrites en majuscules !

Le traitement en PHP des données et fichiers soumissionnées fait l'objet de tout un chapitre.
Traitement des données soumissionnées

Traduction

Débuter en programmation web - sommaire

Initiation au HTML & CSS

Initiation à PHP & MYSQL

Débuter en programmation web - recherche

L'auteur : Patrick Darcheville

Les variables, constantes et tableaux en PHP

Les variables simples

Règles de nommage d'une variable

Type d'une variable

La fonction gettype()

Le code de l'exemple

Le rendu

Les constantes en PHP

Exemple - le code

Le rendu

Les opérations en PHP

La concaténation

Exemple - le code

Le rendu

Les opérateurs arithmétiques

Les opérateurs combinés

Exemple

Le rendu

Les tableaux indicés

Exemple - le code

Le rendu

Autres manipulations de tableaux indicés

Le code de l'exemple

Le rendu

Les tableaux associatifs

Le script PHP

Le rendu

Manipulation de tableaux associatifs

Le script

Le rendu

Tableaux multidimensionnels

Exemple

Le rendu

Autres traitements sur tableaux

La fonction array_unique()

Comparons différents langages

Exemple - le code

Le rendu

La fonction range()

Le code

Le rendu

Le code

Le rendu dans un autre onglet

Pour aller plus loin : simuler le poker

Le rendu dans un autre onglet

Exemple de rendu

Le code

Variables superglobales