Développer en - Notions de base

Développer en <PHP> Notions de base Créé le : 12. avril 2005 Créé par : Steve Fallet Modifié le : 9 novembre 2007 Modifié par : Steve Fallet Adresse de contact : [email protected]

Développer en <PHP> : Table des matières

Programmation Internet Le+PHP+v2.0.doc

1 TABLE DES MATIERES ...........................................................................................3

2 INTRODUCTION ...................................................................................................5 2.1. Un peu d’histoire .........................................................................................................5 2.2. Première page PHP.....................................................................................................6 2.3. Principes de PHP..........................................................................................................7

3 LE LANGAGE PHP ...............................................................................................8 3.1. Généralités ...................................................................................................................8 3.2. Commentaires .............................................................................................................8 3.3. Variables .......................................................................................................................9 3.4. Types ..............................................................................................................................9 3.5. Ecrire du code HTML...................................................................................................9 3.6. Les chaînes de caractères ......................................................................................10 3.7. Les constantes et variable d’environnement......................................................11 3.8. Les structures de contrôle........................................................................................12 3.9. Les tableaux ...............................................................................................................14

3.9.1. Les tableaux numériques................................................................................14 3.9.2. Tableaux associatifs .........................................................................................16

3.10. Les fonctions ..........................................................................................................17 3.10.1. Les paramètres : ...............................................................................................17 3.10.2. Le retour : ...........................................................................................................19

3.11. Les fichiers ..............................................................................................................19 3.11.1. Créer, tester l’existence et supprimer un fichier.........................................19 3.11.2. Lecture d’un fichier..........................................................................................19 3.11.3. Ecrire dans un fichier .......................................................................................20 3.11.4. Ajouter de texte dans un fichier....................................................................21 3.11.5. Insertion d’une ligne ........................................................................................21 3.11.6. Modification d’une ligne ................................................................................24 3.11.7. Suppression d’une ligne..................................................................................25 3.11.8. Fonctions............................................................................................................26 3.11.9. Conclusions .......................................................................................................26

3.12. Les classes ..............................................................................................................27 3.12.1. Création de classes .........................................................................................27 3.12.2. Utilisation de classes ........................................................................................28

3.13. Variables POST et GET..........................................................................................29 3.13.1. Envoyer des variables POST ou GET..............................................................29 3.13.2. Récupérer des variables POST ou GET.........................................................29

4 LES BASES DE DONNÉES ET PHP.......................................................................31 4.1. Introduction ................................................................................................................31 4.2. Connexion ..................................................................................................................32 4.3. Exécuter une requête SQL.......................................................................................32 4.4. Afficher le résultat d’une requête (Ressource de résultat MySQL) ................33

1 TABLE DES MATIERES

Développer en <PHP> : Table des matières


4.4.1. mysql_fetch_row...............................................................................................33 4.4.2. mysql_fetch_array............................................................................................34 4.4.3. mysql_fetch_object .........................................................................................35

4.5. Autres requêtes..........................................................................................................37 4.5.1. INSERT, Ajout de données...............................................................................37 4.5.2. DELETE, Suppression de données ..................................................................38

5 PSEUDO-FRAMES...............................................................................................39 5.1. Inclusion de fichiers ...................................................................................................39 5.2. Les pseudo-frames ....................................................................................................40

5.2.1. Comment ca marche ?..................................................................................40 5.3. Conclusion..................................................................................................................41 5.4. Problème de sécurité ...............................................................................................42

5.4.1. Le problème......................................................................................................42 5.4.2. Le code..............................................................................................................43 5.4.3. Explication .........................................................................................................43 5.4.4. Conclusion.........................................................................................................44

6 LES SESSIONS......................................................................................................45 6.1. Introduction ................................................................................................................45 6.2. Exercice pratique......................................................................................................46

7 EASYPHP (V. 1.6.0.0) .........................................................................................50 7.1. Les Alias .......................................................................................................................50 7.2. Données MySQL (datadir) .......................................................................................50 7.3. PhpMyAdmin..............................................................................................................51 7.4. Environnement EasyPHP...........................................................................................51

8 PHPMYADMIN (V. 2.2.6) ...................................................................................52 8.1. Nouvelle base de donnée ......................................................................................52 8.2. Gestion des utilisateurs .............................................................................................52 8.3. Gestion des clés étrangères....................................................................................53

Développer en <PHP> : Introduction


PHP est un langage de script le plus souvent intégré à votre code HTML et interprété coté serveur. Il présente l'avantage de traiter dynamiquement les flux d'informations en provenance des différents clients qui sont connectés à ce serveur afin de les regrouper et/ou de les interpréter. Ceci vous semble être du chinois ? Plus d'explications dans la suite …

2.1. Un peu d’histoire

PHP est un langage de programmation créé en 1994 par Rasmus Lerdorf. Celui-ci avait pour but de faciliter le développement d'applications pour le web. Aussi, il lui donna le nom de " Personal HomePage Tools ". Ce nom évolua au fil du temps pour finalement formé l'acronyme récursif suivant : " PHP : Hypertext Preprocessor ". PHP possède de nombreux liens de parenté avec le langage C, ce qui facilite son apprentissage auprès d'une importante communauté de développeurs. Il détient l'énorme qualité d'être libre et multi-plateforme car il fonctionne aussi bien sous Linux que sous Windows. Enfin, il est nécessaire de préciser que la version 4 de PHP utilise un moteur de script développé et commercialisé par ZEND qui présente l'avantage d'améliorer de manière notable les performances de cette version par rapport à la précédente. Actuellement PHP est essentiellement utilisé en tant que module de serveur HTTP tel qu’Apache. Il possède une très large palette de fonctions permettant notamment de gérer les aspects suivants du développement Web :

� Fonctions mathématiques � Accès au système de répertoires et de fichiers � Manipulation de tableaux et chaîne � Manipulation d'images � Manipulation dates/heures � Connexion serveur SMTP (envoi de mail) � Gestion des sessions, des cookies � …

Bien évidement, cette lise n'est pas exhaustive et regroupe de manière sommaire les quelques 2873 fonctions actuellement (13/04/2003) disponibles.

2 INTRODUCTION



Enfin, pour stocker et dynamiser les informations récoltées, vous pouvez utiliser tout un éventail de base de données comme :

� MYSQL � MySQL � Oracle � PostgreSQL � Sybase � Access � Sql Server � …

Références : www.php.net www.mysql.com www.apache.org www.zend.com

Ici encore, la liste n'est pas exhaustive. A noter que pour les deux derniers exemples (les bases Microsoft) il est nécessaire d'installer des composants supplémentaires, étonnant non !

2.2. Première page PHP

<html> <head> <title>MA PREMIERE PAGE EN PHP</title></title> </head> <body> <H1>HTML + PHP</H1> Nous sommes le <?php echo Date ("j/m/Y"); ?> <p> <?php echo "Je suis " . $_SERVER['HTTP_USER_AGENT'] . "<BR>"; echo "Je dialogue avec " . $_SERVER['SCRIPT_NAME ']; ?> </body> </html> HTML + PHP Nous sommes le 28/01/2004 Je suis Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.1.4322) Je dialogue avec /web/php/premiere_page.php

Il s’agit d’un document HTML classique, au sein duquel on a introduit des commandes encadrées par les balise <?php et ?> Ici on a deux occurrence de code PHP, que l’on appelle script.



2.3. Principes de PHP

Le client Web (browser) envoie une requête vers le serveur Web [www.monserveur.com/mapage.php]. Le serveur intercepte la requête. Si un ficher avec une extension .php est demandé, alors le serveur le charge en mémoire et y cherche tous les scripts PHP qu’il transmet au module PHP. L’interpréteur, le module PHP, exécute le script ce qui à pour effet de produire du code HTML qui remplace le script. Le script PHP peut éventuellement envoyer une requête sur une BD. Réponse de la BD. Le moteur termine l’interprétation du script. Le module envoie une réponse sous la forme d’une page statique, ne contenant que du HTML, ou autres langage que le client (browser), peut interpréter, JavaScript par exemple. Le navigateur client interprète la réponse, et affiche la page.

Développer en <PHP> : Le langage PHP


PHP s’appuie sur toutes les structures et concepts d’un langage de programmation de haut niveau, ainsi que sur les outils de base de la programmation orientée objet. Il a cependant la particularité d’avoir été conçu spécifiquement pour être intégré avec HTML. L’intérêt de PHP n’est pas seulement dans sa syntaxe, qui est très simple et somme toute assez limitée, mais dans les fonctions qui accompagnent le langage et fournissent un nombre impressionnant de fonctionnalités prêtes à l’emploi. Vous pouvez voir la liste complète de ses fonctionnalités sur le site officiel de php [www.php.net] Note : Afin de tester les exemples de ce cours, je vous conseil d’installer EasyPHP, pour ce faire reportez-vous au chapitre EasyPHP.

3.1. Généralités

Comme on l’a vu précédemment, tout code PHP doit être inclus entre les balises <?php … ?>,que l’on appelle script. Eviter l’utilisation des balises courtes <? … ?>, elles risquent d’entrer en conflit avec d’autres langages. Comme en C, le séparateur d’instruction est le « ; ». echo "Ceci est une instruction";

3.2. Commentaires

Il existe trois manières d’inclure des commentaires en PHP : Comme en C, entre les signes « /* » et « */ » Comme en C, en commençant une ligne pare « // » Comme en shell Unix, avec « #> /* Voici un bloc de commentaires */ //Cette ligne est un commentaire, pas vrais ! #Cette ligne est aussi un commentaire, génial non !

3 LE LANGAGE PHP



3.3. Variables

Une variable est représentée par un signe dollar « $ » suivi du nom de la variable. Le nom d'une variable doit toujours commencer par une lettre ou un « _ », suivi de lettres, chiffres ou soulignés, de plus le « . » n'est pas autorisé. Remarque : PHP distingue les majuscules des minuscules dans le nom des variables : $mavariable et $maVariable sont deux variables différentes. En revanche, les noms de fonction sont insensibles à la casse. Une variable permet de référencer des valeurs. Comme leur nom l’indique, les variables peuvent référencer des valeurs différentes, ce qui les distingue des littéraux (‘0’, ‘1.233’, ‘Chaîne de caractère’) qui représentent directement une valeur immuable. <?php // Variable valide $ma_variable ="contenu de la variable"; // Variable invalide car elle commence par un chiff re $4bonjours ="essais 1"; // Variable invalide car elle contient un "." $bonjours.txt ="essais 1echo // Ceci affichera le contenu de la variable echo $ma_variable; ?>

