Chapitre5 PHP

Développement Web
Chapitre 5 : PHP
Qu’est ce que PHP ?
♦ PHP est un langage de script qui s’exécute côté serveur.
♦ Il permet de réaliser des pages web dynamiques dont le contenu peut être
complètement ou partiellement généré au moment de l’appel de la page, grâce à
des informations récupérées dans un formulaire ou extraites d’une base de
données.
♦ Quelques caractéristiques de PHP :
- Très populaire et très utilisé
- Syntaxe héritée du C/C++
- Extensible par de nombreuses bibliothèques
- calcul mathématique
- accès à la plupart des SGBD
-…
- Un fichier PHP (.php) peut contenir du code HTML, JavaScript et PHP
- PHP est gratuit et performant tout comme MySQL, c'est pourquoi le duo
PHP/MySql est particulièrement aisé à mettre en place.
10/01/2023 Prof. Hafida ZROURI 2

Rappel de la syntaxe
♦ Intégration d’un code PHP dans une page web : <?php … ?>
♦ Extension du fichier : .php
♦ Inclusion de fichier externe : include("nomFichier"), require("nomFichier"),
include_once("nomFichier"), require_once("nomFichier")
♦ Les variables : pas de déclaration explicite, l'affectation d'une valeur suffit et leur
nom commence par un $
♦ Les types : entier (int, integer), décimal (float, double), chaîne de caractères
(string), tableau (array), objet (object), booléen (bool, boolean)
♦ Les tableaux : création à l’aide de la fonction array().
Tableau indexé : $tab = array(val1, val2, …);
Tableau associatif : $tab = array("cle0"=>val1, "cle1"=>val2, …);
♦ Affichage d’une chaîne de caractères : print(chaîne) | echo chaîne1[, chaîne2,…]
♦ Concaténation de chaînes de caractères : .
♦ Affichage de la date et|ou l’heure : date("format")
Ex. : print(date("d-m-Y H:i:s")); // affichage formaté : 09-01-2023 20:14:51

♦ Exemple :
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>PHP</title>
<style> p {font-size: 2em} </style>
</head>
<body>
<?php
echo '<p>Bonjour, <br />Il est '.date('H:i').' !</p>';
?>
</body>
</html>
♦ Les fonctions :
1- Déclarer une fonction :
function nomFonction [:typeDeRetour] ([[type] $param1, [type] $param2, …]) {
/* instructions */
}
2- Fonction anonyme assignée à une variable :
$variable = function [:typeDeRetour] ([[type] $param1, [type] $param2, …]) {
/* instructions */
};
3- Fonction fléchée :
$variable = fn ([[type] $param1, [type] $param2, …]) [:typeDeRetour] => expression;
La fonction fléchée ne peut avoir qu'une seule expression, laquelle est le retour de fonction (le
mot clé return n'est pas permis).
Exemple :
function ajouter(float $x, float $y):float { return $x + $y; }
$predire = function(int $age = 10){ echo "Votre age est : $age"; };
$carre = fn($x) => $x* $x;
echo ajouter(1.5,13)." ------- ".$carre(6)."<br>";
$predire();
♦ Les fichiers :
PHP prend en charge l’accès au système de fichiers du système d’exploitation du
serveur. Voici quelques fonctions dédiées à l'utilisation des fichiers :
- $fp = fopen("nom_du_fichier", "r|w|a|r+|w+|…") : permet d'ouvrir un fichier.
Elle retourne un identificateur de fichier ou FALSE si échec.
- fgetc($fp) : lit un caractère. Elle retourne FALSE à la fin du fichier.
- fgets($fp) : lit la ligne courante. Elle retourne FALSE à la fin du fichier.
- fputs($fp, $str) | fwrite($fp, $str) : écrit la chaîne $str dans le fichier identifié par
$fp.
- fclose($fp) : ferme le fichier identifié par $fp.
- feof($fp) : teste la fin du fichier, retourne TRUE ou FALSE.
- is_file("nom_du_fichier") : permet de savoir si nom_du_fichier correspond à un
fichier existant.
- file("nom_du_fichier") : retourne le fichier nom_du_fichier dans un tableau.
Chaque élément du tableau correspond à une ligne du fichier.
- unlink("nom_du_fichier") : détruit le fichier nom_du_fichier.

