Apprendre PHP & MySQL : Algorithmie

Données

Il serait difficile de réaliser un algorithme sans pouvoir en stocker des données. Découvrons comment déclarer des variables, constantes et tableaux en PHP.

Variables

Une variable est une case mémoire dans laquelle il est possible de stocker une information, une donnée. Cette case mémoire sera identifiée par un nom.

Déclarer des variables en PHP se fait en préfixant le nom que l’on souhaite donner à notre variable du symbole $. La valeur stockée peut être de nombreux types, dont les 3 principaux sont :

• Nombre : entier, décimal…
• Chaîne de caractères : caractère unique, chaîne courte, chaîne longue… - s’écrit entre guillemets simples ' ' ou doubles " ".
• Booléen : vrai (true) ou faux (false)
• …

$firstname = "toto";
$weight = 58.5;
$hungry = true;

En PHP, on termine nos instructions par un ;.

Quand on affecte une valeur à une variable on dit qu’on l’initialise. Il est également possible de déclarer une variable sans l’initialiser tout de suite.

$myVariable; // Ici la variable est "undefined"

Constantes

Une constante est similaire à une variable, à la seule différence que sa valeur ne pourra pas changer. Il s’agit d’une donnée en lecture seule. On déclare une constante avec le mot-clé const ou avec la fonction define() (en dehors d’une classe).

define("MAX_SPEED", 90);
const MAX_SPEED = 90;

Tableaux

Les tableaux sont en quelque sorte des supers variables pour stocker plusieurs informations, de manière structurée.

On les déclare de la même manière que des variables classiques avec le symbole $.

Concernant leurs valeurs, on les écrit entre crochets [] ou en faisant appel à la fonction array(). On sépare les valeurs avec des virgules.

$fruits = ["Pomme", "Poire", "Banane"];
$fruits = array("Pomme", "Poire", "Banane"); // Equivalent

Pour accéder aux données stockées dans un tableau, on les extrait par leur indice. Chaque valeur stockée dans un tableau est associée à un indice, commençant à 0. Pour récupérer une valeur, on fait : $nomTableau[indiceValeur] :

$fruits = ["Pomme", "Poire", "Banane"];
echo $fruits[0]; // Affiche "Pomme"
echo $fruits[1]; // Affiche "Poire"
var_dump($fruits[2]); // Affiche "Banane" (en mode débogage)
echo $fruits[3]; // Erreur : "undefined", car on sort du tableau

Il est également possible de stocker un tableau dans un tableau ! À la différence des tableaux unidimensionnels précédents, on appellera un tableau de ce type : tableau multidimensionnel ou tableau imbriqué.

Pour une meilleure lisibilité, on indentera généralement les sous-tableaux :

// Déclaration
$users = [
	["Pierre", "Moulin", 34],
	["Paul", "Dupont", 27],
	["Jacques", "Durand", 31]
];

// Pour y accéder, on spécifiera un indice pour chaque dimension
echo $users[1]; // Affiche ["Paul", "Dupont", 27]
echo $users[1][2]; // Affiche 27

Si l’on se penche sur le tableau multidimensionnel précédent, on constate qu’il manque de structure, de clarté. Pourquoi cela ? Car les données sont indexées sur des indices (0, 1, 2…). Pour pallier à ce manque d’organisation, PHP nous propose une variante extrêmement pratique : les tableaux associatifs.

Les tableaux associatifs, fonctionnent exactement comme les tableaux classiques (unidimensionnels ou multidimensionnels), à la seule différence que les valeurs seront indexées à des clés. On parle de couples clés-valeurs.

Le symbole => permettra d’associer à une clé sa valeur. Le tableau précédent deviendrait ainsi :

$users = [
	[
		"firstname" => "Pierre",
		"lastname" => "Moulin",
		"age" => 34
	],
	[
		"firstname" => "Paul",
		"lastname" => "Dupont",
		"age" => 27
	],
	[
		"firstname" => "Jacques",
		"lastname" => "Durand",
		"age" => 31
	]
];

// Pour y accéder, on spécifiera un indice pour la première dimension et une clé pour la seconde
echo $users[0]["firstname"]; // Affiche "Pierre"

Voilà qui est plus clair !

Traitement

Stocker des données, c’est bien… les manipuler, c’est mieux. Pour cela place aux opérations, conditions, boucles et fonctions !

Opérations élémentaires

Opérations arithmétiques

En PHP, il est possible d’additionner, soustraire, multiplier, diviser des variables entre elles en utilisant les opérateurs arithmétiques élémentaires +, -, * et /. Il est même possible de calculer le modulo (reste de la division) de deux nombres avec l’opérateur %.

