Page |1
Chapitre 3 : Langage de PHP
Introduction
PHP (Hypertext Preprocessor) est un langage de programmation côté serveur
largement utilisé pour le développement web. Il permet de créer des pages web
dynamiques et interactives en s'intégrant facilement avec des bases de données
comme MySQL. PHP est un langage open-source, simple à apprendre et très
puissant pour la gestion des applications web.
Dans ce chapitre, nous allons explorer les concepts fondamentaux de PHP,
notamment les identificateurs, les types de données, la déclaration de variables et
constantes, les opérateurs, les structures de contrôle, les tableaux, les
entrées/sorties, ainsi que des notions avancées comme le CRUD, les injections
SQL et l'utilisation de PDO.
Les Identificateurs en PHP
Un identificateur en PHP est le nom donné aux variables, fonctions, classes et
autres éléments du langage. Il doit respecter certaines règles :
Il doit commencer par une lettre (a-z, A-Z) ou un underscore (_).
Il peut contenir des lettres, des chiffres (0-9) et des underscores.
Il est sensible à la casse (exemple : $Nom et $nom sont différents).
Exemple de déclaration d'une variable avec un identificateur valide :
$nomUtilisateur = "Jean";
Les Types de Données en PHP
PHP est un langage faiblement typé, ce qui signifie que le type des variables est
automatiquement déterminé. Les principaux types de données en PHP sont :
Entier (integer) : nombres sans décimales ($age = 25;).
Flottant (float) : nombres avec décimales ($prix = 10.99;).
Chaîne de caractères (string) : texte ($nom = "Alice";).
Booléen (boolean) : vrai (true) ou faux (false).
Tableau (array) : collection de valeurs ($jours = array("Lundi", "Mardi",
"Mercredi");).
Objet (object) : instance d'une classe.
NULL : représente une variable sans valeur ($valeur = NULL;).
Déclaration de Variables et de Constantes
Variables
Page |2
Les variables en PHP commencent par le symbole $. Elles peuvent stocker
différents types de données et leur valeur peut changer au cours de l'exécution du
programme.
Exemple :
$nom = "Pierre";
$age = 30;
$prix = 15.5;
Constantes
Les constantes sont des valeurs qui ne changent jamais après leur définition. Elles
sont définies à l’aide de la fonction define() ou du mot-clé const.
Exemple :
define("PI", 3.14159);
const VITESSE_LUMIERE = 299792458;
Les Opérateurs en PHP
Les opérateurs sont utilisés pour effectuer des opérations sur des valeurs et des
variables. PHP propose plusieurs catégories d’opérateurs :
Opérateurs arithmétiques : +, -, *, /, % (modulo).
Opérateurs de comparaison : ==, !=, >, <, >=, <=.
Opérateurs logiques : && (ET), || (OU), ! (NON).
Opérateurs d'affectation : =, +=, -=, *=, /=, %=.
Opérateurs d'incrémentation/décrémentation : ++, --.
Les Structures de Contrôle
Instructions Conditionnelles
if...else :
$age = 18;
if ($age >= 18) {
echo "Vous êtes majeur.";
} else {
echo "Vous êtes mineur.";
}
switch :
$jour = "Mardi";
switch ($jour) {
Page |3
case "Lundi":
echo "Début de semaine";
break;
case "Mardi":
echo "Deuxième jour de la semaine";
break;
default:
echo "Autre jour";
}
Boucles
while :
$i = 0;
while ($i < 5) {
echo $i;
$i++;
}
for:
for ($i = 0; $i < 5; $i++) {
echo $i;
}
foreach:
$jours = ["Lundi", "Mardi", "Mercredi"];
foreach ($jours as $jour) {
echo $jour;
}
Les Fonctions en PHP
Les fonctions permettent d'organiser le code en unités réutilisables. Une fonction
peut prendre des paramètres et retourner une valeur.
Exemple :
function saluer($nom) {
return "Bonjour, " . $nom . " !";
}
echo saluer("Alice");
Page |4
Fonctions anonymes (Closures)
$multiplier = function($a, $b) {
return $a * $b;
};
echo $multiplier(5, 3);
Le CRUD en PHP
Le CRUD (Create, Read, Update, Delete) est un ensemble d'opérations
fondamentales pour gérer les données en base de données.
Exemple avec MySQL et PDO :
$pdo = new PDO("mysql:host=localhost;dbname=ma_base", "root", "");
// Création (INSERT)
$stmt = $pdo->prepare("INSERT INTO utilisateurs (nom, email) VALUES (?,
?)");
$stmt->execute(["Alice", "alice@[Link]"]);
// Lecture (SELECT)
$stmt = $pdo->query("SELECT * FROM utilisateurs");
while ($row = $stmt->fetch()) {
echo $row["nom"] . " - " . $row["email"] . "<br>";
}
// Mise à jour (UPDATE)
$stmt = $pdo->prepare("UPDATE utilisateurs SET email = ? WHERE nom = ?");
$stmt->execute(["nouveau@[Link]", "Alice"]);
// Suppression (DELETE)
$stmt = $pdo->prepare("DELETE FROM utilisateurs WHERE nom = ?");
$stmt->execute(["Alice"]);
Sécurité et Injection SQL
L'injection SQL est une attaque qui consiste à insérer du code SQL malveillant
dans une requête. Pour éviter cela, il faut utiliser les requêtes préparées avec PDO
:
$stmt = $pdo->prepare("SELECT * FROM utilisateurs WHERE email = ?");
$stmt->execute([$_POST['email']]);
Cette approche empêche les attaques en traitant les entrées comme des valeurs et
non comme du code SQL.
Page |5
Gestion des Erreurs en PHP
PHP propose plusieurs façons de gérer les erreurs :
Utilisation
de try...catch pour intercepter les exceptions.
Affichage d'erreurs avec error_reporting().
Exemple de gestion d'erreur :
try {
$pdo = new PDO("mysql:host=localhost;dbname=ma_base", "root", "");
} catch (PDOException $e) {
echo "Erreur de connexion : " . $e->getMessage();
}
Programmation Orientée Objet (POO) en PHP
Introduction
La programmation orientée objet (POO) est un paradigme de programmation qui
repose sur la notion d’objets, lesquels encapsulent des données et des
comportements. PHP supporte pleinement la POO depuis sa version 5, offrant
ainsi aux développeurs une meilleure structuration du code, une réutilisabilité
accrue et une maintenance facilitée.
Dans ce chapitre, nous allons explorer les concepts fondamentaux de la POO en
PHP, y compris les classes et objets, l’encapsulation, l’héritage, le
polymorphisme, les interfaces, les traits, ainsi que la gestion des exceptions.
1. Les Bases de la POO en PHP
a) Définition des Classes et des Objets
En POO, une classe est un modèle définissant un ensemble de propriétés et de
méthodes. Un objet est une instance de cette classe.
Exemple de classe et d’objet en PHP :
class Utilisateur {
public $nom;
public $email;
public function __construct($nom, $email) {
$this->nom = $nom;
Page |6
$this->email = $email;
}
public function afficherInformations() {
return "Nom: $this->nom, Email: $this->email";
}
}
$utilisateur = new Utilisateur("Alice", "alice@[Link]");
echo $utilisateur->afficherInformations();
b) Les Propriétés et les Méthodes
- Propriétés : Variables définies dans une classe.
- Méthodes : Fonctions définies dans une classe qui permettent d’agir sur les
objets.
c) Constructeurs et Destructeurs
- Le constructeur __construct() est une méthode spéciale exécutée
automatiquement lors de la création d’un objet.
- Le destructeur __destruct() est exécuté lorsque l’objet est détruit.
Exemple :
class Produit {
public $nom;
public function __construct($nom) {
$this->nom = $nom;
}
public function __destruct() {
echo "L’objet {$this->nom} est détruit.";
}
}
$produit = new Produit("Ordinateur");
2. Les Principes Fondamentaux de la POO
a) L’Encapsulation
Page |7
L’encapsulation consiste à restreindre l’accès aux données d’un objet en
définissant leur visibilité à l’aide des modificateurs d’accès :
- public : accessible de partout.
- private : accessible uniquement dans la classe.
- protected : accessible dans la classe et les classes héritées.
Exemple :
class CompteBancaire {
private $solde;
public function __construct($solde) {
$this->solde = $solde;
}
public function deposer($montant) {
$this->solde += $montant;
}
public function afficherSolde() {
return $this->solde;
}
}
b) L’Héritage
L’héritage permet à une classe de réutiliser les attributs et méthodes d’une autre
classe.
Exemple :
class Animal {
public function crier() {
echo "Je fais un bruit!";
}
}
class Chien extends Animal {
public function crier() {
echo "Ouaf Ouaf!";
}
}
Page |8
$chien = new Chien();
$chien->crier(); // Affiche "Ouaf Ouaf!"
c) Le Polymorphisme
Le polymorphisme permet à une classe enfant de redéfinir une méthode de la
classe parent.
Exemple :
class Vehicule {
public function demarrer() {
echo "Le véhicule démarre";
}
}
class Moto extends Vehicule {
public function demarrer() {
echo "La moto démarre";
}
}
$moto = new Moto();
$moto->demarrer();
3. Concepts Avancés de la POO en PHP
a) Les Interfaces
Une interface définit un ensemble de méthodes qu’une classe doit implémenter.
Exemple :
interface Volant {
public function voler();
}
class Avion implements Volant {
public function voler() {
echo "L’avion vole";
}
}
Page |9
b) Les Traits
Les traits permettent de partager des méthodes entre plusieurs classes.
Exemple :
trait Logger {
public function log($message) {
echo "LOG : $message";
}
}
class Application {
use Logger;
}
$app = new Application();
$app->log("Démarrage de l’application");
c) La Gestion des Exceptions
Les exceptions permettent de gérer les erreurs de manière contrôlée.
Exemple :
class Division {
public function diviser($a, $b) {
if ($b == 0) {
throw new Exception("Division par zéro impossible");
}
return $a / $b;
}
}
try {
$calc = new Division();
echo $calc->diviser(10, 0);
} catch (Exception $e) {
echo "Erreur : " . $e->getMessage();
}
P a g e | 10
Conclusion
PHP est un langage puissant et flexible permettant de développer des applications
web dynamiques. En maîtrisant les concepts abordés dans ce chapitre, vous serez
en mesure d'écrire des scripts PHP efficaces et sécurisés.
La programmation orientée objet en PHP offre de nombreux avantages en termes
de structuration et de réutilisation du code. Ce chapitre a couvert les bases ainsi
que les concepts avancés de la POO. L’apprentissage des frameworks comme
Laravel, qui repose sur la POO, permet d’améliorer encore plus l’efficacité du
développement en PHP.