3.4. Types

Le type de variable peut changer au cours du même script, contrairement à d’autres langages comme le C ou Java. Ce la veut dire qu’une variable peut référencer à un moment un entier puis une chaîne, un objet, etc. L’interpréteur se charge de gérer l’espace en mémoire nécessaire pour stocker la valeur référencée par une variable, ce qui représente un très grand confort d’utilisation.

3.5. Ecrire du code HTML

Nous avons vu qu’en PHP on utilise la commande echo pour imprimer du code HTML. echo "code html"; Si comme dans l’exemple ci-dessus, le code HTML est entouré par des guillemets doubles, il faudra utiliser l’anti-slash \ comme caractère d’échappement pour écrire un guillemet double dans une chaîne. echo "<a href=\"mapage.htm\">monlien</a>"; Par contre si votre echo est sous cette forme : echo 'code html';



Tous les " devront rester intacts mais cette fois vous devrez remplacer tous les ' par des \' et ainsi de suite ... echo '<table border=\'1\'>'; Note : Dans une chaîne entourée par des guillemets doubles, php va comprendre certains caractères spéciaux : \n Nouvelle ligne \r Retour à la ligne \t Tabulation Attention : On utilise ces caractères pour mieux indenter notre code, pas pour gérer l’affichage de la page HTML.

3.6. Les chaînes de caractères

Nous venons de voir qu’une chaîne s’écrit soit entre des guillemets doubles ou des apostrophes. Une des particularités de PHP est qu’une chaîne peut contenir une variable, exemple : $nom = "Fallet"; $prenom = "Steve"; $adresse = "Rue des Blancs-Pins 19"; $pers = "Monsieur <br> $nom $prenom <br> $adresse"; echo $pers."<br><br>"; Monsieur Fallet Steve Rue des Blancs-Pins 19

La deuxième manière de réaliser ce prodige [là j’exagère !], est de concaténer plusieurs éléments : $nom = "Fallet"; $prenom = "Steve"; $adresse = "Rue des Blancs-Pins 19"; $pers = "Monsieur <br>".$nom." ".$prenom."<br>".$ad resse; echo $pers."<br><br>"; Monsieur Fallet Steve Rue des Blancs-Pins 19

On peut aussi faire une concaténation de la manière suivante : $chaine = "<p>Les qualifiés sont : "; $chaine .= "<b>Jean et Pierre</b></p>"; echo $chaine; Les qualifiés sont : Jean et Pierre



Calculer la taille d’une chaîne : echo "La taille de 'bonjour' est : ".strlen("bonjou r"); La taille de 'bonjour' est : 7

3.7. Les constantes et variable d’environnement

PHP propose plusieurs constantes ou variable d’environnement ci-dessous, une liste non exhaustive : $_SERVER['SERVER_NAME'] Nom du serveur d'hôte

$_SERVER['DOCUMENT_ROOT'] Racine du serveur $_SERVER['HTTP_ACCEPT_LANGUAGE'] Langage du navigateur client ( ex : fr )

$_SERVER['HTTP_HOST'] Hôte du client

$_SERVER['HTTP_REFERER'] Adresse de la page qui a conduit le client à la page courante

$_SERVER['HTTP_USER_AGENT'] Nom du navigateur du client $_SERVER['REMOTE_ADDR'] Adresse IP du client

$_SERVER['SCRIPT_FILENAME'] Nom du script en cours ex: mon_script.php )