$a = 4;
$b = 7;

// Somme de 2 variables
$addition = $a + $b;
// Soustraction de 2 variables
$soustraction = $b - $a;
// Multiplication de 2 variables
$multiplication = $a * $b;
// Division de 2 variables
$division = $b / $a;
// Modulo de 2 variables
$modulo = $b % $a;

// Note : pour les opérations plus complexes (racine carrée, exponentielle, factorielle...), on fera appel à des fonctions.

Concaténation

Si vous souhaitez afficher des variables à côté de chaînes de caractères ou à côté d’autres variables (concaténation), on utilise l’opérateur ..

$firstname = "Toto";
echo "Hello " . $firstname;

Conditions

Les conditions sont des structures algorithmiques extrêmement fréquentes et utiles qui se traduisent par « fais ceci, si cela ». Notre cerveau analyse constamment des situations conduisant à la prise de décision.

if, elseif, else

On déclare une condition avec le mot-clé if (littéralement « si »). Une condition s’écrit de la forme if (condition) { ... traitement ... }

• Si la condition est vraie : renvoie true.
• Si la condition est fausse : renvoie false.

Mais alors comment écrire ces conditions ? Avec des opérateurs de comparaison.

Opérateurs de comparaison

Il existe 8 grands opérateurs de comparaison.

Opérateurs logiques

Au nombre de 3, les opérateurs logiques permettent de tester la véracité d’un ensemble de conditions (AND ou OR) mais aussi d’en inverser la logique (NOT).

$dice = 1;
if ($dice == 1) { // Ici, la condition renvoie "true"
	// Il vaut mieux relancer le dé...
}

Il est également possible de combiner if et else dans une seule instruction pour ajouter des conditions intermédiaires.

$dice = 5;
if ($dice == 1) {
	// Il vaut mieux relancer le dé...
} elseif ($dice > 1 AND $dice <= 3) {
	// C'est mieux...
} elseif ($dice > 3 AND $dice <= 5) {
	// Pas mal !
}

Enfin, si aucune condition précédente n’est vérifiée, le mot-clé else seul permet de déclencher un scénario alternatif.

$dice = 5;
if ($dice == 1) {
	// Il vaut mieux relancer le dé...
} elseif ($dice > 1 AND $dice <= 3) {
	// C'est mieux...
} elseif ($dice > 3 AND $dice <= 5) {
	// Pas mal !
} else {
	// Super !
}

$note = 13;
if ($note >= 0 AND $note <= 20) {
	if ($note >= 0 AND $note < 8) {
		echo "Refusé";
	} elseif ($note >= 8 AND $note < 10) {
		echo "Rattrapage !";
	} elseif ($note >= 10 AND $note < 12) {
		echo "Admis";
	} elseif ($note >= 12 AND $note < 14) {
		echo "Admis avec mention AB";
	} elseif ($note >= 14 AND $note < 16) {
		echo "Admis avec mention B";
	} else {
		echo "Admis avec mention TB";
	}
} else {
	echo "Note non valide";
}

switch

Dans l’écriture de raisonnements logiques similaires, le switch propose une syntaxe alternative plus concise et plus lisible pour vérifier des égalités.

$fruit = "Banane";
switch ($fruit) {
	case 'Banane':
		echo $fruit . " (1.93 € / kg)";
		break;
	case 'Pomme':
		echo $fruit . " (2.62 € / kg)";
		break;
	case 'Mangue':
	case 'Papaye':
		echo $fruit . " (6.17 € / kg)";
		break;
	default:
		echo "Désolé, nous ne vendons pas de " . $fruit;
}

• switch (<valeur>) : valeur à comparer dans les clauses case.
• case exp : expression à comparer avec la valeur de base.
  1. Si correspondance, exécution d’une instruction
  2. Si non-correspondance, passage au case suivant
• break : spécifie la fin d’une instruction (bloc case - break)
• default : clause exécutée par défaut si aucune correspondance n’est trouvée avec les clauses case précédentes.

Boucles

Le principe des boucles est de répéter des instructions plusieurs fois.

for

La boucle for (« pour ») est une boucle à nombre d’itérations fini. La variante foreach en est une déclinaison fréquente et utile.

La boucle for consiste à itérer en spécifiant 3 paramètres :

• Le point de départ
• Le point d’arrivée
• Le pas (« on va de x en x »)

// Une boucle qui exécute 10 itérations en affichant à chaque tour 0, 1, 2, 3... 9
for ($i=0; $i<10; $i=$i+1) {
	echo $i;
}