♦ Les répertoires :
Il est possible en PHP de manipuler un répertoire de la même manière qu’un fichier.
Voici quelques fonctions dédiées à l'utilisation des répertoires :
- $od = opendir("nom_du_répertoire") : permet d'ouvrir un répertoire. Elle retourne un
pointeur sur le dossier ou FALSE si échec.
- readdir($od) : retourne l’entrée suivante dans le dossier identifié par $od (le nom du
fichier ou sous répertoire). Elle retourne FALSE à la fin du répertoire. (Les entrées sont
retournées dans l'ordre dans lequel elles sont enregistrées dans le système de fichiers)
- closedir($od) : ferme le dossier identifié par $od.
- is_dir("nom_du_répertoire") : permet de savoir si nom_du_répertoire correspond à un
répertoire existant.
- mkdir("nom_du_répertoire") : crée un nouveau répertoire. Elle retourne FALSE si
échec.
- rmdir("nom_du_répertoire") : supprime le répertoire. Ce dernier doit être vide. Elle
retourne FALSE si échec.
Exemple : if($od = opendir('.')) {
while($entree = readdir($od)) { echo "$entree<br />"; }
closedir($od); }

♦ Les formulaires :
Les paramètres d'un formulaire envoyés depuis le navigateur vers le serveur sont
accessibles directement par leur nom (attribut name) dans le script qui les reçoit.
Ils sont récupérés dans un tableau associatif :
- $_POST["…"] si la méthode d’envoi est POST
- $_GET["…"] si la méthode d’envoi est GET
- $_ REQUEST["…"] dans les deux cas (GET ou POST)
♦ Les cookies :
Un cookie est un fichier texte créé par un script et stocké, par le navigateur, sur le
disque dur du poste client. Il contient des informations spécifiques à l’utilisateur.
- Déposer un cookie sur le poste client :
setcookie('nom_du_cookie', 'contenu_du_cookie', date_d_expiration);
avec date_d_expiration est le temps en secondes depuis 1/1/1970 :
date_d_expiration = time()+nbsecondes
- Accéder au cookie : $_COOKIE['nom_du_cookie']
- Supprimer un cookie : setcookie('nom_du_cookie');

♦ Les sessions :
Les sessions sont un moyen de stocker sur le serveur des informations relatives au
visiteur. Il s’agit d’une alternative aux cookies.
La différence entre les sessions et les cookies est que les cookies sont stockés sur
le poste du visiteur tandis que les sessions sont dans des fichiers présents sur le
serveur. Il s’agit d’un stockage temporaire mais, les fichiers de sessions ne
peuvent pas être vus et modifiés par le visiteur, contrairement aux cookies.
- Démarrage ou récupération d’une session : session_start();
- Création d’une variable de session : $_SESSION['variable'] = …;
- Suppression d’une variable de session : unset($_SESSION['variable']);
- Fermeture de la session : session_destroy();
Avant de fermer la session, il faut :
- vider le contenu de la session : $_SESSION = array();
- détruire le cookie de session : setcookie(session_name());

Classes et objets
♦ Classe :
▪ Une classe est un type de données défini par le programmeur. C’est une sorte de
moule à partir duquel sont engendrés les objets réels qui s’appellent des instances
de la classe considérée.
▪ Une classe PHP (créée à l’aide du mot clé « class » suivi du nom de la classe)
regroupe :
* des variables d’instance (appelées attributs ou propriétés), représentés par des
variables PHP. Syntaxe :
[public|protected|private] [static] [typeAttribut] nomAttribut;
* des méthodes manipulant ces variables, définies par des fonctions PHP.
class MaClasse {
// Définition des propriétés et des méthodes
}
▪ Le nom de la classe peut être quelconque à condition que ce ne soit pas un mot
réservé en PHP. Il doit commencer par une lettre ou un underscore, suivi de
n'importe quel nombre de chiffres, ou de lettres, ou d'underscores.
Classes et objets
♦ Objet :
▪ Une classe permet de créer des objets (ou instances de classe) au moyen d'un
constructeur appelé à l’aide de l’opérateur new suivi du nom de la classe :
$objet = new MaClasse();
▪ Pour détruire cet objet en mémoire :
unset($objet);
▪ En PHP, soit on met la classe dans le même fichier que l'instance, soit on la
met dans un autre fichier et on fait un include ou un require pour inclure le
fichier contenant la classe. (à la différence de Java où les classes peuvent être
instanciées dans d'autres fichiers du même package).

Classes et objets
♦ Accès aux méthodes | propriétés de la classe :
▪ On accède aux membres par l'intermédiaire de l'opérateur flèche (->). Au
sein d'une classe, le mot clé $this permet d'accéder au membres d'instance
en cours ($this représente en fait l'objet).
▪ À l’intérieur de la classe :
$this->maMethode();
$this->monAttribut;
▪ De l’extérieur :
$monObjet = new MaClasse();
$monObjet->maMethode();
$monObjet->monAttribut;

Classes et objets
Exemple :
<?php
class User {
public $name;
function getName() {
return ucfirst($this->name); // ucfirst rend la première lettre en majuscule
}
}
$mohamed = new User(); // Création d'un objet à partir de la classe

$mohamed->name = 'mohamed'; // Modification d'une propriété
echo $mohamed->getName(); // Accès à une méthode
?>

Classes et objets
♦ Visibilité :
La visibilité d’un membre (propriété ou méthode) est définie en préfixant
la déclaration avec un mot-clé : public, protected, ou private.
▪ Privé (private) : le membre n’est accessible que dans la classe courante.
▪ Protégé (protected) : le membre est accessible dans la classe courante
et dans les classes dérivées.
▪ Publique (public) : le membre est accessible partout, même à
l’extérieur de la classe.
Remarque :
En absence de déclaration de visibilité, l'attribut ou la méthode est
considéré comme public (compatibilité avec PHP 4).

Classes et objets
♦ Constructeur :
▪ En PHP5 (et >5), le constructeur a pour syntaxe :
function __construct($arg1, $arg2, …) { … }
▪ Le constructeur est appelée automatiquement lors de la création d'un objet à
l'aide du mot clef new :
$objet = new NomDeLaClasse(param1, param2, …)
▪ La surcharge n’existe pas en PHP : pas de constructeurs multiples à paramètres
différents.
♦ Destructeur :
▪ Syntaxe [en PHP5 (et >5)] :
function __destruct() { [… ] }
▪ Elle est appelée automatiquement soit lors de la destruction explicite d'un objet
à l'aide de la fonction unset(), soit après la fin du script.

Classes et objets
Exemple :
<?php
class Employe {
private string $nom;
private float $salaire;
public function __construct($n, $s) {
$this->nom = $n;
$this->salaire = $s;
}
public function toHTML() {
return "<strong> Le nom : </strong><em> $this->nom </em><br>".
"<strong> Le salaire : </strong><em> $this->salaire </em>";
}
}
$emp1 = new Employe("Namir", 6000);
echo $emp1->toHTML();
?>

Classes et objets
♦ Membres statiques :
▪ Certains membres peuvent être statiques
▪ Ils deviennent accessibles sans instance
▪ Ils sont communs à toutes les instances
▪ Déclarés à l’aide du mot clé static et accessibles via l’opérateur ::
Exemple de déclaration : public static $staticVar = '300';
Pour y accéder :
self::$staticVar; // Dans la classe
NomDeLaClasse::$staticVar; // A l’extérieur de la classe
parent::$staticVar; // Dans la classe fille
▪ Une méthode statique ne peut pas interagir avec les attributs et les méthodes de
l’instance (sauf les attributs et méthodes statiques). Il n'y a pas de variable $this dans
la méthode statique car elle est faite pour agir sur la classe et non sur un objet. On
utilisera donc le mot-clé self.
▪ Un attribut statique est un attribut indépendant de tout objet : si l'un des objets modifie
sa valeur, tous les autres objets qui accèderont à cet attribut obtiendront la nouvelle
valeur.
Classes et objets
Exemple :
<?php
class Compteur {
private static int $compt = 0;
//…
public function __construct() {
//...
self::$compt++;
}
public static function getCompteur() {
return self::$compt;
}
//…
}
$obj1 = new Compteur(); echo Compteur::getCompteur()."<br />"; // affiche 1
$obj2 = new Compteur(); echo Compteur::getCompteur(); // affiche 2
?>
Classes et objets
♦ Les constantes de classe :
▪ PHP permet de définir des constantes dans une classe en utilisant le mot clé const. Le
nom de la constante ne commence pas par un $.
▪ Les constantes s’utilisent de manière statique et peuvent être définies comme publique,
privée ou protégée. Les constantes déclarées sans mot clé de visibilité explicite sont
définies en tant que public.
Exemple :
class Personne {
const NBRE_YEUX = 2;
const NBRE_MAINS = 2;
…
public function __construct() { … }
public function affiche() {
echo self:: NBRE_YEUX. ",… ". self:: NBRE_MAINS;
}
…
}
Classes et objets
♦ Clonage d’objet :
▪ Permet d'effectuer une copie exacte d'un objet mais en lui affectant une zone de
mémoire différente de celle de l'objet original.
▪ Contrairement à la copie avec "=" ou à la référence avec "&", les modifications
sur l'objet cloné ne sont pas répercutées sur l'original.
Remarque : Avec PHP5 (et >5) les objets sont passés (par défaut) par référence
aux fonctions.
▪ Syntaxe :
$objetclone = clone $objet;
▪ Exemple :
class Voiture { public $marque = "ford"; }
$MaVoiture1 = new Voiture();
$MaVoiture2 = clone $MaVoiture1;
$MaVoiture2->marque = 'ferrari';
echo $MaVoiture1->marque; // affiche "ford"

Classes et objets
♦ Comparaison d’objets :
▪ Opérateur de comparaison "=="

deux objets sont égaux s'ils ont les mêmes attributs et valeurs, et qu'ils
sont des instances de la même classe.
▪ Opérateur d'identité "==="

les objets sont identiques uniquement s'ils font référence à la même
instance de la même classe.

Classes et objets
Exemple :
$p1 = new Personne();
$p2 = new Personne();
$p3 = $p1;
$a = new Animal();
Deux instances de la même classe :
$p1 == $p2 ---> TRUE
$p1 === $p2 ---> FALSE
Deux références sur le même objet :
$p1 == $p3 ---> TRUE
$p1 === $p3 ---> TRUE
Instances de classes différentes :
$p1 == $a ---> FALSE
$p1 === $a ---> FALSE

Classes et objets
♦ Affichage d’un objet :
▪ Quand on essaie d’afficher un objet, PHP fait appel à la méthode __tostring() de
l’objet et s’il ne la trouve pas, il renvoie une erreur.
Exemple :
<?php
class Voiture {
function __tostring() {
return "Vous êtes dans la classe 'voiture' ";
}
}
$maVoiture = new Voiture();
echo $maVoiture; // affiche : Vous êtes dans la classe 'voiture'
?>

Classes et objets
♦ Héritage :
▪ L’héritage consiste à réutiliser une classe de base (plus générale) pour en faire une
version plus spécialisée (classe fille).
▪ Une classe peut être déclarée comme étant une sous-classe d’une autre classe en
spécifiant le mot clé extends :
class sous_classe extends super_classe {
// …
}
▪ La classe sous_classe hérite des attributs et des méthodes appartenant à la classe
super_classe et possède ses propres attributs et méthodes.
▪ Pas d'héritage multiple.
▪ Si un membre (méthode ou attribut) est redéfini dans la sous_classe, c’est sa dernière
définition qui est utilisée. Pour appeler un membre définie dans la super-classe à partir
d'une sous_classe, il suffit d’utiliser le suffixe parent::
▪ Le constructeur de la classe super_classe n’est pas appelé implicitement si la classe
sous_classe définit un constructeur. Par contre, si sous_classe ne définit pas un
constructeur alors il peut être hérité de la classe mère.

Classes et objets
Exemple :
<?php
class Personne {
protected $nom;
protected $adresse;
protected $tel;
public function __construct($n, $a, $t) {
$this->nom = $n;
$this->adresse = $a;
$this->tel = $t;
}
public function toHTML() { // … }
}
$toto = new Personne( "toto", "123 rue Elqods", "0514…");
echo $toto->toHTML(); // ici on a accès à toHTML mais pas à nom, adresse ou tel
?>

Classes et objets
Exemple (suite) :
<?php
class Employe extends Personne {
private $salaire;
private $poste;
public function __construct($n, $a, $t, $s, $p) {
parent::__construct($n, $a, $t);
$this->salaire = $s;
$this->poste = $p;
}
public function toHTML() {
return parent::toHTML( ) . $this->salaire . $this->poste;
}
}
$empl1 = new Employe("toto", "123…", "0514…", 6000, "prog");
echo $empl1->toHTML();
// ici on a accès à toHTML mais pas à nom, adresse, tel, salaire ou poste
?>
Classes et objets
♦ Classes abstraites :
▪ Une classe abstraite ne permet pas l'instanciation d'objets mais sert
uniquement de classe de base pour la création de classes dérivées.
▪ La déclaration d’une classe abstraite se fait avec le mot clé abstract :
abstract class nom_classe {
abstract function maMethode();
// Définition des attributs et de d’autres méthodes
}
▪ Une classe contenant une méthode abstraite doit être déclarée comme
abstraite.
▪ Une classe dérivée n’implémentant pas toutes les méthodes abstraites
doit aussi être déclarée comme abstraite.

Classes et objets
♦ Interfaces :
▪ L'interface définie une structure à laquelle la classe qui l'implémente doit se conformer.
▪ Ne contient aucune déclaration de propriétés.
▪ Ne contient aucune implémentation de méthode.
▪ Déclaration avec le modificateur public uniquement.
▪ Peut contenir des constantes.
▪ Structure d'une interface : interface nom_interface {
[public] function methode1([$var1, $var2,…]);
…
}
▪ Il est possible de définir une classe implémentant une ou plusieurs interfaces :
class nom_classe implements interface1, interface2, … {
// Implémentation de toutes les méthodes des interfaces
}
Remarque : si l’une des méthodes des interfaces n’est pas implémentée, la classe doit être
déclarée abstraite.
▪ Les interfaces peuvent être étendues comme des classes, en utilisant l'opérateur extends :
interface interface2 extends interface1 {…}
Classes et objets
♦ Méthodes et classes finales :
▪ Une classe finale (déclarée par le mot clé final) est une classe qui ne peut pas avoir de
classes filles.
Exemple :
final class A {… }
class B extends A {…} // Erreur
▪ Une méthode finale (déclarée par le mot clé final) est une méthode qui ne peut pas être
redéfinie dans les sous-classes.
Exemple :
class A {//…
final public function f($x) {…}
}
class B extends A { //…
public function f($x) {…} // Erreur
}

Exceptions
♦ Une exception peut être lancée ("throw") et attrapée ("catch") dans PHP.
Le code devra être entouré d'un bloc try. Chaque try doit avoir au moins
un bloc catch ou finally correspondant.
♦ L'objet lancé doit être une instance de la classe Exception (ou une de ses
sous-classes). Autrement, on aura une erreur fatale émise par PHP.
♦ PHP nous offre la possibilité d'hériter la classe Exception afin de

personnaliser nos exceptions. On peut réécrire les méthodes __construct
et __toString. Toutes les autres méthodes sont finales.

Exceptions
Exemple :
<?php
function inverse($x) {
if (!$x) { throw new Exception('Division par zéro.'); }
else return 1/$x;
}
try {
echo inverse(5) . "<br>";
echo inverse(0) . "<br>";
} catch (Exception $e) {
echo 'Exception reçue : ' . $e->getMessage() . "<br>";
}
echo 'Bonjour le monde !';
?>
Affichage :
0.2
Exception reçue : Division par zéro.
Bonjour le monde !
PDO (PHP Data Object) :
accès aux bases de données depuis PHP
♦ PDO (PHP Data Object) est une couche d'abstraction des fonctions d'accès aux
bases de données en programmant avec un style orienté objet, et surtout qui
permet de s'affranchir du SGBD. PDO n'utilise pas des fonctions au nom
trop explicite comme mysqli_query() ou mysqli_connect(), ce qui facilite
grandement la migration d'un SGBD à l'autre.
♦ L'utilisation d’un SGBD avec PHP s'effectue en plusieurs étapes :

1. Connexion au serveur de données et sélection de la base de données
2. Effectuer des requêtes
[3. Exploitation des résultats de la requête]
4. Déconnexion

♦ Connexion au serveur de données :
▪ Avant de travailler avec un serveur de gestion de base de données (comme
MySQL), il faut ouvrir une connexion.
▪ Ouvrir une connexion se fait automatiquement lorsqu'on instancie un objet PDO.
▪ Syntaxe :
$connexion = new PDO("DSN", "NomUtilisateur", "MotDePasse");
Le DSN (Data Source Name) permet de décrire la base de données à laquelle
nous allons nous connecter et son type. Chaque SGBD a ses propres paramètres.
Nous ne verrons que le DSN MySQL.
▪ Exemple :
// Préparation des informations nécessaires
$dsn = 'mysql:host=localhost;dbname=nomDeMaBase';
$utilisateur = 'root';
$mdp = '';
// Création d'un objet PDO et connexion
$connexion = new PDO($dsn, $utilisateur, $mdp);
♦ Étant donné que la connexion à la base de données est utilisée sur plusieurs pages
différentes du site, il serait judicieux de créer un fichier de connexion et d'y faire
appel à chaque fois que nous en avons besoin. De plus, si les données permettant de
configurer notre accès changent, il nous suffira de mettre à jour ce simple fichier.
Voici un petit exemple reprenant le code précédent. Ici nous créons des constantes
pour les paramètres à passer plutôt que des variables. On peut aussi améliorer ce
code en ajoutant une structure de test de type try / catch.
// Préparation des informations nécessaires
define('DSN', 'mysql:host=localhost;dbname=test');
define('USER', 'root');
define('MDP', '');
// Création d'un objet PDO et connexion
try {
$connexion = new PDO(DSN, USER, MDP);
} catch (PDOException $e) {
echo "Erreur : ".$e -> getMessage();
exit();
}
♦ Déconnexion :
▪ Pour se déconnecter, il suffit de détruire l'objet PDO que nous avons
créé. Affecter la valeur null à cet objet suffira.
▪ Syntaxe :
// Fermeture de la connexion
if ($connexion) {
$connexion = NULL;
}
Remarque : Nous vérifions l'existence de notre objet avant de changer sa
valeur, évitant ainsi la génération d'une erreur si la connexion avait déjà
été précédemment fermée.

♦ Effectuer des requêtes :
▪ Une fois connecté au serveur de données (ex : MySQL) avec notre objet PDO,
nous allons pouvoir commencer à envoyer des requêtes SQL au serveur.
▪ PDO distingue deux types de requêtes :
1- Les requêtes de mise à jour (UPDATE, INSERT, DELETE) :
$connexion->exec("Requête");
- Requête : une chaîne de caractères, syntaxe SQL.
- La méthode exec() retourne un entier qui correspond au nombre de lignes
affectées par la requête.
- Exemple :
$nbLignes = $connexion->exec("DELETE FROM personne WHERE id=2");

2- Les requêtes de sélection (SELECT) : $connexion->query("Requête")
- La méthode query() retourne FALSE en cas d’erreur ou, sinon, un jeu de résultats en tant qu’objet de
la classe PDOStatement.
Exemple :
$resultats = $connexion->query("SELECT nom, prenom FROM personne");
- Pour connaître le nombre de lignes de résultats : $resultats->rowCount()
- Pour parcourir ligne par ligne les résultats de la requête : $resultats->fetch()
- Pour récupérer, en tant qu'objet, ligne par ligne les résultats de la requête : $resultats->fetchObject()
Exemple :
while($ligne=$resultats->fetch()){echo $ligne[0].' '.$ligne[1] .'<br />';}
ou while($ligne=$resultats->fetch()){echo $ligne['nom'].' '.$ligne['prenom'] .'<br />';}
ou while($ligne=$resultats->fetchObject()){echo $ligne->nom.' '.$ligne->prenom.'<br />';}
- Pour mettre toutes les lignes dans un tableau : $resultats->fetchAll()
Exemple :
$lignes = $resultats->fetchAll();
foreach($lignes as $ligne) {echo $ligne['nom'].' '.$ligne['prenom'].'<br />'; }
- Pour libérer la connexion au serveur, permettant ainsi à d'autres requêtes SQL d'être exécutées :
$resultats->closeCursor()
♦ Requêtes préparées :
▪ Lorsqu'on exécute une requête, la base de données va l'analyser, la compiler,
l'optimiser puis l'exécuter. Le but des requêtes préparées est de ne pas répéter
toutes ces actions lorsqu'on exécute des requêtes identiques.
▪ Une requête préparée ou requête paramétrable est utilisée pour exécuter la même
requête plusieurs fois.
▪ Deux étapes sont nécessaires : la préparation et l’exécution.
Les méthodes que nous aurons besoin sont :
La méthode prepare() va préparer une requête qui contient soit des paramètres ou
noms (:nom) soit des marqueurs (?), qui sera ensuite exécutée au travers de la
méthode execute(). Les noms et les marqueurs seront substitués par leurs valeurs à
l’exécution ou avec la méthode bindParam().
Remarque : vous ne pouvez pas utiliser les noms et les marqueurs dans une même
requête SQL ; choisissez l'un ou l'autre.

▪ Exemple 1 :
$c = new PDO('mysql:host=localhost;dbname=test', 'root', '');
$stmt=$c->prepare("INSERT INTO personne (nom, prenom) VALUES (:nom, :prenom)");
$stmt->bindParam(':nom', $nom); //bindParam : Lie un paramètre à un nom de variable spécifique
$stmt->bindParam(':prenom', $prenom);
// Insertion d’une ligne
$nom = 'Azaiis';
$prenom = 'Mohamed';
$stmt->execute();
// Insertion d’une autre ligne
$nom = 'Essoufi';
$prenom = 'Amina';
$stmt->execute();

▪ Exemple 2 :
- On peut utiliser « ? » comme marqueur de paramètre dans la requête :
$stmt = $c->prepare("INSERT INTO personne (nom, prenom) VALUES (?, ?)");
$stmt->bindParam(1, $nom);
$stmt->bindParam(2, $prenom);
$nom = 'Azaiis'; $prenom = 'Mohamed';
$stmt->execute();
- On peut passer les paramètres de la requête dans la méthode execute() :
$stmt = $c->prepare("INSERT INTO personne (nom, prenom) VALUES (?, ?)");
$nom = 'Azaiis'; $prenom = 'Mohamed';
$stmt->execute(array($nom, $prenom));
▪ Exemple 3 :

$stmt = $c->prepare("SELECT nom, prenom FROM personne WHERE nom = ?");
if($stmt->execute(array($_GET['name']))) {
while($ligne = $stmt->fetch()) {
print($ligne['nom'].' '.$ligne['prenom'] .'<br />');
}
}
Remarques :
- La méthode prepare() retourne un objet de type PDOStatement si le serveur de
base de données prépare avec succès la requête. Dans le cas contraire elle retourne
FALSE ou émet une exception PDOException.
- La méthode execute() retourne TRUE en cas de succès ou FALSE sinon.

Gestion de XML avec PHP
♦ L'extension DOM de PHP permet de manipuler des documents XML avec une
collection d'objets et leurs méthodes et propriétés associées.
♦ Le DOM est une API standard : les méthodes de manipulation DOM sont
exactement les mêmes dans tous les langages. Donc les noms de propriétés et
de méthodes DOM que nous avons utilisé avec JavaScript sont les mêmes que
nous allons utilisés dans ce chapitre avec PHP.
♦ L'extension DOM de PHP5 est entièrement orientée objet. Les principales classes :
‣ DomNode : objet nœud : document, éléments, nœuds textuels, ...
‣ DomDocument : objet document (hérite de DomNode)
‣ DomElement : objet élément (hérite de DomNode)
‣ DomAttr : objet attribut (hérite de DomNode)
‣ DomNodeList : objet liste de DomNode (ce n'est pas un tableau PHP)

♦ L’objet document :
▪ Création d’un document XML :
Tout traitement de XML doit commencer par l’instanciation d’un objet
DomDocument :
$document = new DomDocument();
▪ Chargement des données XML :
Une fois le document créé, il peut soit être construit de toutes pièces avec des
éléments, attributs et textes, soit être chargé à partir d'une source XML provenant
d'un fichier ou d'une variable textuelle.
๏ Charger un fichier XML :
Pour charger un fichier XML, il faut appeler la méthode load() de l’objet
document en fournissant une adresse de fichier :
$document->load('nomDuFichier.xml');

๏ Charger une chaîne XML :
Il est possible de charger directement le XML depuis une chaîne de caractères
grâce à la méthode loadXML() :
$xml = "<cours><titre> XML et PHP </titre></cours>";
$document->loadXML($xml) ;
▪ Enregistrement d’un document XML :
$document->save('nouveauFichier.xml');
Exemple : <?php
$document->load('annuaire.xml');
$document->save('copieannuaire.xml');
?>
▪ Enregistrement dans une variable :
$chaineXML = $document->saveXML();
La méthode saveXML() renvoie le contenu sous la forme d’une chaîne de caractères.

♦ Lire un document :
▪ Accéder à l’élément racine :
$racine = $document->documentElement;
▪ Accéder au document depuis un nœud :
La fonction inverse de l’attribut documentElement s’appelle ownerDocument. Il
permet de récupérer l’objet document à partir d’un nœud quelconque.
$document = $racine->ownerDocument;

▪ Rechercher un élément par la valeur d’un attribut de type ID :
$element = $document->getElementById("valeurId");
▪ Rechercher un élément par le nom de la balise :

$listeElements = $document->getElementsByTagName("nomBalise");
Cette méthode retourne un objet de type DomNodeList.
On peut parcourir $listeElements avec la boucle foreach() ou accéder à un item en
particulier à l’aide de la méthode item() et d’un index numérique.
$noeud1 = $listeElements->item(0); // Premier nœud de la liste
$nombreNœuds = $listeElements->length; // Nombre des nœuds de la liste

▪ Exemple 1 :
-------------------------------------------------XML----------------------------------------------------
Soit le fichier annuaire.xml du chapitre 3.
<annuaire> … </annuaire>
------------------------------------------------- PHP-----------------------------------------------------
<?php
// Recherche de tous les noms
$listeNoms = $document->getElementsByTagName('nom');
foreach($listeNoms as $nom) echo $nom->firstChild->nodeValue . "<br />";
// Recherche du téléphone de la première personne
$personne1 = $document->getElementsByTagName('personne')->item(0);
$telephonePersonne1 = $personne1->getElementsByTagName('telephone')->item(0);
echo $telephonePersonne1->firstChild->nodeValue . "<br />";
?>

▪ Exemple 2 :
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>PHP-XML</title></head>
<body>
<table border="1" cellspacing="0">
<caption>Liste des personnes</caption>
<tr><th>Nom</th><th>Prénom</th><th>Téléphone</th></tr>
<?php
$listeNoms = $document->getElementsByTagName("nom");
$listePrenoms = $document->getElementsByTagName("prenom");
$listeTelephones = $document->getElementsByTagName("telephone");
for($i=0; $i<$listeNoms->length; $i++)
echo '<tr><td>'.$listeNoms->item($i)->firstChild->nodeValue ."</td><td>".
$listePrenoms->item($i)->firstChild->nodeValue ."</td><td>".
$listeTelephones->item($i)->firstChild->nodeValue ."</td></tr>";
?></table></body></html>
♦ Quelques méthodes et attributs de l'objet DOMNode :
Soit $noeud un objet de type DOMNode. (Ces méthodes et attributs ont été détaillés
dans le chapitre 2)
$nom = $nœud->nodeName;
$valeur = $nœud->nodeValue;
$type = $nœud->nodeType;
$pere = $nœud->nodeParent;
$liste_enfants = $nœud->childNodes;
$noeud = $liste_enfants->item(…);
$attributs = $nœud->attributes;
$attribut = $attributs->getNamedItem("…");
$valeurAttribut = $nœud->getAttribute ("…");
$premier_enfant = $nœud->firstChild;
$dernier_enfant = $nœud->lastChild;
$grand_frere = $nœud->previousSibling;
$petit_frere = $nœud->nextSibling;

▪ Exemple : Soit le fichier annuaire.xml du chapitre 3. On souhaite afficher les personnes ayant un numéro de
fixe (<telephone type="fixe">).
<!DOCTYPE html>
<html>
<head><meta charset="UTF-8"><title>PHP-XML</title></head>
<body>
<table border="1" cellspacing="0">
<caption>Liste des personnes</caption>
<tr><th>Nom</th><th>Prénom</th><th>Téléphone</th></tr>
<?php $document = new DomDocument();
$listeNoms = $document->getElementsByTagName("nom");
$listePrenoms = $document->getElementsByTagName("prenom");
$listeTelephones = $document->getElementsByTagName("telephone");
for($i=0; $i<$listeTelephones->length; $i++) {
$attributs = $listeTelephones->item($i)->attributes;
$attributType = $attributs->getNamedItem("type")->nodeValue;
if (strcmp($attributType,'fixe')==0) {
echo '<tr><td>'.$listeNoms->item($i)->firstChild->nodeValue ."</td><td>".
$listePrenoms->item($i)->firstChild->nodeValue ."</td><td>".
$listeTelephones->item($i)->firstChild->nodeValue ."</td></tr>"; }
?></table></body></html>
♦ Création des nœuds et attributs :
La création des nœuds éléments ou textuels s'obtient soit par l'instanciation des objets,
soit par les méthodes de création de l'objet DOMDocument :
$element = $document->createElement('nomElement', ['valeurElement']);
$texte = $document->createTextNode('Un texte...');
$element = new DOMElement('nomElement', ['valeurElement']);
Les noeuds éléments ou textuels s’insèrent dans le document par l'intermédiaire de la
méthode appendChild() ou insertBefore() de l'objet DOMNode.
$racine = new DOMElement('annuaire');
$document->appendChild($racine);
Les attributs s'ajoutent aux éléments d'une manière différente. En effet, il faut passer
par les méthodes d'ajout d'attribut de l'objet DOMElement.
$element = new DOMElement('elt');
$reussi = $element->setAttribute('attribut', 'valeur');
$attribut = new DOMAttr('attribut', 'valeur');
$reussi = $element->setAttributeNode($attribut);
▪ Exemple : On souhaite ajouter une nouvelle personne (Aababou Mohamed 0699556611) au
fichier annuaire.xml .
<?php $document = new DomDocument();
$elementPersonne = $document->createElement('personne');
$elementNom = $document->createElement('nom', 'Aababou');
$elementPrenom = $document->createElement('prenom', 'Mohamed');
$elementTelephone = $document->createElement('telephone', '0699556611');
$elementTelephone->setAttribute('type', 'portable');
$elementPersonne->appendChild($elementNom);
$elementPersonne->appendChild($elementPrenom);
$elementPersonne->appendChild($elementTelephone);
$reussi = $racine->appendChild($elementPersonne);
if($reussi) echo '<script>alert("Personne ajoutée !");</script>';
$document->save('annuaire.xml');
?>
♦ Modification et suppression des nœuds et attributs :
▪ $noeud = $DOMNode->removeChild(DOMNode ancienNoeud);
Supprime le nœud spécifié de la liste des enfants du nœud courant.
▪ $noeud = $DOMNode->replaceChild(DOMNode nouvNoeud, DOMNode ancNoeud);
Remplace un ancien nœud par un nouveau au sein des enfants du nœud courant.
▪ $noeud = $DOMNode->cloneNode([boolean recursif]);
Clone un nœud et éventuellement l'ensemble de sa descendance (recursif = true).
▪ $DOMElement->removeAttribute(string nom);
Supprime l'attribut portant le nom spécifié.
▪ $booleen = $DOMElement->removeAttributeNode(DOMAttr attribut);
Supprime l'attribut spécifié.

▪ Exemple : On souhaite supprimer la dernière personne du fichier annuaire.xml .
<?php
$listePersonnes = $document->getElementsByTagName("personne");
$dernier = $listePersonnes->item($listePersonnes->length-1);
$reussi = $racine->removeChild($dernier);
if($reussi) echo '<script>alert("Personne supprimée !");</script>';
$document->save('annuaire.xml');
?>

Chapitre5 PHP

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre5 PHP

Transféré par

Droits d'auteur :

Formats disponibles

Développement Web

10/01/2023 Prof. Hafida ZROURI 2

10/01/2023 Prof. Hafida ZROURI 3

10/01/2023 Prof. Hafida ZROURI 6

10/01/2023 Prof. Hafida ZROURI 7

10/01/2023 Prof. Hafida ZROURI 8

10/01/2023 Prof. Hafida ZROURI 9

10/01/2023 Prof. Hafida ZROURI 11

10/01/2023 Prof. Hafida ZROURI 12

$mohamed = new User(); // Création d'un objet à partir de la classe

10/01/2023 Prof. Hafida ZROURI 13

10/01/2023 Prof. Hafida ZROURI 14

10/01/2023 Prof. Hafida ZROURI 15

10/01/2023 Prof. Hafida ZROURI 16

10/01/2023 Prof. Hafida ZROURI 20

▪ Opérateur de comparaison "=="

▪ Opérateur d'identité "==="

10/01/2023 Prof. Hafida ZROURI 21

10/01/2023 Prof. Hafida ZROURI 22

10/01/2023 Prof. Hafida ZROURI 23

10/01/2023 Prof. Hafida ZROURI 24

10/01/2023 Prof. Hafida ZROURI 25

10/01/2023 Prof. Hafida ZROURI 27

10/01/2023 Prof. Hafida ZROURI 29

♦ PHP nous offre la possibilité d'hériter la classe Exception afin de

10/01/2023 Prof. Hafida ZROURI 30

♦ L'utilisation d’un SGBD avec PHP s'effectue en plusieurs étapes :

10/01/2023 Prof. Hafida ZROURI 32

10/01/2023 Prof. Hafida ZROURI 35

10/01/2023 Prof. Hafida ZROURI 36

10/01/2023 Prof. Hafida ZROURI 38

10/01/2023 Prof. Hafida ZROURI 39

$c = new PDO('mysql:host=localhost;dbname=test', 'root', '');

10/01/2023 Prof. Hafida ZROURI 41

10/01/2023 Prof. Hafida ZROURI 42

10/01/2023 Prof. Hafida ZROURI 43

10/01/2023 Prof. Hafida ZROURI 44

10/01/2023 Prof. Hafida ZROURI 45

▪ Rechercher un élément par le nom de la balise :

10/01/2023 Prof. Hafida ZROURI 46

10/01/2023 Prof. Hafida ZROURI 47

10/01/2023 Prof. Hafida ZROURI 49

10/01/2023 Prof. Hafida ZROURI 53

10/01/2023 Prof. Hafida ZROURI 54

Vous aimerez peut-être aussi