$_SERVER['REQUEST_URI'] Adresse du script en cours ( ex : http://www.site.com/script.php)

__FILE__ Nom du fichier parsé

__LINE__ N° de la ligne courante du ficher en cours

PHP_VERSION N° de la version de PHP

PHP_OS Nom de l’OS sur lequel est exécuté PHP

Remarque : les variables d’environnement commencent toujours par un $, et toujours en majuscule comme les constantes. On peut également définir ses propres constants [nom en majuscules] : <?php define ("NOM","Fallet"); define ("PRENOM","Steve"); echo "<li>Votre nom : ".NOM."</li>"; echo "<li>Votre prénom : ".PRENOM."</li>"; echo "<br>".$DOCUMENT_ROOT."<BR>"; echo __FILE__; ?> Votre nom : Fallet Votre prénom : Steve c:/program files/easyphp/www u:\cours\web\cours\php\constantes.php



3.8. Les structures de contrôle

Les structures de contrôle nous permettent d’effectuer des tests, afin de contrôler l’exécution d’un script.

Structures Signification Opérateurs Signification if Si == Egale else Autrement != Différent elseif Autrement si < Inférieur à switch Selon > Supérieur à while Tant que <= Inférieur ou égal à for Tant que >= Supérieur ou égal à and ou && Et or ou || Où ! Not

<?php $p1 = "Jean"; //Test si p1 = PIERRE if($p1 == "PIERRE") { echo "Bonjour Pierre !"; } //Autrement si not p1 --> si p1 est vide ou false else if(!$p1) { echo "Vous n'avez pas de prénom !"; } //Autrement else { echo "Vous n'êtes pas Pierre !"; } ?> Si p1 = Jean : Vous n'êtes pas Pierre ! Si p1 = PIERRE : Bonjour Pierre ! Sinon : Vous n’avez pas de prénom !



//La boucle for <?php //La boucle for for($i=0;$i<=10;$i++) echo $i."<br>"; ?> 0 1 2 3 4 5 6 7 8 9 10

//La boucle while <?php //La boucle while $i = 0; $j = 5; while($i != $j) { echo $i."<br>"; $i++; } ?> 0 1 2 3 4

//Le switch <?php //Le SWITCH $var = 5; switch($var) { case 5 : echo "Rendre 4.50 CHF !"; break; case 2 : echo "Rendre 1.50 CHF !"; break; case 1 : echo "Rendre 0.50 CHF !"; break; case 0.50 : echo "Rendre 0.00 CHF!"; break; } ?> Rendre 4.50 CHF !



3.9. Les tableaux

3.9.1. Les tableaux numériques

Les tableaux nous permettent de stoquer une grande quantité d’informations dans une seule variable. L’index d’un tableau commence à 0 comme dans la plupart des langages de programmation. Les tableaux numériques se déclarent de deux façons : En ajoutant le double crochet devant une variable et en spécifiant l’index du tableau: $tab1[0] = "Jean"; $tab1[1] = "Nemarre"; Si on ne donne pas l’index du tableau, php insère automatiquement à la fin du tableau. $tab2[] = "Jean"; $tab2[] = "Nemarre"; Avec la méthode array(), chaque éléments des tableaux étant séparé par une virgule. $tab3 = array("Jean","Nemarre"); Les tableaux sont hétérogènes, et peuvent donc contenir des valeurs ou variables de tous types. $tab1 = array("steve",1111,$tab2); Pour accéder à une case du tableau, on indique l’index du tableau entre les doubles crochets. $tab[5] = "TEST"; echo $tab[5];



Pour parcourir un tableau on utilisera une des deux boucles vues dans le chapitre précédent. $tab1[0] = "1"; $tab1[1] = "2"; $tab1[2] = "3"; $tab2[] = "A"; $tab2[] = "B"; $tab2[] = "C"; $tab3 = array($tab1[0],$tab2[0],$tab1[1],$tab2[1]); echo $tab1[0]." / ".$tab1[1]."<br><br>"; for($i=0; $i<count($tab2);$i++) echo " / ".$tab2[$i]; echo"<br><br>"; $i=0; while($i<count($tab3)) { echo " / ".$tab3[$i]; $i++; } 1 / 2 / A / B / C / 1 / A / 2 / B

Il existe encore une boucle spécifique aux tableaux, le foreach (pour chaque). $tab[] = 1; $tab[] = "toto"; $tab[] = "bonjour"; foreach($tab as $v) echo $v."<br>"; 1 toto bonjour

Cette méthode parcours le tableau passé en paramètre et stoque la valeur de l’élément dans la variable souhaitée (ici $v) grâce au mot réservé as .



3.9.2. Tableaux associatifs

Dans le cas précédant, pour accéder à un élément du tableau il fallait utiliser l’index correspondant. Il existe une autre façon d’accéder aux éléments, en les référençant avec une chaîne de caractère, c’est ce qu’on appelle un tableau associatif. Exemple : $personnes[numero] = 1; $personnes[nom] = "Nemarre"; $personnes[prenom] = "Jean"; echo $personnes[prenom]."<br>"; Jean

Comme on peut le voir dans l’exemple précédant, pour nommer un élément du tableau, il suffit de remplacer l’index par un nom. Pour atteindre l’élément, c’est le même principe. L’exemple suivant montre comment parcourir un tableau associatif. $personnes[numero] = 1; $personnes[nom] = "Nemarre"; $personnes[prenom] = "Jean"; echo '<table> <tr> <th>KEY</th> <th>VALUE</th> </tr>'; for($i=0; $i<count($personnes); $i++) { $temp = each($personnes); echo "<tr><td>".$temp[key]."</td><td>".$temp[value]."</t d></tr>"; } echo '</table>'; KEY VALUE

numero 1

nom Nemarre

prenom Jean

La méthode each() retourne un tableau associatif de deux éléments key et value. Lors de son premier appel, each() retourne un tableau contenant la première paire clé/valeur (dans l’exemple numero/1). Pour passer à l’élément suivant, il suffit de rappeler la méthode each(), c’est pourquoi est fait partie de la boucle de parcours du tableau associatif.



On peut aussi déclarer un tableau associatif à l’aide de la méthode array(). $personnes = array( "numero"=>4, "nom"=>"Nemarre", "prenom"=>"Jean"); foreach ($personnes as $key=>$element) { echo $key." : ".$element."<br>"; } numero : 4 nom : Nemarre prenom : Jean

On remarque dans l’exercice ci-dessus la syntaxe de la boucle foreach() pour le parcours d’un tableau associatif.

3.10. Les fonctions

En PHP une fonction se décompose en 5 parties : Le mot clé function Le nom de la fonction Le(s) paramètre(s) Le(s) instruction(s) Un retour function nom_fonction($param1,$param2) { //bloc d’instructions $resultat = $param1 + $param2; //retour return $param1; }

3.10.1. Les paramètres :

Les paramètres peuvent être passés par valeur(en entrée) ou par référence(entrée/sortie). Quand on passe un paramètre par valeur, PHP fait une copie de celui-ci qui va être utilisée par la fonction, et donc l’originale reste inchangée. Si on passe le paramètre par référence, alors ola variable passée en paramètre peut être modifiée par la fonction. Par défaut en PHP, les paramètres sont passés par valeur. Pour passé un paramètre par référence, il faut que celui-ci soit précédé du caractère ‘&’ . Par valeur : function nom_fonction($param1){…} Par référence : function nom_fonction(&$param1){…} L’exemple suivant utilise une fonction qui augmente de deux la valeur passée en paramètre. Dans le premier cas le paramètre sera passé par valeur et dans le second par référence.



//Fonction plus2 avec paramètre par valeur function plus2_val ($param1) { $param1 = $param1 + 2; echo "Valeur de param1 dans plus2_val : $param1 <b r>"; } //Fonction plus2 avec paramètre par référence function plus2_ref (&$param1) { $param1 = $param1 + 2; echo "Valeur de param1 dans plus2_ref : $param1 <b r>"; } $x = 4; plus2_val($x); echo "Valeur de X après plus2_val : $x <br>"; plus2_ref($x); echo "Valeur de X après plus2_ref : $x <br>"; Valeur de param1 dans plus2_val : 6 Valeur de X après plus2_val : 4 Valeur de param1 dans plus2_ref : 6 Valeur de X après plus2_ref : 6

On voit que quand le paramètre est par référence, la valeur de $x augmente de deux après la fonction plus2_ref, alors qu’elle ne change pas avec la fonction plus2_val. On peut également donner une valeur par défaut aux paramètres. function additionne($x=4, $y=2) { return $x+$y; } echo "<p> Le résultat est : ".additionne(10,20)."</ p>"; echo "<p> Le résultat est : ".additionne()."</p>"; echo "<p> Le résultat est : ".additionne(10)."</p>" ; Le résultat est : 30 Le résultat est : 6 Le résultat est : 12

La fonction ci-dessus, à deux paramètres par valeur, qui on chacun une valeur par défaut. Si à l’appel, on ne donne aucun paramètre, alors les paramètres vont prendre comme valeur leur valeur par défaut soit 4 et 2. Si on donne deux paramètres alors se seront les valeurs de ces deux paramètres qui seront utilisées. On peut également donnée que le(s) x premier(s) paramètres, comme on peut le voir dans le 3e exemple.



3.10.2. Le retour :

Les fonctions peuvent retourner qqch de cette façon, on peut affecter le résultat d’une fonction dans une variable ou directement l’afficher comme dans l’exemple précédant, etc.… Le retour doit absolument être la dernière instruction exécutée par la fonction. function plus_grand_que($p1,$p2) { if($p1>$p2) return "vrais"; else return "faux"; } echo "<p>".plus_grand_que(5,4)."</p>"; vrais

3.11. Les fichiers

3.11.1. Créer, tester l’existence et supprimer un fichier

Ci-dessous un script qui permet de créer, de tester l’existence et de supprimer un fichier. Les fonctions utilisées dans ce bout de code sont expliquées sous la rubrique fonctions de ce chapitre. //Création du fichier 'temp.txt' if (touch("temp.txt")) echo "Le fichier à été créé avec succès !<br>"; else //Création impossible echo "Création impossible !<br>"; //Test si un fichier existe if(file_exists("temp.txt")) echo "Le fichier existe !<br>"; else echo "Fichier introuvable !<br>"; //Suppression du fichier 'temp.txt'; if (unlink("temp.txt")) echo "Le fichier à été supprimé avec succès !<br>" ; else //Suppression impossible echo "Suppression impossible !<br>"; Le fichier à été créé avec succès ! Le fichier existe ! Le fichier à été supprimé avec succès !

3.11.2. Lecture d’un fichier

Ci-dessous un script qui lit un fichier ligne par ligne, les fonctions utilisées dans ce bout de code sont expliquées sous la rubrique fonctions de ce chapitre. Contenu de fichier.txt : Hello world ! Ce qui veut dire en français heu, je sais plus …



//Emplacement et nom de du fichier $fichier = "fichier.txt"; //Ouverture du fichier en lecture if($fp = fopen($fichier,"r")) { //Initialisation du compteur $ligne=1; //Tant que pas fin du fichier while (!feof($fp)) { echo "Ligne n°".$ligne; //Extrait le contenu de la ligne //Une ligne dans un fichier texte //fait 1024 caractères ou octets. //1024 caractères = 1 Ko echo " : ".fgets($fp,1024)."<br>"; //Incrémentation du compteur $ligne++; } fclose($fp); // Fermeture du fichier } else //Echec à l'ouverture { echo "Erreur : impossible d'ouvrir ".$fichier; //Stope l'exécution du script exit(); } Hello world ! Ce qui veut dire en français heu, je sais plus …

3.11.3. Ecrire dans un fichier

Ci-dessous un script qui écrit dans un fichier vide, les fonctions utilisées dans ce bout de code sont expliquées sous la rubrique fonctions de ce chapitre. // Emplacement et nom du fichier $fichier = "fichier.txt"; // Texte à écrire dans le fichier, // le \n permet de passer à la ligne $txt = "TEXTE DE LA PREMIERE LIGNE \nTEXTE DE LA DE UXIEME LIGNE"; // Ouverture du fichier en écriture if($fp = fopen($fichier,"w+")) { // Ecrit dans le fichier fwrite($fp, $txt); // Fermeture du fichier fclose($fp); } else //Echec à l'ouverture { echo "Erreur : impossible d'ouvrir ".$fichier; //Stope l'exécution du script exit(); }



Contenu de fichier.txt après : Ligne n°1 : TEXTE DE LA PREMIERE LIGNE Ligne n°2 : TEXTE DE LA DEUXIEME LIGNE

3.11.4. Ajouter de texte dans un fichier

Ci-dessous un script qui ajoute des informations à la fin d’un fichier, les fonctions utilisées dans ce bout de code sont expliquées sous la rubrique fonctions de ce chapitre. Contenu de fichier.txt avant : Ligne n°1 : TEXTE DE LA PREMIERE LIGNE Ligne n°2 : TEXTE DE LA DEUXIEME LIGNE // Emplacement et nom du fichier $fichier = "fichier.txt"; // Ouverture du fichier en ajout if($fp = fopen($fichier,"a")) { //Saut de ligne fwrite($fp, "\n"); // On ajoute du texte fwrite($fp, "TEXTE DE LA TROISIEME LIGNE"); //Saut de ligne fwrite($fp, "\n"); // On ajoute du texte fwrite($fp, "TEXTE DE LA QUATRIEME LIGNE"); // Fermeture du fichier fclose($fp); } else // Echec à l'ouverture { echo "Erreur : impossible d'ouvrir ".$fichier; exit(); } Contenu de fichier.txt après : TEXTE DE LA PREMIERE LIGNE TEXTE DE LA DEUXIEME LIGNE TEXTE DE LA TROISIEME LIGNE TEXTE DE LA QUATRIEME LIGNE

3.11.5. Insertion d’une ligne

On possède une liste de client triée par numéro stoquées dans un fichier. Lors de l’ajout d’un nouveau client, il nous faudra rechercher la ligne ou insérer ce client afin de respecter l’ordre du tri. Fichier client.txt avant : NUMERO PRENOM NOM ************************************* 1000 JEAN NEMARRE 2000 LAURE DINATEUR 3000 YVES REMORDS



// Nom du fichier $fichier = "clients.txt"; // Nouveau client $cli_num =2002; $cli_nom ="SANDRA"; $cli_prenom ="SAMEGRATTE"; // Ouverture du fichier en lecture $fp = fopen($fichier,"r"); // Création d'un fichier temporaire touch("temp.txt"); // Ouverture du fichier temporaire $fp_temp = fopen("temp.txt","w+"); //0 == pas ajouter, 1 == déjà ajouter $ajouter = 0; // Parcours du fichier while (!feof($fp)) { // On récupère une ligne $ligne = fgets($fp,1024); //Si le new numero est >= OU déjà ajouté if (substr($ligne,0,4)<=$cli_num || $ajouter) { echo $ligne."<br>"; //Copie de la ligne dans temp fwrite($fp_temp,$ligne); } else // Si il est < alors on l'ajoute { //Ajout du new client fwrite($fp_temp,$cli_num."\t".$cli_prenom."\t\t" .$cli_nom."\n"); //Copie de la ligne en cours fwrite($fp_temp,$ligne); //Indique que l'ajout à déjà eu lieu $ajouter = 1; } } // Fermeture des fichiers fclose($fp); fclose($fp_temp); // On recopie le fichier temporaire copy("temp.txt",$fichier); // Suppression du fichier temporaire unlink("temp.txt");



Fichier client.txt après : NUMERO PRENOM NOM ************************************* 1000 JEAN NEMARRE 2000 LAURE DINATEUR 2002 SAMEGRATTE SANDRA 3000 YVES REMORDS Le principe est très simple, on parcourt le fichier original en lisant chaque ligne l'une après l'autre. Si la ligne contient un nombre inférieur ou égale à celui que nous souhaitons insérer, alors on se contente de recopier cette ligne dans le fichier temporaire. En revanche, si cette condition n'est plus valide, alors on a trouvé l'emplacement correct. On insère alors le nombre, puis la dernière ligne. Enfin, on passe le booléen ($ajouter) à vrai (1) de façon à prendre le relais de la condition de placement qui forcement n'est plus vrai. Les dernières lignes sont donc recopiées dans le fichier temporaire. Pour finir, on copie le contenu de ce fichier temporaire dans celui du fichier source et on efface le fichier temporaire. L'opération se fait donc de manière transparente. L'intérêt de ce procédé ? Il est souvent bien moins coûteux en ressource d'effectuer un classement dès la création d'un fichier plutôt qu'a chaque fois qu'on accède au contenu de celui-ci. Ensuite, si l’on veut modifier ou supprime une ligne, il suffit de changer la condition >= par != et ensuite d’ajouter la modification ou de supprimer la ligne en la remplaçant par la ligne suivante, voir les deux exemples suivant.



3.11.6. Modification d’une ligne

// Nom du fichier $fichier = "clients.txt"; // Nouveau client $cli_num =2002; $cli_nom ="HEGRATTE"; $cli_prenom ="SAM"; // Ouverture du fichier en lecture $fp = fopen($fichier,"r"); // Création d'un fichier temporaire touch("temp.txt"); // Ouverture du fichier temporaire $fp_temp = fopen("temp.txt","w+"); // Parcours du fichier while (!feof($fp)) { // On récupère une ligne $ligne = fgets($fp,1024); //Si le new num différent if (substr($ligne,0,4)!=$cli_num) //Copie de la ligne dans temp fwrite($fp_temp,$ligne); else // Si il est égale //MODIFICATION fwrite($fp_temp,$cli_num."\t\t".$cli_prenom."\t\t" .$cli_nom."\n"); } // Fermeture des fichiers fclose($fp); fclose($fp_temp); // On recopie le fichier temporaire copy("temp.txt",$fichier); // Suppression du fichier temporaire unlink("temp.txt");



3.11.7. Suppression d’une ligne

// Nom du fichier $fichier = "clients.txt"; // Numéro de la ligne à supprimer $cli_num =2002; // Ouverture du fichier en lecture $fp = fopen($fichier,"r"); // Création d'un fichier temporaire touch("temp.txt"); // Ouverture du fichier temporaire $fp_temp = fopen("temp.txt","w+"); // Parcours du fichier while (!feof($fp)) { // On récupère une ligne $ligne = fgets($fp,1024); //Si le new num différent if (substr($ligne,0,4)!=$cli_num) //Copie de la ligne dans temp fwrite($fp_temp,$ligne); } // Fermeture des fichiers fclose($fp); fclose($fp_temp); // On recopie le fichier temporaire copy("temp.txt",$fichier); // Suppression du fichier temporaire unlink("temp.txt");



3.11.8. Fonctions

Voici un récapitulatif des fonctions utiles pour manipuler vos fichiers. Cette liste n'est pas exhaustive, mais permet de réaliser pas mal de manipulation. La variable $fp renvoie toujours un identificateur de fichier obtenu lors de l'utilisation de fopen() . Fonction Description copy($source,$dest) Copie un fichier fclose($fp) Ferme un fichier feof($fp) Vérifie si pointeur en fin de fichier fgetc($fp) Lit un caractère d'un fichier

fgetcsv($fp,$len,"|") Lit une ligne et scinde la chaîne dans un tableau

fgets($fp,$len) Lit une ligne d'un fichier fgetss($fp,$len) Lit une ligne et supprime le html file("filename") Lit entièrement un fichier dans un tableau $fp=fopen("file","mode") Ouvre un fichier et retourne identificateur fpassthru($fp) Retourne la totalité d'un fichier fputs($fp,"chaine") Ecrit chaine dans un fichier fwrite($fp,"chaine") Idem que fputs readfile("filename") Lit un fichier et retourne son contenu rename("old","new") Renomme un fichier unlink("filename") Efface un fichier Et pour finir le tableau récapitulatif des modes d'ouvertures de vos fichiers. Mode Description r Ouverture en lecture seule r+ Ouverture en lecture/écriture w Ouverture en écriture seule w+ Idem que w et supprime le contenu. Fichier créé si inexistant a Ecriture seule. Pointeur en fin de fichier. Fichier créé si inexistant a+ Idem que a mais lecteur/écriture. Faites précédé le mode d'un "b" si vous traitez un fichier binaire (ex : "bw+").

3.11.9. Conclusions

Comme vous avez pu le constater, les fichiers peuvent s'avérer très utiles pour stocker des données sans pour autant faire appel à une base de données. Ceci est encore plus vrai car PHP gère très efficacement l'accès au système de fichiers grâce notamment à un grand nombre de fonctions.



3.12. Les classes

Les classes nous permettent de créer des objets avec des attributs, des constructeurs et des méthodes qui leur sont propres.

3.12.1. Création de classes

Une classe égale un fichier, les fichiers représentant des classes se nomment de la manière suivante : nom_classe.class.php



3.12.2. Utilisation de classes

Ci-dessous un script qui utilise la classe Personne. //Utilisation de la classe Personne require ('personne.class.php'); //Création d'une personne $pers1 = new Personne(10,"Jean","Nemarre",1980); //Appel de la méthode affiche $pers1->affiche(); //Utilsation de la méthode age() $son_age = $pers1->age(); echo "pers1 à : ".$son_age." ans <BR><BR>"; //Création d'une personne en 2 temps $pers2 = new Personne(); $pers2->numero = 20; $pers2->nom = "Laure"; $pers2->prenom ="Dinateur"; $pers2->date_naissance = 2000; //Appel de la méthode affiche $pers2->affiche(); //Utilsation de la méthode age() $son_age = $pers2->age(); echo "pers2 à : ".$son_age." ans <BR><BR>"; 10 Jean Nemarre Né en : 1980 pers1 à : 24 ans 20 Laure Dinateur Né en : 2000 pers2 à : 4 ans La méthode require() inclus la page demandée, dans notre cas la classe personne.class.php. Il existe une autre méthode qui permet l’inclusion de pages PHP, include(), la différence est qu’avec require() la page ne peut être inclue qu’une seul fois contrairement à include(). Pour créer un objet, on utilise la méthode new suivit du constructeur avec ou sans paramètres. $p = new Personne() ; Les paramètres du constructeur permettent d’initialiser directement tous ou une partie des attributs de la classe : $p = new Personne(10,"Jean","Nemarre",1980); On peut également initialiser ou modifier un attribut avec un accès direct. L’accès direct à un attribut ou l’appel d’une méthode de la classe se fait à l’aide du signe -> $p->numero = 55; $p->affiche();



3.13. Variables POST et GET

3.13.1. Envoyer des variables POST ou GET

Il existe plusieurs techniques pour transmettre des valeurs d’une page à une autre. Le moyen le plus connu est le formulaire, qui permet d’envoyer des paires clé/valeur avec les méthodes POST et GET. La méthode POST, envoie de manière transparente pour l’internaute les paires clé/valeur vers une autre page, alors que la méthode GET les passe en paramètre de l’URL. Prenons comme exemple un formulaire avec un champ nom et une check box sexe. L’action du formulaire est d’ouvrir la page affiche_get.php qui récupérera puis affichera le nom et le sexe choisit (voir chapitre suivant). Comme on peut le voir, le formulaire ci-dessous utilise la méthode GET et va donc utiliser les paramètres d’URL pour passé ses valeurs. Les paramètres d’URL se situent après le caractère ? d’une URL. Comme écrit précédemment, un paramètre est en fait un paire clé/valeur qui s’écrit comme suit : cle=valeur. S’il y a plusieurs paires clé/valeur à passer dans l’URL alors on les sépare avec un &.

Il existe une autre technique pour passer des paramètres d’un page à une autre, c’est la réécriture d’URL. Elle se base sur le même principe que la méthode GET du formulaire sauf que cette fois-ci on crée manuellement l’URL et ses paramètres avec un lien HTML : <a href="affiche_get.php?nom=Fallet&sexe=M">monLien </a> Ce lien ouvre lui aussi la page affiche_get.php avec deux paramètres.

3.13.2. Récupérer des variables POST ou GET

Précédemment, nous avons vu comment envoyer des variables d’une page à un autre, dans ce chapitre nous verrons comment les récupérer. PHP met à notre disposition deux méthode $_POST['cle'] et $_GET['cle'] ,comme leur nom l’indique il existe une méthode pour récupérer les variables formulaires de type POST et une autre pour les variables d’URL de type GET. Voici comment récupérer la valeur de la clé nom d’une variable d’URL :



$url_nom = $_GET['nom'];

On peut également utiliser cette page pour tester la méthode de réécriture d’URL avec le lien ci-dessous : <a href="affiche_get.php?nom=Depique&sexe=F">monLie n</a> Bonjour Madame Depique ! Pour la méthode POST, c’est le même principe, elle ne fonctionne qu’avec les envois par formulaire en mode POST bien entendu. Formulaire : <form name="formulaire_post" method="post" action=" affiche_post.php"> <input name="nom" type="text" value="Entrez vot re nom !"> <br> <input type="radio" name="sexe" value="H">Homme <br> <input type="radio" name="sexe" value="F">Femme <br> <input type="submit" name="Submit" value="Envoy er"> </form affiche_post.php : //Récupération des variables de formulaire $form_nom = $_POST['nom']; $form_sexe = $_POST['sexe']; $titre = 'Monsieur'; if($form_sexe=='F') $titre = 'Madame'; //Affiche les information echo "Bonjour ".$titre." ".$form_nom." !"; Bonjour Monsieur Fallet !

Développer en <PHP> : Les Bases de données et PHP


4.1. Introduction

Pour illustrer ce chapitre nous utiliserons une base de données MySQL. Les fonctions permettant de gérer les accès avec d’autres bases sont disponibles sur php.net [http://ch2.php.net/manual/fr/] chapitre LXVIII. MySQL Ci-dessous le script de création de la table nécessaire à la réalisation des exercices. Pour créer et gérer une base MySQL se reporter au chapitre PhpMyAdmin. # Structure de la table `personnes` DROP TABLE IF EXISTS `personnes`; CREATE TABLE `personnes` ( `personnes_numero` mediumint(9) NOT NULL auto_inc rement, `personnes_nom` mediumtext NOT NULL, `personnes_prenom` mediumtext, PRIMARY KEY (`personnes_numero`) ) TYPE=MyISAM AUTO_INCREMENT=28 ; # Contenu de la table `personnes` INSERT INTO `personnes` VALUES (1, 'Connery', 'Sean '); INSERT INTO `personnes` VALUES (2, 'Snipes', 'Wesle y'); INSERT INTO `personnes` VALUES (3, 'Anderson', 'Kev in'); INSERT INTO `personnes` VALUES (4, 'Carrere', 'Tia' ); INSERT INTO `personnes` VALUES (5, 'Keitel', 'Harve y'); INSERT INTO `personnes` VALUES (6, 'Mako', NULL); INSERT INTO `personnes` VALUES (7, 'Tagawa', 'Cary- Hiroyuki'); INSERT INTO `personnes` VALUES (8, 'Kaufman', 'Phil ip'); INSERT INTO `personnes` VALUES (9, 'Kaufman', 'Pete r'); INSERT INTO `personnes` VALUES (10, 'Crichton', 'Mi chael'); INSERT INTO `personnes` VALUES (11, 'Backes', 'Mich ael'); INSERT INTO `personnes` VALUES (12, 'Bowen', 'Micha el'); INSERT INTO `personnes` VALUES (13, 'Carradine', 'D avid'); INSERT INTO `personnes` VALUES (14, 'Chiba', 'Sonny '); INSERT INTO `personnes` VALUES (15, 'Dreyfus', 'Jul ie'); INSERT INTO `personnes` VALUES (16, 'Fox', 'Vivica A.'); INSERT INTO `personnes` VALUES (17, 'Hannah\r\n', ' Daryl'); INSERT INTO `personnes` VALUES (18, 'Kunimura', 'Ju n'); INSERT INTO `personnes` VALUES (19, 'Kuriyama', 'Ch iaki'); INSERT INTO `personnes` VALUES (20, 'Liu', 'Gordon' ); INSERT INTO `personnes` VALUES (21, 'Liu', 'Lucy'); INSERT INTO `personnes` VALUES (22, 'Madsen', 'Mich ael'); INSERT INTO `personnes` VALUES (23, 'Maro\r\n', 'Ak aji'); INSERT INTO `personnes` VALUES (24, 'Parks', 'Micha el'); INSERT INTO `personnes` VALUES (25, 'Thurman', 'Uma '); INSERT INTO `personnes` VALUES (26, 'Tarantino', 'Q uentin'); INSERT INTO `personnes` VALUES (27, 'Bender', 'Lawr ence');

4 LES BASES DE DONNÉES ET PHP



4.2. Connexion

Les informations nécessaires pour ouvrir une connexion sur une BD sont :

� Nom utilisateur [root] � Mot de passe [password] � Nom de la base de données [ma_base] � Nom du serveur où se trouve la base [localhost]

Une connexion se passe en deux temps, on se connecte tout d’abord au serveur de base de donnée puis, une fois la connexion validée, il faut choisir la base avec laquelle on veut travailler. La connexion au serveur s’effectue avec la fonction mysql_pconnect , qui retourne une connexion que l’on stoque dans une variable. $cnx = mysql_pconnect("localhost", "root", "password");

Le choix de la BD se fait avec la fonction mysql_select_db en lui passant en paramètre le nom de la base et la variable contenant la connexion que l’on vient de créer. mysql_select_db("ma_base", $cnx);

Si la connexion échoue ou que la base n’existe pas, alors PHP génèrera une erreur. Note : Si on précède une fonction PHP du caractère @, le moteur PHP va ignorer les erreurs qui pourraient se produire dans la fonction. Le @ est fortement conseillé pour les fonctions de gestion de base de données, afin de masquer les erreurs aux internautes. Exemple : @mysql_select_db("ma_base", $cnx) ;

4.3. Exécuter une requête SQL

Pour exécuter une requête, nous avons besoins de deux paramètres, la requête SQL (sans point-virgule à la fin) et une connexion. La fonction permettant d’envoyer la requête est mysql_query . $req_resultat = mysql_query("Select * from matable" , $cnx); La fonction mysql_query retourne une ressource de résultat MySQL (avec les commande SQL SELECT, SHOW, EXPLAIN et DESCIBE) ou false en cas d’erreur. Pour les autres types de requêtes SQL (Insert , Update , Delete , … ), mysql_query retourne true ou false (juste ou faux). La commande mysql_affected_rows($req_resultat) retourne le nombre de ligne affectées (Pour les commandes DELETE, INSERT, REPLACE, ou UPDATE).



4.4. Afficher le résultat d’une requête (Ressource de résultat MySQL)

Pour afficher le résultat d’une requête SQL, PHP offre différentes fonctions, nous allons étudier les plus courantes.

4.4.1. mysql_fetch_row

mysql_fetch_row(ressource result) retourne un tableau indexé numériquement, qui correspond à la prochaine ligne du résultat MySQL, ou false s’il ne reste plus de lignes. Chaque colonne est enregistrée sous la forme d’un tableau commençant à la position 0. Note : mysql_num_rows($req_resultat ) retourne le nombre de lignes d’un résultat MySQL, et mysql_num_fields($req_resultat) le nombre de champs, de colonnes. <?php //Création de la connexion $cnx = @mysql_pconnect("localhost", "root",""); //Selection de la base @mysql_select_db("bd_dvd",$cnx); //Création de la requête $req = "SELECT * FROM personnes where personnes_pre nom='Michael'"; //Exécution de la requête, et enregistrement du rés ultat dans $resultat $req_resultat = @mysql_query($req, $cnx); //Test s'il y a qqch dans le rsesultat if(@mysql_num_rows($req_resultat)>0) { //Parcours chaque ligne du résulatat while($ligne = @mysql_fetch_row($req_resultat)) { //Affiche le contenu de la première colonne, le n uméro echo "<b>Numéro : </b>".$ligne[0]; //Affiche le contenu de la deuxième colonne, le n om echo " <b>Nom : </b>".$ligne[1]; //Affiche le contenu de la troisème colonne, le p rénom echo " <b>Prénom : </b> ".$ligne[2]."<br>"; } } else //S'il n'y a plus d'enregistrements echo "Aucun résultat !!!"; ?> Numéro : 10 Nom : Crichton Prénom : Michael Numéro : 11 Nom : Backes Prénom : Michael Numéro : 12 Nom : Bowen Prénom : Michael Numéro : 22 Nom : Madsen Prénom : Michael Numéro : 24 Nom : Parks Prénom : Michael



4.4.2. mysql_fetch_array

mysql_fetch_array (resource result) retourne une ligne de résultat MySQL sous la forme d’un tableau associatif et d’un tableau indexé (comme mysql_fetch_row ). mysql_fetch_array est une fonction étendue de mysql_fetch_row . En plus d’enregistrer les données sous forme d'un tableau à indice numérique, elle peut aussi les enregistrer dans un tableau associatif, en utilisant les noms des champs comme indices.

<?php //Création de la connexion $cnx = @mysql_pconnect("localhost", "root",""); //Selection de la base @mysql_select_db("bd_dvd",$cnx); //Création de la requête $req = "SELECT * FROM personnes where personnes_pre nom='Michael'"; //Exécution de la requête, et enregistrement du rés ultat dans $resultat $req_resultat = @mysql_query($req, $cnx); //Test s'il y a qqch dans le rsesultat if(@mysql_num_rows($req_resultat)>0) { //Parcours chaque ligne du résulatat while($ligne = @mysql_fetch_array($req_resultat)) { //Affiche le contenu de colonne personnes_numero echo "<b>Numéro : </b>".$ligne['personnes_numero' ]; //Affiche le contenu de la deuxième colonne comme avec //mysql_fetch_row echo " <b>Nom : </b>".$ligne[1]; //Affiche le contenu de la colonne personnes_pren om echo " <b>Prénom : </b> ".$ligne['personnes_prenom']."<br>"; } } else //S'il n'y a plus d'enregistrements echo "Aucun résultat !!!"; ?> Numéro : 10 Nom : Crichton Prénom : Michael Numéro : 11 Nom : Backes Prénom : Michael Numéro : 12 Nom : Bowen Prénom : Michael Numéro : 22 Nom : Madsen Prénom : Michael Numéro : 24 Nom : Parks Prénom : Michael



4.4.3. mysql_fetch_object

mysql_fetch_object ( resource result) retourne un objet dont les propriétés correspondent à une ligne du résultat, ou FALSE s'il n'y a plus d'autres lignes.

<?php //Création de la connexion $cnx = @mysql_pconnect("localhost", "root",""); //Selection de la base @mysql_select_db("bd_dvd",$cnx); //Création de la requête $req = "SELECT * FROM personnes where personnes_pre nom='Michael'"; //Exécution de la requête, et enregistrement du rés ultat dans $resultat $req_resultat = @mysql_query($req, $cnx); //Test s'il y a qqch dans le rsesultat if(@mysql_num_rows($req_resultat)>0) { //Parcours chaque ligne du résulatat while($ligne = @mysql_fetch_object($req_resultat)) { //Affiche la valeur de l'attribut personnes_numer o echo "<b>Numéro : </b>".$ligne->personnes_numero; //Affiche la valeur de l'attribut personnes_nom echo " <b>Nom : </b>".$ligne->personnes_nom; //Affiche la valeur de l'attribut personnes_préno m echo " <b>Prénom : </b> ".$ligne->personnes_prenom."<br>"; } } else //S'il n'y a plus d'enregistrements echo "Aucun résultat !!!"; ?> Numéro : 10 Nom : Crichton Prénom : Michael Numéro : 11 Nom : Backes Prénom : Michael Numéro : 12 Nom : Bowen Prénom : Michael Numéro : 22 Nom : Madsen Prénom : Michael Numéro : 24 Nom : Parks Prénom : Michael



4.5. Autres requêtes

Bien entendu il est aussi possible d’envoyer des requêtes pour l’édition des données (INSERT, UPDATE, DELETE, …) et des structures (CREATE, DROP, MODIFY,…) Il suffit de créer la requête et de l’exécuter avec la fonction mysql_query($requete) .

4.5.1. INSERT, Ajout de données

<?php //Création de la connexion $cnx = @mysql_pconnect("localhost", "root",""); //Selection de la base @mysql_select_db("bd_dvd",$cnx); //Création de la requête d’insertion $req = "INSERT INTO personnes (personnes_nom, perso nnes_prenom) VALUES ('Fallet', 'Steve')"; //Exécution de la requête et test si l'ajout est ok if(@mysql_query($req, $cnx)) { //Récupération de l'identifiant généré par la dern ière requête INSERT MySQL $last_id = @mysql_insert_id($cnx); //Message de confirmation echo "Vous venez d'enregistrer une nouvelle pesonn e.<br>"; echo "Le numéro <b>".$last_id."</b> lui a été attr ibué !!!"; } else //Si l'ajout n'est pas bon { //Message d'erreur echo "Ajout impossible, erreur MySQL suivante :<br >"; //mysql_errno : retourne le numéro d'erreur de la dernière commande MySQL echo "<b> N° erreur : ".mysql_errno()."<br>"; //mysql_error : retourne le texte associé avec l'e rreur générée lors de la dernière requête echo "<b>Message d'erreur : </b>".mysql_error(); } ?> Vous venez d'enregistrer une nouvelle pesonne. Le numéro 54 lui a été attribué !!!

Si vous modifier la requête d’insertion dans le but de créer une erreur, en renommant la table personnes en perssssson par exemple, vous obtiendrez le résultat suivant : Ajout impossible, erreur MySQL suivante : N° erreur : 1146 Message d'erreur : La table 'bd_dvd.perssssson' n'existe pas



4.5.2. DELETE, Suppression de données <?php //Création de la connexion $cnx = @mysql_pconnect("localhost", "root",""); //Selection de la base @mysql_select_db("bd_dvd",$cnx); //Création de la requête de suppression de la derni ere personne enregistree $req = "DELETE FROM personnes WHERE personnes_nom = 'Fallet'"; //Exécution de la requête de suppression et test si suppression ok if(@mysql_query($req, $cnx)) { //Message de confirmation echo "Suppression de l'enregistrement OK !<br>"; //mysql_affected_rows retourne le nombre de lignes affectées lors de la dernière requête SQL MySQL echo "Nombre de champs supprimés : ".mysql_affecte d_rows(); } else { //Message d'erreur echo "Suppression impossible, erreur MySQL suivant e :<br>"; //mysql_errno : retourne le numéro d'erreur de la dernière commande MySQL echo "<b> N° erreur : ".mysql_errno()."<br>"; //mysql_error : retourne le texte associé avec l'e rreur générée lors de la dernière requête echo "<b>Message d'erreur : </b>".mysql_error(); } ?> Suppression de l'enregistrement OK ! Nombre de champs supprimés : 1

Il existe bon nombre d’autres fonctions MySQL pour PHP, n’hésitez pas à les consulter sur php.net [http://ch2.php.net/manual/fr/] chapitre LXVIII MySQL.

Développer en <PHP> : Pseudo-frames


5.1. Inclusion de fichiers

Le but des pseudo-frames est de découper notre site en plusieurs parties, chacune dans un fichier différent, puis de les regrouper dans une page. Et pour quoi faire ? Et bien afin de simplifier la mise à jour de notre site comme on le faisait avec les frames classiques (frames HTML). Imaginons que vous avez un menu sur votre site, et que ce menu est affiché sur toutes les pages de votre site. Si vous faites un copier/coller de ce menu sur toutes vos pages, cela veut dire qu’à chaque mise à jour il faudrait le corriger dans chaque page. Pour trois ou quatre pages ça va encore mais pour une vingtaine, pff, chiant non ! Avec les pseudo-frames, ce problème ne se pose plus. Vous créez un fichier menu.php, et vous l’appeler dans chaque page. Lorsque vous mettez à jour le fichier menu.php, votre menu est mis à jour sur chaque page automatiquement. menu.php //Menu du site <ul> <li> <a href="accueil.php" title="L'accueil">Accueil </a> </li> <li> <a href="news.php" title="Les News ">News</a> </li> </ul> accueil.php //Page d’accueil <div class="colonneGauche" > <?php //Nous appelons notre menu include('menu.php'); ?> </div> <div class="colonneDroite"> <p>Ici nous aurions le contenu de notre page d'ac cueil.</p> </div> news.php //Page de news <div class="colonneGauche" > <?php //Nous appelons notre menu include('menu.php'); ?> </div> <div class="colonneDroite"> <p>Ici nous aurions les news de notre site.</p> </div>

5 PSEUDO-FRAMES



Comme vous l’avez vu, le processus est le même sur les pages accueil.php et news.php , elles utilisent les deux la fonction include() qui permet d’inclure un fichier et d’exécuter son contenu. Les avantages sont que le rendu final se fera sur une page unique, et, comme nous l'avons vu plus haut, en cas de modification du menu, vous ne modifiez que menu.php. Comme c'est le même fichier qui est inclus à chaque fois, les changements se répercuteront automatiquement sur tout le site (du moins partout où vous avez inclus ce fichier).

5.2. Les pseudo-frames

5.2.1. Comment ca marche ?

Nous avons donc vu qu'il était possible et très facile d'inclure un fichier dans un autre fichier en PHP. Cela va nous ouvrir la voie des pseudos-frames. En effet imaginons que nous soyons capable de prévoir quelle page doit être incluse et quand, nous pourrions découper tout notre site en plusieurs morceaux tout en gardant une page centrale qui se chargerait d'appeler le bon morceau au bon moment. C'est ici que va nous servir le paramètre d'url. En effet c'est lui va nous permettre de savoir que quand l'utilisateur clique sur tel lien, c'est tel page qu'il faut appeler et afficher. Comment ? C'est ce que nous allons voir... Note : le code qui va suivre contient un énorme trou de sécurité. Il n'est qu'à titre d'exemple et d'apprentissage par pallier. Le code sécurisé suit, merci donc de lire le chapitre Problème de sécurité. Nous allons commencer par créer les morceaux de pages. Ici nous avons besoin de l'accueil et des news. Le menu lui aussi va être légèrement modifié, vous comprendrez plus tard pourquoi. accueil.php //Page d’accueil <p>Mettez ici simplement le contenu que vous voulez voir afficher en accueil.</p> news.php //Page de news <p>Mettez ici simplement le contenu que vous voulez voir afficher dans les news. Il y a de forte chance que cela soit du code PHP qui vous génère ces news. Cela ne pose aucun problème, procédez comme à votre habitude: requête, boucle, echo, ...</p> menu.php //Menu du site <ul> <li><a href="index.php?page=accueil" title="L'accueil">Accueil</a></li> <li><a href="index.php?page=news" title="Les News ">News</a></li> </ul> entete.php //Entête de page <b>Date</b> : <?php echo date('H:m:s, d M Y, T'); ? > <hr> pied.php //Pied de page <hr> © Fallet Steve



Nous allons maintenant créer une page index.php qui va être le noyau de notre site. Elle va se charger d'inclure tous les éléments découpés afin de construire une page complète. index.php //Page noyau <div class="entete" > <?php // Nous appelons l'entete du site include('entete.php'); ?> </div> <div class="colonneGauche" > <?php // Nous appelons notre menu include('menu.php'); ?> </div> <div class="colonneDroite"> <?php // Nous appelons le contenu central de la page include($_GET['page'].'.php'); ?> </div> <div class="pied"> <?php // Nous appelons le pied de page include('pied.php'); ?> </div> Comme vous l'avez sûrement compris, tout le problème consiste à savoir quand il faut inclure les news ou l'accueil. Notez les modifications de la page menu : les liens pointent dorénavant tous sur la page index.php , mais il y a plus. Ces derniers ont été complétés avec un paramètre page auquel nous affectons une valeur en fonction de ce que nous voulons afficher. Sur la page index.php nous récupérons ce paramètre ainsi que la valeur qu'il contient à l'aide de $_GET['page'] . Cette dernière est ce l'on appelle une variable globale. Tout comme $_POST permet de récupérer des valeurs passées par formulaires, $_GET permet de récupérer des valeurs passées dans l'URL.

5.3. Conclusion

Donc lorsque le visiteur clique sur le lien news, le paramètre page avec la valeur news est transmis à la page index.php . Sur cette dernière on récupère cette valeur. Et donc l'include qui dans le code est include($_GET['page'].'.php') va devenir dynamiquement include('news.php') et c'est donc bien la page contenant le news qui va être incluse dans la page noyau. De même pour l'accueil. Cette fois le paramètre page sera égal à accueil et donc l'include sera modifié en fonction.



5.4. Problème de sécurité

5.4.1. Le problème

Si vous avez bien lu, vous savez que le paramètre page est affiché en clair dans la barre d'adresse du navigateur. Il est donc facilement modifiable par l'utilisateur. Ce dernier peut dès lors inclure n'importe quoi dans votre page index.php ! Petit exemple, créer un fichier phpinfo.php que vous enregistrer à la racine de votre disque c:\. phpinfo.php //Page qui affiche les infos serveur <?php echo phpinfo(); ?> Ensuite entrez la valeur suivante pour le paramètre d’URL page : www.site.com ?page=c:/phpinfo

Et voilà, on peut maintenant voir toutes les informations relatives à votre serveur, avec un code plus poussé on peut faire tout ce que l’on veut. Il convient donc de tester ce que vaut ce paramètre avant d'inclure la page demandée et surtout vérifier que cela correspond bien à ce que vous permettez. Nous allons pour cela créer un tableau contenant un listing de toutes les pages que vous autorisez dans cet include. Remplacer donc le code d’index.php par le code de la page suivante.



5.4.2. Le code

index.php //Page noyau sécurisée <div class="entete" > <?php // Nous appelons l'entete du site include('entete.php'); ?> </div> <div class="colonneGauche" > <?php // Nous appelons notre menu include('menu.php'); ?> </div> <div class="colonneDroite"> <?php // On définit le tableau contenant les pages aut orisées $pageOK = array('news' => 'news.php', 'accueil' => 'accueil.php'); // On teste que le paramètre d'url existe $_GET[ 'page'] et // si il existe dans le tableau : $pageOK[$_GET[ 'page']] if (($_GET['page']) && ($pageOK[$_GET['page']])) { // Nous appelons le contenu central de la page include($pageOK[$_GET['page']]); } ?> </div> <div class="pied"> <?php // Nous appelons le pied de page include('pied.php'); ?> </div>

5.4.3. Explication

Comme vous le voyez nous avons créé un tableau associatif. Ce tableau est construit de telle manière :

� son index représente les paramètres d'inclusion autorisés dans l'url. � les valeurs représentent le chemin réel du fichier.

En l'occurrence les fichiers sont dans le même répertoire que la page index.php , mais vous auriez pu vouloir inclure un fichier dans le répertoire colGauche contenu dans le répertoire courant. Dans ce cas vous auriez dû rajouter une ligne au tableau de cette forme : 'page' => 'colGauche/fichier.php'. Ensuite nous testons l'existence de cette ligne du tableau avec comme index du tableau, le paramètre passé en url. Si la ligne existe c'est que le paramètre est autorisé, on inclut donc le fichier en utilisant la valeur de la ligne concernée du tableau.



Note : Vous l'avez sûrement remarqué, j'ai spécifié des classes dans mes divs. Elles sont là à titre purement indicatif, vous pouvez les modifier à loisir.

5.4.4. Conclusion

Voilà c'est terminé. Si vous avez bien suivi vous pouvez maintenant créer des architectures de sites plus ou moins complexes qui vous faciliteront les mises à jour et le graphisme tout en restant parfaitement accessibles (si vous respectez les standards au niveau du code HTML bien sûr). N'oubliez jamais le problème de sécurité et le moyen d'y remédier sans quoi vous pourriez rencontrer quelques surprises. Sachez également que vous pouvez utiliser plus d'un paramètre dans vos url, il suffit pour cela de les séparer par des "&" (domain.com?paramOne=1&paramTwo=2 ).

Développer en <PHP> : Les sessions


6.1. Introduction

Une session est en fait un fichier conservé sur le serveur et accessible à vos scripts en fonction d'un identifiant généré à la création. Chaque fois qu'un de vos visiteurs génère une session, un identifiant lui est attribué. Tout ce qui est dans cette session est accessible de partout à vos scripts. On comprend dès lors très vite tout l'intérêt de la chose. En effet, si chaque session est propre à un visiteur, on peut personnaliser nos scripts en fonction du visiteur, ou encore alléger nos requêtes : plutôt que d'aller chercher un pseudonyme dans la base de données sur chaque page, vous le rapatriez à l'arrivée du visiteur sur le site, vous le stockez en session et c'est de là que vous y accéderez par la suite. La session est finalement l'équivalent d'un cookie en plus sécurisé. En effet, étant stoquée sur le serveur et non chez le client, elle est plus difficile d'accès aux éventuels pirates. Mais un risque demeure, prenez donc l'habitude de ne pas y stocker des informations trop sensibles. N'oubliez pas également que la session, à la différence du cookie, n'est valable qu'un temps limité (aux alentours des 30 minutes, mais cela dépend de la configuration de votre serveur), et est automatiquement détruite à la fermeture du navigateur du visiteur. Vous pouvez enregistrer en session tout type de variable : du simple numérique au tableau en passant par la chaîne de caractères et les objets. Il existe plusieurs fonctions liées aux sessions, mais deux seulement sont essentielles à leur fonctionnement, ainsi qu'un tableau : session_start();

Cette fonction sert à démarrer une session ou à appeler la session existante. Elle doit donc être présente sur toutes les pages de votre site. A savoir que cette fonction ne tolère pas d'envoi au navigateur avant elle. Plus simplement il ne faut aucune sortie avant elle : pas de balises html, pas de echo . Prenez l'habitude de la placer au début du fichier, avant quoi que ce soit d'autre et tout se passera bien. session_destroy();

Cette fonction détruit la session en cours. Mais elle ne détruit pas les variables de sessions associées à la session courante. Nous verrons plus loin comment détruire une session complètement et proprement. $_SESSION

Il s'agit du tableau global contenant toutes les variables de sessions pour la session courante. Son utilisation est exactement identique aux tableaux habituels, voir le cas suivant.

6 LES SESSIONS



6.2. Exercice pratique

Ci-dessous vous pouvez voir le plan de navigation de l’exercice. Il se compose de trois pages, une page d’identification login.php , une page qui teste les données entrées par l’utilisateur t_login.php et une page réservée aux membres identifiés accueil.php .

Cheminement :

1. L’utilisateur entre son login et son mot de passe 2. t_login.php teste si le login et le mot de passe sont corrects

a. le login ou mot le passe est faux, on renvoie l’internaute sur login.php qui affiche un message d’erreur

3. t_login.php stoque les informations du membre dans la session et renvoie l’utilisateur vers accueil.php.

4. accueil.php affiche les informations du membre connecté a. le membre n’est pas identifié, on renvoie l’internaute sur login.php

qui affiche un message d’erreur b. le membre est de type administrateur, ce qui affiche le type du

membre.



Ci-dessous le script de génération de la table membre nécessaire pour l’exécution des exemples. //Script de création de la table membre # Structure de la table `membres` CREATE TABLE `membres` ( `membres_numero` mediumint(9) NOT NULL auto_incre ment, `membres_login` mediumtext NOT NULL, `membres_email` mediumtext NOT NULL, `membres_nom` mediumtext NOT NULL, `membres_prenom` mediumtext NOT NULL, `membres_type` mediumtext NOT NULL, `membres_pw` mediumtext NOT NULL, PRIMARY KEY (`membres_numero`), UNIQUE KEY `membres_login` (`membres_login`(50)) ) TYPE=MyISAM AUTO_INCREMENT=17 ; # Contenu de la table `membres` INSERT INTO `membres` VALUES (1, 'fallste', 'steve. [email protected]', 'Fallet', 'Steve', 'admin', '1234'); INSERT INTO `membres` VALUES (2, 'quebant', '[email protected]', 'Québatte', 'Antoine', ' visiteur', '1234'); INSERT INTO `membres` VALUES (5, 'montarn', 'arnaud .montfermecpp.ch', 'Montfermé', 'Arnaud', 'visiteur', '1234'); login.php //formulaire de connexion <?php //Récupération du message d'erreur $url_error = $_GET['error']; //Test si un message d'erreur existe et l'affiche if($url_error) echo "<b style=\"color:red\">".$url_error."</b>"; ?> <form name="form1" method="post" action="t_login.ph p"> <table width="0" border="0" align="center" cellpa dding="0" cellspacing="0"> <tr> <td>Login : </td> <td><input type="text" name="login"></td> </tr> <tr> <td>Mot de passe : </td> <td><input type="password" name="password"></ td> </tr> <tr> <td> </td> <td align="right"> <input type="submit" name="Submit" value="O K !"> </td> </tr> </table> </form>



t_login.php //page de test du login et du mot de passe <?php //On démarre la session session_start(); //On récupère les paramètres formulaire POST $form_login = $_POST['login']; $form_password = $_POST['password']; //Si le login ou le password est vide if(!$form_login || !$form_password) { //on le renvoie au formulaire avec un message d'er reur header("location: login.php?error=Login et passwor d obligatoire !"); exit; } //Création de la connexion à la BD $cnx = mysql_pconnect("localhost", "root",""); //Selection de la base mysql_select_db("bd_dvd",$cnx); //On recherche l'utilisateur. //addslashes() Ajoute des anti-slash dans une chaîn e $req = "SELECT * FROM membres WHERE membres_login = '".addslashes($form_login)."'"; //Exécution de la requête $resultat = mysql_query($req, $cnx); // On vérifie que l'utilisateur existe bien if (mysql_num_rows($resultat) > 0) //On stoque le résultat $membre = mysql_fetch_array($resultat); else // L'utilisateur n'existe pas { //on renvoie l'utilisateur au formulaire avec un m essage d'erreur header("location: login.php?error=Nom d'utilisateu r incorrect !"); exit; } //On teste si le mot de passe est correcte if($form_password != $membre['membres_pw']) { //on le renvoie au formulaire avec un message d'er reur header("location: login.php?error=Mot de passe inc orrecte !"); exit; } //On enregistre les donnée du membre dans la sessio n $_SESSION['mb_login'] = $membre['membres_login']; $_SESSION['mb_type'] = $membre['membres_type']; $_SESSION['mb_nom'] = $membre['membres_nom']; $_SESSION['mb_prenom'] = $membre['membres_prenom']; //Tout est OK, on envoie le membre sur la page d'ac cueil header("location: accueil.php"); ?>



accueil.php //page d’accueil des membres <?php //On appelle la session session_start(); //Test si le membre est identifié if(!$_SESSION['mb_login']) { //Détruit la session session_destroy(); //Renvoie l'internaute au formulaire de login header("location: login.php?error=Page réservée au x membres, identifiez vous !"); } //On affiche une phrase résumant les infos sur l'ut ilisateur courant echo 'Login : '.$_SESSION['mb_login'].'<br>'. 'Nom : '.$_SESSION['mb_nom'].'<br>'. 'Prénom : '.$_SESSION['mb_prenom'].'<br>'; //Informations disponibles que pour les admin if($_SESSION['mb_type'] == 'admin') echo 'Type : '.$_SESSION['mb_type'].'<br>'; ?>

Développer en <PHP> : EasyPHP (v. 1.6.0.0)


Une fois le logiciel téléchargé [http://www.easyphp.org], exécuter-le. Cet exécutable va installer un serveur Apache et une base de donnée MySQL.

Lorsque vous lancer EasyPHP une icône apparaît dans la barre des tâche .Faites un click droit sur cette icône puis sélectionner Démarrer. Une fois le logiciel démarré, le carré rouge formant l’icône clignote. Afin de paramétrer le logiciel, cliquer avec le bouton droit de la souris sur l’icône de la barre des tâches puis sur Administration. Votre navigateur s’ouvre avec la page d’administration du serveur Apache d’EasyPHP. Sur cette page on trouve différentes informations et utilitaires :

� Alias � Données MySQL (datadir) � PhpMyAdmin � Environnement EasyPHP

7.1. Les Alias

Un alias est le nom d’une uri, correspondant à un dossier partagé sur le serveur. Une uri, est la partie de l’url qui suit l’identifiant du serveur, par exemple dans l’url [http://www.monserveur.com/monsite/mapage.php], l’uri est /monsite/. Notre machine faisant office de serveur [http://localhost/], c’est donc un des dossiers de notre pc qu’on référence, que l’on partage. Ce dossier contiendra tous les fichiers et/ou dossiers du site internet. Nous allons donc créer un alias pour notre site, pour ce faire cliquer sur [ajouter] dans le paragraphe Vos alias : . Ensuite saisissez le nom de votre alias (p. ex : monsite) et le chemin complet du dossier auquel il se réfère (p. ex : c:/mes documents/monsite/). Ensuite l’on peut atteindre le dossier par l’intermédiaire du serveur en tapant l’adresse suivante dans le navigateur : [http://localhost/monsite/] si le dossier contient une page nommée index.php, celle-ci sera automatiquement chargée. Code de index.php : <?php echo �MA PREMIERE PAGE PHP� ; ?>

7.2. Données MySQL (datadir)

En cliquant sur [modifier], vous pouvez modifier le répertoire dans lequel sont sauvegardées les données de la base de donnée MySQL, pour plus de détails, voir le chapitre PhpMyAdmin.

7 EASYPHP (V. 1.6.0.0)

Développer en <PHP> : EasyPHP (v. 1.6.0.0)


7.3. PhpMyAdmin

PhpMyAdmin, est un utilitaire qui nous permet de créer et gérer une base de donnée MySQL, voir le chapitre PhpMyAdmin.

7.4. Environnement EasyPHP

Liste des différentes fonctions et constantes, mises à disposition par le serveur Apache et leur valeur actuelle. On peut aussi voir les paramètres de connexions de la base de données en cliquant sur [paramètres] qui affiche les informations suivantes : Serveur : "localhost" username : "root" mot de passe : "" Ce sont donc les trois paramètres indispensables pour se connecter à la base de données MySQL depuis une application PHP.

Développer en <PHP> : PHPMyAdmin (v. 2.2.6)


La page d’accueil de PHPMyAdmin se divise en deux parties. La partie de gauche vous permet d’atteindre une base de données ainsi que les différentes tables qui la composent. L’autre cadre, affiches les informations relatives à :

� MySQL : lien Accueil situé au plus haut de la frame de gauche), à une base ou à une table.

� une BD : choix dans la liste déroulante ou click sur le nom de la base

� une table : click sur le nom de la table

8.1. Nouvelle base de donnée

Charger la page d’accueil et entrez le nom de votre nouvelle BD dans le champ Créer une base de donnée. Et voilà, vous venez de créer votre base de données, simple non ! Maintenant on va pouvoir créer des tables et cela de trois manières, en tapant une requête SQL, en chargeant un fichier comportant un script SQL ou avec l’aide de PHPMyAdmin. Pour créer une table avec l’assistant, entrez le nom de votre table et le nombre de champs qu’elle comporte dans le formulaire de création de table puis [Exécuter]. L’assistant s’ouvre et il vous suffit d’entrez le nom des champs de leur choisir un type et une taille. Remarquez qu’il existe un type auto_increment dans la liste déroulante Extra, fort utile pour générer les clés primaires. Ne pas oublier de spécifier la clé primaire. Une fois les informations rentrées appuyer sur [Sauvegarder]. Si la sauvegarde s’est bien passée, vous remarquerez qu’on distingue son nom dans le cadre de gauche, juste au-dessous du nom de la BD à laquelle elle appartient.

8.2. Gestion des utilisateurs

Pour ouvrir l’assistant de gestion des utilisateurs, chargez la page d’accueil de PHPMyAdmin et cliquer sur le lien Utilisateurs et privilèges. Vous remarquerez que MySQL ne contient qu’un utilisateur root qui est l’administrateur par défaut. La première chose à faire est de lui donner un mot de passe, sans quoi n’importe qui pourrait accéder à vos BD. Pour ce faire aller à la page précédente, et cliquer Modifier pour l’utilisateur root. La page qui s’affiche nous permet de modifier le profil et les privilèges de l’utilisateur. Ajouter un mot de passe, puis [Exécuter].

8 PHPMYADMIN (V. 2.2.6)



Vous venez de modifier le mot de passe de MySQL, il faut donc l’indiquer à PHPMyAdmin, pour ce faire modifier le fichier function.inc.php qui se trouve à la racine de PHPMyAdmin [c:\program files\EasyPHPx-x\phpmyadmin]. Ouvrer ce

fichier et modifier le mot de passe de l’utilisateur root, comme illustré ci-dessous. Il est fortement conseiller de ne pas appeler l’administrateur root ou avec tout autre nom connu comme : administrateur, admin, … Nous allons maintenant créer deux utilisateurs pour notre BD, en général une BD a au moins deux utilisateurs :

� Administrateur : il gère la base de données, il peut créer, supprimer et modifier des tables, des enregistrements et des utilisateurs.

� Visiteur : il utilise les données de la base, il peur créer, supprimer et modifier des enregistrements. Il n’a jamais le droit de toucher à la structure des tables. Il se peut qu’il ait des accès restreint sur certaines tables ou champs (colonne).

L’utilisateur root est administrateur, il ne nous reste plus qu’à créer un visiteur. Pour ce faire, dans le formulaire Ajouter un utilisateur, entrez localhost comme serveur, visiteur pour le nom et un mot de passe de votre choix. Ensuite, sélectionner les privilèges : Select, Insert, Update, Delete Ces propriétés permettent de voir, d’insérer, d’éditer et de supprimer des enregistrements. L’administrateur possède par défaut tous les privilèges. Pour plus d’informations, n’hésitez pas à consulter la doc PHPMyAdmin.

8.3. Gestion des clés étrangères

Pour pouvoir gérer les clés étrangères depuis phpMyAdmin, il faut créer les tables permettant de stoquer les informations sur les différentes clés. Pour ce faire, il faut créer les tables suivantes, dans la base que vous voulez, par défaut on les crée dans la base mysql.



CREATE TABLE `pma_column_info` ( ìd` int(5) unsigned NOT NULL auto_increment, `db_name` varchar(64) NOT NULL default '', `table_name` varchar(64) NOT NULL default '', `column_name` varchar(64) NOT NULL default '', `comment` varchar(255) NOT NULL default '', `mimetype` varchar(255) NOT NULL default '', `transformation` varchar(255) NOT NULL default '' , `transformation_options` varchar(255) NOT NULL de fault '', PRIMARY KEY (ìd`), UNIQUE KEY `db_name` (`db_name`,`table_name`,`col umn_name`) ) TYPE=MyISAM COMMENT='Comments for Columns' AUTO_I NCREMENT=1 ; CREATE TABLE `pma_history` ( ìd` bigint(20) unsigned NOT NULL auto_increment, ùsername` varchar(64) NOT NULL default '', `db` varchar(64) NOT NULL default '', `table` varchar(64) NOT NULL default '', `timevalue` timestamp(14) NOT NULL, `sqlquery` text NOT NULL, PRIMARY KEY (ìd`), KEY ùsername` (ùsername`,`db`,`table`,`timevalu e`) ) TYPE=MyISAM COMMENT='SQL history' AUTO_INCREMENT= 1 ; CREATE TABLE `pma_pdf_pages` ( `db_name` varchar(64) NOT NULL default '', `page_nr` int(10) unsigned NOT NULL auto_incremen t, `page_descr` varchar(50) NOT NULL default '', PRIMARY KEY (`page_nr`), KEY `db_name` (`db_name`) ) TYPE=MyISAM COMMENT='PDF Relationpages for PMA' A UTO_INCREMENT=1 ; CREATE TABLE `pma_relation` ( `master_db` varchar(64) NOT NULL default '', `master_table` varchar(64) NOT NULL default '', `master_field` varchar(64) NOT NULL default '', `foreign_db` varchar(64) NOT NULL default '', `foreign_table` varchar(64) NOT NULL default '', `foreign_field` varchar(64) NOT NULL default '', PRIMARY KEY (`master_db`,`master_table`,`master_ field`), KEY `foreign_field` (`foreign_db`,`foreign_table` ) ) TYPE=MyISAM COMMENT='Relation table'; CREATE TABLE `pma_table_coords` ( `db_name` varchar(64) NOT NULL default '', `table_name` varchar(64) NOT NULL default '', `pdf_page_number` int(11) NOT NULL default '0', `x` float unsigned NOT NULL default '0', `y` float unsigned NOT NULL default '0', PRIMARY KEY (`db_name`,`table_name`,`pdf_page_nu mber`) ) TYPE=MyISAM COMMENT='Table coordinates for phpMyA dmin PDF output'; CREATE TABLE `pma_table_info` ( `db_name` varchar(64) NOT NULL default '', `table_name` varchar(64) NOT NULL default '', `display_field` varchar(64) NOT NULL default '', PRIMARY KEY (`db_name`,`table_name`) ) TYPE=MyISAM COMMENT='Table information for phpMyA dmin';



CREATE TABLE `pma_bookmark` ( ìd` int(11) NOT NULL auto_increment, `dbase` varchar(255) NOT NULL default '', ùser` varchar(255) NOT NULL default '', `label` varchar(255) NOT NULL default '', `query` text NOT NULL, PRIMARY KEY (ìd`) ) TYPE=MyISAM COMMENT='Bookmarks' AUTO_INCREMENT=1 ; Ensuite il faut déclarer ces tables dans le fichier confing.inc.php qui se trouve dans le dossier racine de phpMyAdmin. Pour ce faire il suffit d’initialiser les variables correspondantes comme indiqués ci-dessous. $cfg['Servers'][$i]['bookmarktable'] = 'pma_bookmar k'; $cfg['Servers'][$i]['relation'] = 'pma_relation' $cfg['Servers'][$i]['table_info'] = 'pma_table_info ' $cfg['Servers'][$i]['table_coords'] = 'pma_table_co ords' $cfg['Servers'][$i]['pdf_pages'] = 'pma_pdf_pages' $cfg['Servers'][$i]['column_info'] = 'pma_column_in fo' $cfg['Servers'][$i]['history'] = 'pma_history';

Développer en - Notions de base

Documents

Transcript of Développer en - Notions de base