Au départ $i vaut 0, à chaque tour de boucle il s’incrémente de 1, et continue cela jusqu’à atteindre 9. Si nous avions écrit en point d’arrivée $i<=10, la boucle serait allée jusqu’à atteindre 10 et nous aurions donc effectué 11 tours de boucle.

Il est bien évidemment possible d’imbriquer des boucles les unes dans les autres !

foreach

La boucle foreach (« pour chaque ») permet d’itérer sur les éléments d’un tableau.

C’est la boucle utilisée lorsque vous voyez :

• Des articles listés sur un blog
• Des produits listés sur un site e-commerce
• Des utilisateurs listés sur un réseau social
• Des publications listées sur un feed de réseau social Bref, vous avez compris le principe. 😉

$languages = ["HTML", "CSS", "JavaScript", "PHP"];
foreach ($languages as $language) {
	echo $language; // Affiche "HTML", puis "CSS", etc.
}

Ici, $language prend successivement les valeurs du tableau $languages.

<?php
	$articles = array(
		array(
			"title" => "Apprendre le HTML",
			"content" => "<p>Bienvenue sur cette formation où... blablabla</p>",
			"author" => "Thibaud"
		),
		array(
			"title" => "Apprendre le CSS",
			"content" => "<p>Bienvenue sur cette formation où... blablabla</p>",
			"author" => "Thibaud"
		)
	);
?>

<?php foreach ($articles as $article) { ?>
	<h2 class="title"><?= $article["title"]; ?></h2>
	<div class="content"><?= $article["content"]; ?></div>
	<span class="author">Par <?= $article["author"]; ?></span>
<?php } ?>

while

La boucle while (« tant que ») est une boucle à nombre d’itérations non-défini.

La boucle while est une sorte de mélange entre structure conditionnelle et structure itérative dans la mesure où on continue d’itérer tant qu’une condition est vérifiée.

$number = 0;
while ($number != 7) {
	$number = // aléa entre 1 et 10...
}

Fonctions

Les fonctions permettent de regrouper un ensemble d’instructions visant à résoudre une problématique au sein d’un même module. Il est possible de faire appel à un bloc de code de ce type afin qu’il effectue quelque chose et/ou nous retourne un résultat.

Fonctions natives

Comme tout langage de programmation, PHP ne déroge pas à la règle et vient avec son lot de fonctions natives. Il suffira alors de les appeler par leur nom.

$sitename = "laConsole";
$nbChars = strlen($sitename); // Retourne 9
if (!empty($sitename) {
	// Ici on rentre dans la condition
})

• strlen() permet de retourner la taille d’une chaîne de caractères.
• empty() permet de savoir si une variable est vide. Retourne true si la variable est vide, false sinon.

Fonctions custom

En PHP, il est possible de créer ses propres fonctions ; nous parlerons de fonctions « custom ».

Déclaration de fonction

Pour déclarer une fonction custom nous définissons :

1. Son nom
2. Des instructions
3. (optionnels) Ses paramètres
4. (optionnelle) Une valeur de retour (information retournée par la dite fonction)

function functionName() {
	// Instructions...
}

function functionName($param1, $param2) {
	// Instructions...
	return ...
}

Appel de fonction

On fait appel à une fonction en spécifiant simplement son nom, suivi de parenthèses ().

functionName();

Si une fonction est définie avec des paramètres, il faudra alors lui transmettre des arguments.

functionName($arg1, $arg2);

Quelques exemples

Ces 4 exemples illustrent les différents cas d’usage avec ou sans paramètres et valeurs de retour.

// ❌ pas de "return" / ❌ pas de paramètres
function sayHello1(): void {
	echo "Hello !";
}

// ✅ "return" / ❌ pas de paramètres
function sayHello2(): string {
	return "Hello !";
}

// ❌ pas de "return" / ✅ paramètres
function sayHello3(string $firstname): void {
	echo "Hello " . $firstname . " !";
}

// ✅ "return" / ✅ paramètres
function sayHello4(string $firstname): string {
	return "Hello " . $firstname . " !";
}

// Appels de fonction
sayHello1();
echo sayHello2();
sayHello3("Toto");
echo sayHello4("Toto");

$firstname = "Toto"; // Aucun typage

function myFunction(int $param1, string $param2) {
	// Le paramètre $param1 doit être de type int
	// Le paramètre $param2 doit être de type string
}

function sum(int $a, int $b): int {
	return $a + $b; // La fonction renvoie un résultat de type int
}

Cet exemple illustre quant à lui davantage l’intérêt d’une fonction dans un programme.

function isEven(int $number): bool {
	return $number % 2 === 0;
}

echo isEven(7); // false
echo isEven(8); // true