Partie 3 : manipulation de bases de données mySql avec PhP

Transcription

Initiation à PhP
Séquence 3
Partie 3 : manipulation de bases de données mySql avec PhP
Si je reprends le schéma explicatif et que je le complète, voici ce que cela donne lorsqu’on utilise
une (ou plusieurs) base(s) de données pour construire dynamiquement des pages :
Notre machine
Apache
1. Requête de la forme :
http :// localhost/.../...php
6. Transmission
3. Transmission de la
Notre navigateur, qui
joue le rôle du client
web.
pour traduction Interpréteur
Serveur http.
de scripts
11. Transmission PhP.
page htlm générée
4. Envoi du formulaire contenant
de la page html
une requête de la forme : http:
//.../.../..php
générée
12. transmission de la page
2.
html générée.
5.
7.
Répertoire par
défaut (pour nous,
c’est www.)
10.
Serveur mySql
8.
9.
Base de données
Ce qui change par rapport au schéma fonctionnel de la partie 2, ce sont les étapes 7, 8, 9 et 10.
Ces étapes se produisent si le script contient des instructions de connexion à des bases de données,
et des requêtes SQL.
Étape 7 : elle n’a lieu que si le script contient des instructions de connexion à des bases de
données. L’interpréteur de script détecte une instruction de connexion à des bases de données, et la transmet au serveur mySql.
Étape 8 : le serveur sollicite les bases de données concernées et leur soumet les requêtes SQL
figurant dans le script.
Étape 9 : le serveur mySql exécute les requêtes et récupère les résultats.
Étape 10 : le serveur mySql renvoie les résultats au script. Les résultats sont renvoyés au
script et celui-ci utilise éventuellement les résultats des requêtes SQL pour construire dynamiquement une page html et la renvoyer au serveur http, qui lui-même la renvoie au navigateur du poste client.
Nous sommes ici en plein dans l’architecture client/serveur.
Pour nous initier à cette technique, nous allons travailler avec un formulaire, un script et une base
de données très simple, base que je vous invite à créer sous mysql.
8 3951 TG PA 00
167
Initiation à PhP
Séquence 3
1. Le formulaire initialement envoyé par l’internaute
Vous le connaissez, on s’en est déjà servi pour faire pas mal de tests.
Voici le code source de ce formulaire :
<html>
<head><title> Formulaire n°1 de test </title></head>
<body>
<form action = ”http://localhost/exploitationFormulaire1AvecBase.php” method
= “get”>
Entrez votre nom : <input type = “text” name = “nom” size = 20> <br>
Entrez votre âge : <input type = “text” name = “age” size = 5> <br>
<input type = “submit” value = “Envoyer”>
<input type = “reset” value = “Annuler”>
</form>
</body>
</html>
Voici ce formulaire :
2. La base de données utilisée
On va l’appeler basinscrits. Elle est constituée d’une seule table, la table inscrits, qui comporte
deux champs, nom et age, tous deux de type chaîne de caractère.
Aucun des deux champs n’est pour le moment clé primaire, le null est autorisé pour les deux.
Bref, ce n’est pas une bonne base de données telle qu’on vous apprend à les concevoir, mais pour
le moment, faire une bonne base n’est pas le sujet.
Voici le détail des champs de la table inscrits :
Champ
Type
Taille/Valeurs
Interclassement
Attributs
Null
nom
VARCHAR
20
null
age
VARCHAR
3
null
Voici la requête de création de la table inscrits :
CREATE TABLE `inscrits` ( `nom` VARCHAR( 20 ) ,`age` VARCHAR( 3 ) );
Pour accéder à une base depuis un script, il faut que le script se connecte.
8 3951 TG PA 00
168
Séquence 3
Initiation à PhP
3. Connexion à la base de données
Pour pouvoir se connecter à mysql depuis un script, mysql doit être lancé.
Pour se connecter, à l’aide d’un script php, à une base de données mysql, on a deux possibilités :
– créer une source de données odbc et se connecter à la base en utilisant les fonctions php
de connexion aux sources de données odbc ;
– se connecter directement à mysql en utilisant les fonctions php de connexion spécifiques
à mysql.
3A. Connexion à la base de données via une source de données
odbc
Cette première technique est intéressante car elle est transposable à tout autre SGBD comme
interbase, access, sqlqerver…
Avec odbc, on va rajouter notre base dans les sources de données (si vous ne savez plus faire ça, je
vous renvoie à la séquence sur mySql, paragraphe 3B. Création d’une source de données).
La source de données doit être créée sur la machine hébergeant le serveur http.
Voici ce que je saisis pour créer la source de données ODBC :
Pour plus de confort, pour le moment, choisissez un utilisateur qui a tous les droits.
Pour se connecter à une source de données odbc, on utilise la fonction odbc_connect.
Cette fonction prend 3 paramètres : le nom de la source odbc, le nom d’utilisateur, son mot de
passe.
Notre script va s’appeler exploitationFormulaire1AvecBase.php.
<?
$connexion = odbc_connect(”lienSurBasinscrits“,“root“,“root“);
if ($connexion)
8 3951 TG PA 00
169
Séquence 3
Initiation à PhP
{
print ”connexion réussie“;
}
else print ”Echec de la connexion“;
// Lʼinstruction de fermeture de connexion ci-dessous est optionnelle
odbc_close($connexion);
?>
Ce script très simple tente de se connecter à la base basinscrits via la source de données odbc
lienSurBasinscrits qu’on vient de créer, en indiquant que c’est l’utilisateur root ayant le mot de
passe root qui demande cette connexion.
Si la connexion échoue, la fonction renvoie la valeur 0 et la variable $connexion vaut donc 0.
Si la connexion réussit, la variable $connexion a pour valeur un identifiant de connexion délivré
par le serveur mySql.
L’identifiant de connexion retourné par cette fonction est nécessaire pour toutes les autres fonctions ODBC.
Ensuite, selon la valeur de la variable $connexion, le script crée une page à la volée, qui indique
si la connexion a réussi ou non.
Si la connexion à la source de données odbc a réussi, on la referme à l’aide de l’instruction odbc_
close($connexion);.
L’instruction de fermeture de la connexion est optionnelle, la connexion est automatiquement
fermée à la fin du script.
Pour tester ça, ouvrez le formulaire html, cliquez sur Envoyer.
3B. Connexion directe à mySql, sans passer par la source de données odbc
Cette fois, le script est le suivant :
<?
$connexion = mysql_connect(”localhost“, ”root“, ”root“);
if ($connexion)
{
print ”connexion réussie“;
}
// Optionnelle aussi
mysql_close($connexion);
?>
Le principe de cette fonction mysql_connect est exactement le même que celui de la fonction
odbc_connect, c’est pour cela que les deux scripts sont si ressemblants.
De même, la fonction mysql_close a pour effet de fermer la connexion au serveur mysql.
8 3951 TG PA 00
170
Séquence 3
Initiation à PhP
Alors qu’avec odbc_connect, on se connecte à une source de données, avec mysql_connect, on se
connecte au serveur mysql, et ce, sans spécifier quelle est la base de données concernée.
Remarque
Ne pas préciser quelle base de données est concernée par la connexion signifie qu’il faudra bien
préciser à un autre moment quelle base est concernée par les opérations, mais cela signifie aussi
qu’avec un seul identifiant de connexion, on peut manipuler plusieurs bases, ce qui n’est pas le
cas avec une connexion via odbc.
Autre remarque
Si, dans mysql, vous avez créé un utilisateur sans mot de passe (en laissant le mot de passe vide lors
de la création de l’utilisateur), alors, l’instruction de connexion passe, en guise de mot de passe,
une chaîne de caractères vide à la fonction de connexion.
Exemple : en supposant que vos ayez créé un utilisateur machin sans mot de passe, l’instruction
de connexion est mysql_connect(”localhost“, ”machin“, ”“); (”“ : deux doubles quottes qui se
suivent).
Passons à la suite des manips.
4. Manipulation de la base de données
Une fois la connexion établie, on peut exécuter des requêtes SQL.
4A. Insertion des données saisies par l’internaute
On va, par une requête, rajouter dans la table inscrits les données que l’internaute a saisies dans
les champs de formulaire nom et age.
4A1. Mise en jambes
Mais avant de faire ça, on va commencer simple : on va insérer la ligne (‘truc’,’42’) dans la table
inscrits.
La première version de ce script se connecte à la base via odbc :
<?
if ($connexion)
{print ”Connexion réussie <br>“;
// Si la connexion est réussie, alors on envoie la requête dʼinsertion
$resultatRequete = odbc_do($connexion,“insert into inscrits (nom, age)
values(ʻtrucʼ,ʼ42ʼ)“);
// si la requête sʼest exécutée correctement
if ($resultatRequete) print ”Votre saisie a été prise en compte“;
else print ”Impossible de prendre vos données en compte“;
}
?>
8 3951 TG PA 00
171
Séquence 3
Initiation à PhP
On exécute des requêtes sql sur la base de données en utilisant la fonction odbc_do (on peut aussi
utiliser la fonction odbc_exec, qui est un synonyme de odbc_do).
Comme je vous l’ai annoncé tout à l’heure, on passe en paramètres à cette fonction :
– l’identifiant de connexion ;
– le texte de la requête. À ce propos, attention à ne pas encadrer les données à insérer de
doubles quottes si le texte de votre requête est lui-même entre doubles quottes, sinon
vous avez une erreur.
La fonction odbc_do (ou odbc_exec) renvoie une valeur booléenne fausse si la requête n’a pas
abouti, sinon, elle retourne un identifiant de résultat odbc.
C’est pour cela qu’on peut tester si la requête s’est bien exécutée, à l’aide du test if ($resultatRequete).
Pour tester votre script, il vous suffit de cliquer sur le bouton Envoyer de votre formulaire.
Ensuite, allez voir dans la base basinscrits si les données ont bien été rajoutées.
Maintenant, on va faire la version du script qui utilise la connexion directe à mySql. Observez bien
les différences avec le script ci-dessus :
<?
if ($connexion)
$resultatRequete = mysql_db_query(”basinscrits“,“insert into inscrits
(nom, age) values(ʻtrucʼ,ʼ42ʼ)“, $connexion);
if ($resultatRequete) print ”Votre saisie a été prise en compte ”;
}
?>
Voilà, quand on se connecte au serveur mysql avec la fonction mysql_connect, c’est lors de l’exécution de la requête qu’on passe, en paramètre, le nom de la base concernée.
Remarque
Dans les deux scripts ci-dessus, vous pouvez remplacer les instructions :
// première version, connexion à la source odbc
$resultatRequete = odbc_do($connexion,“insert into inscrits (nom, age)
values(ʻtrucʼ,ʼ42ʼ)“);
et :
// deuxième version, connexion directe à mysql
$resultatRequete = mysql_db_query(”basinscrits“,“insert into inscrits (nom,
age) values(ʻtrucʼ,ʼ42ʼ)“, $connexion);
8 3951 TG PA 00
172
Séquence 3
Initiation à PhP
par :
// première version
$requete = ”insert into inscrits (nom, age) values(ʻtrucʼ,ʼ42ʼ)“;
$resultatRequete = odbc_do($connexion, $requete);
et par :
// deuxième version
$requete = ”insert into inscrits (nom, age) values(ʻtrucʼ,ʼ42ʼ)“;
$resultatRequete = mysql_db_query(”basinscrits“, $requete, $connexion);
Dans ces deux derniers cas, au lieu de passer en paramètre la chaîne de caractères contenant le
texte de la requête sql, on l’affecte à une variable, et c’est cette variable que l’on passe en paramètre à la fonction.
Tiens, juste par curiosité, changez la requête sql dans un des deux scripts, ou dans les deux, en
enlevant les quottes autour de truc et de 42, juste pour voir…
$requete = ”insert into inscrits (nom, age) values(truc,42)”;
Et testez à nouveau… Cette fois, la connexion réussit, mais les données ne sont pas prises en
compte, problème de type, probablement…
4A2. Maintenant, la requête avec les données saisies par l’internaute
On reprend les deux scripts précédents et on les modifie de manière à ce que ce qui soit inséré
dans la base, soient les informations saisies par l’internaute dans les zones de saisie du formulaire.
En fait, c’est juste le texte de la requête qui change. Il doit être construit par concaténation entre
des parties fixes de la requête, et des parties qui changent.
Par exemple, si je saisis fred et 42 dans les champs nom et age, ma requête doit être :
$requete = ”insert into inscrits (nom, age) values(ʻfredʼ, ʻ42ʼ)“;
ou bien :
$requete = ʻinsert into inscrits (nom, age) values(”fred“, ”42“)ʼ;
mais en aucun cas, elle ne peut être :
$requete = ʻinsert into inscrits (nom, age) values(fred, 42)ʼ;
car on a bien vu dans le dernier test du paragraphe précédent que ça ne fonctionnait pas.
Commençons par essayer le texte de requête suivant :
$requete = ʻinsert into inscrits (nom, age)
values($_REQUEST[”nom“], $_REQUEST[”age“])ʼ;
On a à nouveau notre message :
Connexion réussie
Impossible de prendre vos données en compte
Bon, c’est parce que quand on fait ça, on lui passe les valeurs saisies mais elles ne sont pas encadrées par des quottes, et comme dans la base, les champs nom et age sont déclarés comme étant
de type chaîne de caractères, mysql n’en veut pas dans la table inscrits.
8 3951 TG PA 00
173
Séquence 3
Initiation à PhP
Pour php, le type d’une donnée dépend de sa valeur et du contexte, mais pas pour mysql.
Pour mysql, une chaîne de caractère, c’est un truc encadré par des quottes.
Il faut donc qu’on encadre chaque valeur issue de $_REQUEST avec des quottes.
Ce qu’on veut, si, par exemple, l’internaute a saisi lulu et 15, c’est que, une fois qu’on remplace
$_REQUEST[‘nom’] par lulu et $_REQUEST[‘age’] par 15, le texte de la requête soit ‘insert into
inscrits (nom, age) values(”lulu“, ”15“)’
Donc, il faut que dans le texte de la requête, on concatène des doubles quottes aux variables
$_REQUEST[‘nom’] et $_REQUEST[‘age’].
Voilà le résultat :
values(”ʼ.$_REQUEST[ʻnomʼ].ʼ“, ”ʼ.$_REQUEST[ʻageʼ].ʼ“)ʼ;
Dans la requête ci-dessus, la première fois que vous voyez “ ’, il s’agit d’une double puis d’une
simple quotte ; la deuxième fois, c’est une simple puis une double quotte, ensuite, c’est à nouveau
une double puis une simple quotte, et enfin, une simple puis une double quotte.
Vous pouvez tester, ça fonctionne. Mais ça veut dire aussi que pour construire ce type de requête,
il faut être à l’aise avec la concaténation.
Moi, maintenant, je me demande comment il faut rédiger le texte de la requête pour une donnée
de type numérique.
Alors je vous propose de modifier, dans la table inscrits, le type de la donnée age, que l’on va
mettre en numérique. Moi, je l’ai modifié en choisissant le type int.
Je garde le script avec la dernière version de la requête, et je teste.
Ça marche pas.
Ce qu’il faut, c’est faire en sorte que dans la requête, la donnée $_REQUEST[‘age’] ne soit plus
encadrée par des quottes quand on la remplace par sa valeur effective.
values(”ʼ.$_REQUEST[ʻnomʼ].ʼ“, ʻ.$_REQUEST[ʻageʼ].ʼ)ʼ;
Testez. Ça marche.
Voilà. Dans les deux requêtes précédentes, les parties variables du texte de la requête sont les
valeurs des données $_REQUEST[‘nom’] et $_REQUEST[‘age’].
Alors maintenant qu’on a inséré des données dans notre table, on va pouvoir faire des requêtes
de consultation. On a été très laxiste quand on a créé notre table inscrits : les enregistrements
n’ont pas de clé primaire, les doublons sont autorisés et les valeurs null aussi.
Un prof de MCD et de base de données s’arracherait le cheveu devant une telle table. Mais le but,
c’est de faire plein de tests, et plusieurs fois les mêmes, alors c’est plus facile avec une table aussi
bancale que la table inscrits.
Remarque importante
Toutes les requêtes ayant pour effet de modifier le contenu (update, delete….) ou la structure de
la base de données (alter, drop…) se construisent sur le même modèle que les requêtes insert.
8 3951 TG PA 00
174
Séquence 3
Initiation à PhP
4A3. En guise de conclusion à propos des requêtes de modification
Il y a tout de même un type particulier de requête dont il faut que je vous parle, ce sont les requêtes qui ne s’adressent à aucune base particulière, mais directement au serveur de base de données,
comme les requêtes demandant au serveur mysql de créer une nouvelle base de données.
Pour ces requêtes là, on n’utilise pas la fonction mysql_db__query, puisqu’on ne peut pas spécifier
une base de données particulière, mais mysql_query.
Exemple :
$requete = ”create database nouvelleBase;“;
mysql_query($requete, $connexion);
Ensuite, après avoir créé la base, on peut utiliser mysql_db_query pour toutes les autres requêtes.
L’équivalent n’est pas disponible avec odbc, puisqu’avec odbc, on se connecte à une source de
données, ce qui signifie que cette source existe déjà.
Remarque
Si on ne veut pas, à chaque requête, spécifier en paramètre quelle base elle concerne, en utilisant
mysql_db_query, on peut utiliser mysql_query pour ces requêtes, mais il faut alors, avant l’exécution de ces requêtes, spécifier quelle base est concernée à l’aide de l’instruction mysql_select_db.
Exemple : en supposant qu’on a créé la base de données nouvelleBase, et que maintenant, on
veuille utiliser la base (pour y ajouter des tables, par exemple), alors, avant d’écrire ces requêtes,
il faut écrire l’instruction mysql_select_db («nouvelleBase», $connexion);
Passons maintenant aux requêtes de consultation. Vous allez comprendre pourquoi je les aborde
après les requêtes de mise à jour : l’exploitation des données issues des requêtes de consultation
nécessite des structures de programmation un peu plus complexes que pour les requêtes abordées
ci-dessus.
4B. Consultation
Comme ci-dessus, pour consulter notre base de données, on va se contenter de modifier le texte
de notre requête.
Ceci fait que notre formulaire ne sert qu’à lancer la requête.
Si j’étais courageuse, je vous ferais modifier votre formulaire, de manière à ce qu’il soit cohérent
avec le fait qu’on consulte la base sans rien y insérer. Mais tout de suite, là, maintenant, je suis
prise de paresse. Vous, par contre, faites-le si vous voulez.
Lorsqu’on exécute une requête de consultation (une requête commençant par select), il y a généralement un ensemble de résultats qui est renvoyé.
Jusqu’à présent, lorsque vous faisiez une requête select, vous voyiez directement le résultat s’afficher à l’écran, parce que le logiciel que vous utilisez, dans ce cas, est client du SGBD, et se charge
d’afficher les résultats de requêtes que le serveur de base de données lui renvoie.
Ici, ça ne va pas fonctionner comme ça car c’est notre script qui est client de mysql. Lorsqu’on
exécute une requête select dans un script, le résultat est renvoyé au script, et c’est au script de se
charger d’afficher ce résultat, à l’aide de commandes spéciales.
8 3951 TG PA 00
175
Séquence 3
Initiation à PhP
4B1. Allez, on se fait une requête select * from maTable
Je reprends une des deux versions du script et je modifie sa requête :
<?
if ($connexion)
$requete = ”select * from inscrits“;
$resultatRequete = mysql_db_query(”basinscrits“,$requete, $connexion);
if ($resultatRequete)
{
print ”Votre saisie a été prise en compte ”;
// ici, il faut rajouter des instructions pour exploiter le résultat de la requête
// car pour le moment, même si la requête sʼexécute, le script
nʼaffiche pas son
// résultat
}
}
?>
Pour exploiter le résultat d’une requête de consultation, comme il se peut que ce résultat contienne plusieurs lignes, on doit faire une boucle.
Comme il se peut aussi que le résultat de la requête soit vide, on doit faire une boucle while.
En fait, le principe pour exploiter le résultat d’une requête est celui des curseurs, que vous avez
peut-être déjà vu au cours de vos formations sur les bases de données.
Pour ceux qui ne voient pas du tout de quoi je peux bien parler, le résultat d’une requête (dans
notre cas, ce résultat s’appelle $resultatRequete) se parcourt séquentiellement comme un fichier
de données, comme une collection de données du même type, comme un tableau… : tant qu’on
n’est pas à la fin, on lit le suivant.
Voici, ci-dessous, un exemple d’instruction permettant d’afficher, pour chaque ligne du résultat,
les deux champs de la table inscrits…
// Cette instruction est à mettre à la place des commentaires commençant
par :
// ici, il faut rajouter des instructions…
while($ligneResultat = mysql_fetch_array($resultatRequete))
print $ligneResultat[0].“, ”.$ligneResultat [1].“,<br> ”;
On peut écrire cette boucle while de façon moins concentrée, mais aussi plus lisible. La syntaxe
ci-dessous ressemble plus à ce que vous avez l’habitude d’écrire, mais les deux syntaxes sont totalement équivalentes.
8 3951 TG PA 00
176
Initiation à PhP
Séquence 3
Je vous ai rajouté des commentaires pour expliquer la structure.
…
// Lecture avancée du premier enregistrement issu du résultat de la
// requête
$ligneResultat = mysql_fetch_array($resultatRequete);
// Si on a pu lire un enregistrement, on entre dans le while
while($ligneResultat)
{
// Tentative de lecture de lʼenregistrement suivant
$ligneResultat = mysql_fetch_array($resultatRequete);
}
}
…
La fonction mysql_fetch_array, que fait-elle ?
Elle lit la ligne courante (c’est à dire le ”n-uplet“ ou encore l’enregistrement courant) dans $resultatRequete et l’affecte à la variable $ligneResultat, qui contient donc, à chaque tour de boucle,
la ligne courante issue du résultat de la requête.
Le fait d’affecter une ligne de table à la variable $ligneResultat fait que cette variable devient un
tableau à une dimension, si la requête d’origine demande l’affichage de plusieurs champs. Dans
ce cas, l’indice du premier élément de $resultatRequete est 0 (zéro).
À chaque indice, on trouve la valeur d’un champ de table. Pour notre part, la table inscrits contient deux champs.
Donc, $ligneResultat contient deux éléments, un à l’indice zéro, l’autre à l’indice un, que l’on
affiche à l’aide de l’instruction :
print $ligneResultat[0].“, ”.$ ligneResultat [1].“,<br> ”;
Remarque
On pourrait aussi faire une boucle pour afficher les champs d’une ligne, suivant le morceau d’algo
suivant…
Pour i de 0 à 1
Faire Afficher $ligneResultat[i]
finPour
La fonction mysql_fetch_array, si elle n’arrive pas à affecter la valeur de la ligne courante à $ligneResultat, lui affecte une valeur booléenne fausse.
Si c’est le cas, on ne « re-rentre » pas dans le while.
La variable $ligneResultat peut être fausse :
– soit parce que le résultat de la requête est vide (dans ce cas, on n’entre jamais dans le
while) ;
– soit parce qu’on a lu le dernier enregistrement du résultat de la requête lors de la boucle
précédente.
8 3951 TG PA 00
177
Initiation à PhP
Séquence 3
Si mysql_fetch_array renvoie vrai, c’est qu’elle a pu lire l’enregistrement qui suit l’enregistrement
courant, qui devient à son tour l’enregistrement courant, que l’on affiche à l’intérieur du while,
etc. etc. À chaque lecture dans $resultatRequete , c’est l’enregistrement suivant qui est lu, jusqu’à
ce qu’on se trouve à la fin du résultat de la requête.
Et si le script s’est connecté en utilisant une connexion odbc ?
La fonction odbc_fetch_array est l’équivalent de la fonction mysql_fetch_array, sauf que si on
l’utilise, la variable $ligneResultat est un tableau de hachage dont les clés sont les noms des
champs spécifiés dans la requête.
Voici ci-dessous ce que ça donne :
<?
if ($connexion)
{print ”Connexion réussie<br>“;
$requete = ”select * from inscrits“;
{
print ”Votre saisie a été prise en compte <br> ”;
while($ligneResultat = odbc_fetch_array($resultatRequete))
print $ligneResultat[ʻnomʼ].“, ”.$ligneResultat[ʻageʼ].“<br>“ ;
}
}
?>
Remarque
Si vous souhaitez faire en sorte que $ligneResultat soit un tableau à indice numérique, vous pouvez, au lieu d’utiliser la fonction odbc_fetch_array, choisir d’utiliser la fonction odbc_fetch_into,
comme vous le montre le bout de code ci-dessous :
…
while(odbc_fetch_into($resultatRequete, $ligneResultat))
…
4B2. Une requête construite à partir d’une saisie de l’internaute
Ce qu’on veut, c’est que la requête nous retourne uniquement les enregistrements de la table
inscrits tels que le nom soit le nom saisi par l’internaute dans la zone nom du formulaire, ou tels
que l’âge soit l’âge saisi par l’internaute dans la zone age du formulaire.
Exemple : si l’internaute saisit 42, la requête sql doit être :
select * from inscrits where age = 42
8 3951 TG PA 00
178
Séquence 3
Initiation à PhP
Les deux requêtes ci-dessous fonctionnent, que la connexion se fasse via odbc ou directement à
mysql. Testez-les l’une après l’autre.
// attention : dans la requête ci-dessous, ”ʼ : une double puis une simple
quotte,
// et ʻ“ʼ : une simple, une double, une simple quotte
$requete = ʻselect * from inscrits where age = ”ʼ.$_REQUEST[”age“].ʼ“ʼ;
$requete = ʻselect * from inscrits where age = ʻ.$_REQUEST[”age“];
Vous pouvez remarquer que bien que, dans la table inscrits, le champ age soit de type numérique,
on peut l’encadrer dans la requête par des quottes, ça fonctionne.
Autre exemple : ce qu’on veut maintenant, c’est que les enregistrements renvoyés soient tels que
le nom soit le nom saisi par l’internaute dans la zone nom du formulaire.
// Attention : dans les requêtes ci-dessous, ”ʼ : une double puis une simple
quotte,
// et ʻ“ʼ : une simple, une double, une simple quotte
$requete = ʻselect * from inscrits where nom = ”ʼ.$_REQUEST[”nom“].ʼ“ʼ;
// celle-là fonctionne aussi
$requete = ʻselect * from inscrits where nom = ”ʼ.$_REQUEST[ʻnomʼ].ʼ“ʼ;
// celles-là aussi
// Attention, ci-dessous, ʻ“ : une simple puis une double quotte,
// ”ʼ“ : une double, une simple, une double quotte
$requete = ”select * from inscrits where nom = ʻ“.$_REQUEST[ʻnomʼ].“ʼ“;
$requete = ”select * from inscrits where nom = ʻ“.$_REQUEST[”nom“].“ʼ“;
Maintenant qu’on a des requêtes qui fonctionnent, essayons de voir dans quel cas ça ne fonctionne pas :
//Celle-ci ne fonctionne pas :
$requete = ʻselect * from inscrits where nom =ʼ.$_REQUEST[ʻnomʼ];
Dans le cas de la requête ci-dessus, on a un intéressant message d’erreur qui s’affiche :
Connexion réussie
Warning: odbc_do(): SQL error: [MySQL][ODBC 3.51 Driver][mysqld-4.1.9max]Champ ʻfredʼ inconnu dans where clause, SQL state S0022 in SQLExecDirect
in c:\program files\easyphp1-8\www\exploitationformulaire1avecbaseodbc.php on
line 6
Impossible de prendre vos données en compte
En fait, l’erreur vient du fait que je n’ai pas fait en sorte que la valeur contenue dans $_
REQUEST[‘nom’] soit encadrée par des quottes.
Si, par exemple, je saisis truc dans mon champ de formulaire, cela donne la requête select * from
inscrits where nom = truc.
Mysql croit donc qu’on est en train de faire une jointure entre le champ nom de la table inscrits et
un autre champ de cette table, qui s’appellerait truc. Comme il ne trouve pas ce champ truc dans
la table inscrits, il nous le signale.
8 3951 TG PA 00
179
Séquence 3
Initiation à PhP
Remarque
Cette erreur nous montre comment construire dynamiquement une jointure dans une requête
sql !!
4B3. Habiller le résultat des requêtes de consultation
Pour le moment, les résultats s’affichent mais ne sont pas très présentables.
On peut, au fur et à mesure qu’on traite chaque enregistrement, construire des tableaux, des
listes, ou tout autre élément de page html, à l’aide de l’instruction print, avec des instructions du
genre de celles contenues dans le script ci-dessous, que je vous invite à tester :
<?
if ($connexion)
{print ”Connexion réussie<br>“;
$requete = ”select * from inscrits where nom = ʻ“.$_REQUEST[”nom“].“ʼ“;
{
// on va compter le nombre de résultats
$nb=0;
print ”<H1>Liste des résultats</H1> <br>“;
print ʻ<P><TABLE BORDER=2 WIDTH=“75%“>ʼ;
print ”<TR><TH>NOM</TH><TH>AGE</TH></TR>“;
while(odbc_fetch_into($resultatRequete,$ligneResultat)) {
print ”<TR><TD>“. $ligneResultat[0].“ </TD><TD>“. $ligneResultat[1].
”</TD></TR>“;
$nb++;
}
print ”</TABLE><P>“;
print ”Il y a ”.$nb.“ résultats.“;
}
}
?>
Remarque
On peut parvenir à un résultat mis en forme de façon à peu près équivalente à la précédente à
l’aide de la fonction odbc_result_all, comme dans l’exemple de code suivant :
8 3951 TG PA 00
180
Initiation à PhP
Séquence 3
…
{
print ”<H1>Liste des résultats</H1> <br>“;
odbc_result_all($resultatRequete,“border=2“);
}
…
Mais dans ce cas, on ne peut pas compter combien de résultats on affiche… Il existe probablement
une fonction qui sait nous dire combien d’éléments contient l’ensemble résultat.
Note : l’équivalent de odbc_result_all n’existe pas si on s’est directement connecté à mysql sans
passer par odbc.
Bon, on a vu l’essentiel.
Avec toutes les connaissances acquises au cours de ce chapitre, je vous propose ci-dessous de mettre tout seuls les « mains dans le cambouis » avec quelques idées pour prolonger cette initiation.
5. Quelques idées pour prolonger cette initiation
Remarque importante
Il existe tout un tas de fonctions que l’on peut utiliser dans un script relativement aux bases de
données.
Je vous invite à consulter la documentation sur ces fonctions aux liens suivants (documentation
officielle) :
http://www.php.net/manual/fr/ref.mysql.php, pour les fonctions utilisables lorsqu’on s’est
directement connecté à mysql.
http://www.php.net/manual/fr/ref.uodbc.php, pour les fonctions utilisables lorsqu’on s’est
connecté à mysql via une source odbc.
Un exemple de fonction bien utile : la fonction mysql_affected_rows, qui, suite à l’exécution
d’une requête sql, retourne le nombre de lignes concernées par la requête, ce qui permet de faire
des tests.
Quels tests ? On peut, par exemple, tester si le nombre de lignes concernées par une requête est
différent de zéro. Si c’est le cas, on effectue le traitement d’affichage du résultat de la requête,
sinon, on indique par un message que la requête n’a pas de résultat.
On peut aussi afficher, dans la page html générée dynamiquement, combien la requête nous a
fourni de résultats.
8 3951 TG PA 00
181
Séquence 3
Initiation à PhP
Voici quelques idées pour prolonger cette initiation
• Mettre le champ nom en clé primaire, prévoir un test en cas de tentative d’insertion d’une ligne
où la clé primaire est déjà dans la table inscrits, ça donne un bout de code du genre :
…
// On suppose que lʼinternaute a saisi un nom dans le champ de formulaire
nom, et un âge
// dans le champ de formulaire age
values(” ʻ.$_REQUEST[ʻnomʼ].ʼ ”, ʻ.$_REQUEST[ʻageʼ].ʼ)ʼ;
else print ”Impossible de rajouter cette information <br> ”;
…
• Faire des requêtes update sur des enregistrements figurant déjà dans la table inscrits.
• Changer l’instruction de connexion, en indiquant un utilisateur n’ayant pas les mêmes droits que
root (attention, dans ce cas, à bien adapter la source odbc).
• Rajouter une table et faire des requête avec des jointures.
• Reprendre nos tentatives de création de page comportant plusieurs formulaires et donc plusieurs instructions submit, pour voir si les deux instructions submit sont bien prises en compte.
• Rendre variables les valeurs de l’instruction de connexion : faire saisir à l’utilisateur son nom et
son mot de passe dans un premier formulaire.
• Dans un second script, construire l’instruction de connexion à l’aide des valeurs saisies par l’internaute dans le premier formulaire.
• Faire un test ayant pour rôle d’autoriser la connexion seulement si l’utilisateur a des droits sur
la base. S’il a les droits, effectuer les traitements et renvoyer le résultat, sinon, lui afficher un
message lui indiquant qu’il n’est pas autorisé à demander que ces traitements soient effectués,
• Gérer les erreurs se produisant lors de l’exécution des requêtes SQL, afin d’éviter l’écriture des
messages d’erreur dans la page html renvoyée à l’internaute.
Ce type d’erreur peut se produire quand l’internaute n’est pas autorisé à demander le traitement effectué par la requête.
Pour gérer ces erreurs, vous pouvez utiliser l’opérateur de gestion des erreurs que je vous avais
présenté dans la partie 1 de cette séquence.
Vous pouvez aussi chercher des fonctions php de gestion des erreurs en allant sur les liens que
je vous ai fournis ci-dessus.
• Continuer (et terminer) le site qu’on avait entrepris lors de la séquence javascript.
D’un site de présentation, il peut maintenant devenir un site commercial. Vous pouvez créer une
base de données où vous stockerez les internautes ayant rempli le formulaire d’inscription. Vous
pouvez aussi stocker quels sont ses artistes préférés.
Vous pouvez aussi mettre dans une table vos disques, films, livres, et leur affecter un prix.
Vous pouvez également permettre aux internautes de consulter ce catalogue et de passer des
commandes, ce qui nécessitera que vous gériez votre stock de produits à vendre (histoire de ne
pas vendre 2 fois le même CD à deux internautes différents).
8 3951 TG PA 00
182
Séquence 3
Initiation à PhP
Vous pouvez aussi confirmer la commande de l’internaute par envoi automatique d’un mail (il y
a des fonctions php spéciales pour générer et envoyer automatiquement des mails).
Etc. etc.
Vous avez toutes les connaissances techniques requises pour réaliser ces prolongements.
N’hésitez pas également à chercher des exemples sur le net pour vous en inspirer, car ce cours,
bien que déjà volumineux, reste très incomplet.
Commencez par vous inspirer d’exemples les plus simples possibles, car vous avez besoin de comprendre le code source des scripts de ces exemples.
Voilà, maintenant, on va attaquer la partie 4 de ce support, celle où on mélange du php, du sql,
du javascript. Je vais en faire une partie microscopique avec deux tous petits exemples, car maintenant que vous savez comment on construit une page html à partir d’un script php, l’écriture
d’instructions javascript se fait tout à fait de la même façon.
Partie 4 : on ajoute du javascript, on secoue, et on déguste
Dans cette partie 4, il s’agit d’intégrer du javascript dans les scripts php, afin que le javascript soit
envoyé dans le code source de la page générée dynamiquement par le script.
Trophacylle !!
Les instructions javascript, tout comme le html peuvent :
– s’écrire directement dans le code source du script ;
– s’écrire dans le code source de la page créée dynamiquement.
On peut, dans les deux cas, écrire des instructions javascript de manière conditionnelle : si on est
dans telle situation, alors on écrit telle instruction javascript, sinon, on écrit telle autre instruction
javascript.
Nous allons essentiellement travailler à partir du même exemple initial, que nous ferons évoluer
pour s’initier aux différentes possibilités.
1. Exemple 1 : du code javascript « en dur » dans le script
Voici un premier exemple. Il est intéressant pour plusieurs raisons :
– c’est un « deux en un » : il fait à la fois office de formulaire initial, et de script d’exploitation ;
– il contient des instructions javascript écrites directement dans le code source de la page, sans
passer par du php.
La première fois que l’internaute demande l’affichage du formulaire, dans la barre d’adresse de
son navigateur, il tape : http ://localhost/scriptPartie4.php. Un formulaire vierge, à remplir, lui est
alors envoyé, généré par le script scriptPartie4.php.
Le script est écrit de manière à savoir tenir compte du fait que l’internaute l’utilise, dans un premier temps, comme un formulaire.
8 3951 TG PA 00
183
Séquence 3
Initiation à PhP
J’ai commenté le code afin que vous compreniez comment ça fonctionne :
<html>
<head>
<title> Demande de renseignements </title>
<script language = javascript>
function envoi(form)
{
form.submit();
}
</script>
</head>
<?
// cʼest seulement ici que le php commence
// on compte le nombre de champs de formulaires non renseignés ou inexistants
$nbVidesOuInexistants = 0;
// si lʼinternaute nʼa encore pas renvoyé le formulaire ou sʼil nʼa pas coché
dʼoption
// pour le sexe
if (!array_key_exists(ʻsexeʼ,$_REQUEST)) $nbVidesOuInexistants += 1;
// si lʼinternaute vient dʼenvoyer sa première requête http concernant ce
formulaire, cʼest quʼil
// ne lʼa pas encore renvoyé,
// donc, la clé dateNaiss nʼexiste pas dans le tableau $_REQUEST
if (!array_key_exists(ʻdateNaissʼ,$_REQUEST)) $nbVidesOuInexistants += 1;
// si, par contre, il a déjà renvoyé le formulaire, on vérifie sʼil a renseigné sa date de naissance
else if
($_REQUEST[ʻdateNaissʼ] == ʻʼ) $nbVidesOuInexistants += 1;
// cas où lʼinternaute a bien rempli et renvoyé son formulaire
if ($nbVidesOuInexistants == 0)
print ʻBien reçu <br>ʼ;
// on va dans le else si cʼest la première requête demandant le formulaire
vierge
// ou si lʼinternaute a mal renseigné certains champs du formulaire
else
{
printʼ<form name = ”formrep“ action = ”http://localhost/scriptPartie4.php“
method = ”get“>ʼ;
// si cʼest le sexe qui nʼa pas été renseigné...
if (!array_key_exists(ʻsexeʼ,$_REQUEST))
{
print ʻIndiquez votre sexe : <BR>ʼ;
print ʻH: <Input type = ”radio“ name = ”sexe“ value = ”h“>ʼ;
8 3951 TG PA 00
184
Séquence 3
Initiation à PhP
print ʻF: <Input type=“radio“ name = ”sexe“ value = ”f“> <br>ʼ;
}
else {
// si le sexe a été renseigné, on restitue ce qui a été saisi par
lʼinternaute
// en cochant lʼoption quʼil avait cochée
print ʻSexe : <BR>ʼ;
if ($_REQUEST[ʻsexeʼ] == ʻhʼ)
{
print ʻH: <Input type = ”radio“ name = ”sexe“ value = ”h“
checked>ʼ;
print ʻF: <Input type = ”radio“ name = ”sexe“ value = ”f“>
<br>ʼ;
}
else {
print ʻH: <Input type = ”radio“ name = ”sexe“ value = ”h“
>ʼ;
print ʻF: <Input type = ”radio“ name =“sexe“ value = ”f“
checked> <br>ʼ;
}
}
// fin traitement sexe
// si la date de naissance est inexistante
if (!array_key_exists(ʻdateNaissʼ,$_REQUEST))
print ʻIndiquez votre date de naissance : <Input type = ”date“
name = ”dateNaiss“ size = 8 > <br>ʼ;
// si lʼinternaute nʼa pas renseigné sa date de naissance
else if ($_REQUEST[ʻdateNaissʼ] == ʻʼ) // 2 simples quottes
print ʻIndiquez votre date de naissance : <Input type =
”date“ name = ”dateNaiss“ size = 8 > <br>ʼ;
else
print ʻDate de naissance : <Input type = ”date“ name =
”dateNaiss“ size = 8 value = ” ʻ.$_REQUEST[ʻdateNaissʼ].ʼ ”
> <br>ʼ;
// fin traitement date
// on rajoute le bouton submit
print ʻ<input type = ”BUTTON“ name = ”envoyer“ value = ”Envoyer“ OnClick
= ”envoi(this.form);“><br>ʼ;
print ʻ</form>ʼ;
}
print ʻ</html>ʼ;
?>
8 3951 TG PA 00
185
Séquence 3
Initiation à PhP
Pour tester, commencez par taper la requête http suivante dans la barre d’adresse de votre navigateur : http ://localhost/scriptPartie4.php.
Vous pouvez constater qu’en réponse, vous recevez un formulaire à remplir.
Par curiosité, affichez le code source de ce formulaire.
Vous pouvez constater deux choses :
– on a bien le code source de la fonction javascript ;
– le code html généré dynamiquement tient entièrement sur une seule ligne. On a bien mis
nos <br> pour que les composants soient les uns en dessous des autres dans le formulaire
généré, mais on n’a pas utilisé \n dans les instructions php, de façon à ce que le code
source généré dynamiquement soit propre. Dans votre script php, réparez cette erreur
afin que le code html généré soit présentable.
Voici le code source généré dynamiquement lors de l’envoi de la requête http :
http ://localhost/scriptPartie4.php…
<html>
<head>
{
form.submit();
}
</script>
</head>
<form name = ”formrep“ action = ”http://localhost/scriptPartie4.php“ method =
”get“>
Indiquez votre sexe : <BR>
H: <Input type = ”radio“ name = ”sexe“ value = ”h“>
F: <Input type=“radio“ name = ”sexe“ value = ”f“> <br>
Indiquez votre date de naissance : <Input type = ”date“ name = ”dateNaiss“
size = 8 > <br>
<input type = ”BUTTON“ name = ”envoyer“ value = ”Envoyer“ OnClick =
”envoi(this.form);“><br>
</form>
</html>
Maintenant, pour tester la réaction de notre script, cocher une des options concernant le sexe,
mais ne renseignez pas la date de naissance, puis cliquez sur Envoyer.
Voici ce qui est envoyé au script :
http://localhost/scriptPartie4.php?sexe=f&dateNaiss=.
En réponse, le script nous renvoie un formulaire où il nous demande de saisir une date de naissance.
8 3951 TG PA 00
186
Séquence 3
Initiation à PhP
Affichez le code source du formulaire que vous avez reçu.
Vous pouvez constater que la partie variable du formulaire, celle qui a changé par rapport au
formulaire issu de la première requête http, c’est la partie générée dynamiquement à l’aide de
tests en php.
Enfin, pour terminer ce test, renseignez la date de naissance et cliquez sur Envoyer.
Vous recevez, en réponse, une page affichant le message Bien reçu.
Affichez également le code source de cette page. Il est encore différent.
Vous avez pu observer trois versions d’un formulaire, générées par notre script scriptPartie4.php.
Maintenant, nous allons faire en sorte, dans le deuxième exemple, que les instructions javascript
fassent aussi partie de la partie variable du formulaire.
2. Exemple 2 : présence conditionnelle de javascript dans
la page générée
Je veux faire évoluer l’exemple précédent, en faisant le constat suivant.
Il est inutile de créer la fonction envoi lorsque l’internaute a bien renseigné toutes les zones.
Nous n’allons donc écrire cette fonction que si certaines zones sont vides ou inexistantes.
Je reprends le script précédent et je le modifie comme ci-dessous (j’ai mis en gras les nouveautés).
<html>
<head>
<?
// on compte le nombre de champs de formulaires non renseignés
else if
{
print ʻBien reçu <br>ʼ.“\n“;
// on ferme la balise head seulement ici
print ʻ</head>ʼ;
}
else
{
print ʻ<script language = javascript>ʼ.“\n“;
print ʻfunction envoi(form)ʼ.“\n“;
print ʻ{ʻ.»\n».ʼform.submit();ʼ.“\n“.ʼ}ʼ.“\n“;
8 3951 TG PA 00
187
Séquence 3
Initiation à PhP
print ʻ</script>ʼ.“\n“;
// on ferme la balise head seulement ici
print ʻ</head>ʼ.“\n“;
printʼ<form name = “formrep“ action = «http://localhost/scriptPartie4.php“
method = “get“><br>ʼ.“\n“;
// si cʼest le sexe qui nʼa pas été renseigné ...
// la suite du script ne change pas
Vous voyez qu’ici, on a écrit les instructions javascript dans des instructions print. On a fait comme
pour les balises html.
Testez cette version de la façon suivante :
– envoyez une requête http ://localhost/scriptPartie4.php ;
– regardez le code source de ce qui nous est renvoyé, notre fonction y figure en bonne
place ;
– ensuite, renseignez bien le sexe et la date de naissance ;
– cliquez sur Envoyer ;
– regardez le code source de la page qui vous est renvoyée en réponse, la fonction javascript
n’y figure pas.
Voilà un exemple d’écriture conditionnelle d’instructions javascript.
On pourrait aussi provoquer des écritures itératives d’instructions javascript !!
Je souhaite maintenant faire évoluer une dernière fois cet exemple en faisant en sorte que les
instructions javascript ne soient pas toujours les mêmes selon la situation. On va prendre un cas
simple.
3. Exemple 3 : instructions javascript variant selon la
situation
Disons que nous allons faire évoluer la version précédente de notre script de la façon suivante :
quand l’internaute oublie de renseigner la date, on lui affiche Cette fois, pensez à bien renseigner
votre date de naissance, et quand il a oublié de cocher un des deux sexes, on lui affiche N’oubliez
pas de renseigner le sexe.
C’est simpliste, mais ça vous permettra de voir que même les instructions javascript peuvent être
générées de façon conditionnelle.
Voici ci-dessous un début de solution, qui, je vous préviens tout de suite, ne fonctionne pas, mais
on va voir ensemble pourquoi. Comme d’habitude, j’ai mis en gras les changements.
<html>
<head>

</head>
8 3951 TG PA 00
188
Séquence 3
Initiation à PhP
<?
else if
print ʻBien reçu <br>ʼ.“\n“;
else
{
printʼ<form name = “formrep“ action = “http://localhost/scriptPartie4.php“
method = “get“><br>ʼ.“\n“;
{
print ʻ<script language = javascript>ʼ.“\n“;
print ʻfunction envoi(form)ʼ.“\n“;
print ʻ{ʻ.“\n“;
print ʻalert(“N\ʼoubliez pas de renseigner votre sexe!“);ʼ.“\n“;
print ʻform.submit();ʼ.“\n“.ʼ}ʼ.“\n“;
print ʻ</script>ʼ.“\n“;
print ʻIndiquez votre sexe : <BR>ʼ.“\n“;
print ʻH: <Input type = “radio“ name = “sexe“ value = “h“>ʼ.“\n“;
print ʻF: <Input type=“radio“ name = “sexe“ value = “f“> <br>ʼ.“\
n“;
}
else {
// si le sexe a été renseigné, on restitue ce qui a été saisi par
lʼinternaute
// en cochant lʼoption quʼil avait cochée
print ʻSexe : <BR>ʼ.“\n“;
// etc…la suite ne change pas pour lʼinstant
Allez, on teste.
À la première requête http://localhost/scriptPartie4.php, tout se passe bien, le formulaire s’affiche correctement.
Quand on regarde le code source de ce formulaire, on voit notre fonction :
<html>
<head>
8 3951 TG PA 00
189
Séquence 3
Initiation à PhP
</head>
<form name = “formrep” action = “http://localhost/scriptPartie4.php” method =
“get”><br>
{
alert(“Nʼoubliez pas de renseigner votre sexe!”);
form.submit();
}
</script>
Indiquez votre sexe : <BR>
H: <Input type = “radio” name = “sexe” value = “h”>
F: <Input type=”radio” name = “sexe” value = “f”> <br>
Indiquez votre date de naissance : <Input type = “date” name = “dateNaiss”
size = 8 > <br>
<input type = “BUTTON” name = “envoyer” value = “Envoyer” OnClick =
“envoi(this.form);”><br>
</form>
</html>
Pour tester, je saisis une valeur dans la date de naissance et je clique sur Envoyer.
Je vois bien le message N’oubliez pas de renseigner votre sexe ! S’afficher.
Je clique sur OK et ça fonctionne.
Je recommence le test depuis le début, mais cette fois, lors de la saisie des informations dans le
formulaire qui m’a été envoyé, je renseigne le sexe, mais pas la date de naissance, je clique sur
Envoyer, et cette fois, crac, j’ai une erreur javascript.
Regardons le code source :
<html>
<head>
</head>
<form name = “formrep” action = “http://localhost/scriptPartie4.php” method =
“get”><br>
Sexe : <BR>
H: <Input type = “radio” name = “sexe” value = “h” >
F: <Input type = “radio” name =”sexe” value = “f” checked> <br>
Indiquez votre date de naissance : <Input type = “date” name = “dateNaiss”
size = 8 > <br>
8 3951 TG PA 00
190
Séquence 3
Initiation à PhP
<input type = “BUTTON” name = “envoyer” value = “Envoyer” OnClick =
“envoi(this.form);”><br>
</form>
</html>
Ah !! Évidemment !!
J’appelle une fonction envoi, dans l’événement OnClick de mon bouton, mais cette fonction
n’existe pas puisqu’elle n’est générée que lorsque l’internaute ne renseigne pas son sexe !!
Bon, alors on n’a pas le choix, on ne peut pas écrire cette fonction au fur et à mesure qu’on construit le formulaire à renvoyer à l’internaute.
On doit la construire avant la construction du formulaire, de manière conditionnelle :
head>
</head>
<?
else if
{
print ʻBien reçu <br>ʼ.”\n”;
}
else
{
print ʻ<script language = javascript>ʼ.”\n”;
print ʻfunction envoi(form)ʼ.”\n”;
print ʻ{ʻ.”\n”;
print ʻalert(“N\ʼoubliez pas de renseigner votreʼ;
// on continue ici lʼinstruction alert quʼon avait commencé à créer cidessus
if (!array_key_exists(ʻsexeʼ,$_REQUEST)) print ʻ sexe!”);ʼ.”\n”;
else printʼ date de naissance.”);ʼ.”\n”;
print ʻform.submit();ʼ.”\n”.ʼ}ʼ.”\n”;
print ʻ</script>ʼ.”\n”;
printʼ<form name = “formrep” action = “http://localhost/scriptPartie4.php”
method = “get”><br>ʼ.”\n”;
8 3951 TG PA 00
191
Séquence 3
Initiation à PhP
{
print ʻIndiquez votre sexe : <BR>ʼ.”\n”;
print ʻH: <Input type = “radio” name = “sexe” value = “h”>ʼ.”\n”;
print ʻF: <Input type=”radio” name = “sexe” value = “f”> <br>ʼ.”\
n”;
}
else { // Etc… la suite du script ne change pas
Voilà. Pour tester, comme d’habitude, testez une fois en renseignant le sexe mais pas la date de
naissance, regardez le code source de ce qui vous est renvoyé.
Puis recommencez le test en renseignant la date de naissance et pas le sexe, et regardez à nouveau le code source de la page qui vous est renvoyée.
Vous pouvez constater que le code source de la fonction envoi est adapté à la situation.
Je vous laisse le soin de rajouter du SQL dans votre script, cela ne change rien aux manipulations
javascript que l’on vient de faire.
Notre partie 4 est donc terminée, et comme c’était la dernière partie de cette séquence sur php,
cela signifie que nous avons terminé l’initiation à php, qui était le gros morceau de ce support
de cours.
Nous allons maintenant aborder les feuilles de style, dans la séquence suivante et enfin, pour
terminer cette initiation à la programmation web, nous ferons un petit bout de xml.
8 3951 TG PA 00
192

Partie 3 : manipulation de bases de données mySql avec PhP

Transcription

Documents pareils

Stratégie et actions commerciales Web to Print

stage graphisme et communication (web et print) h/f entreprise

php, mysql - Mediagraf

Exporter - Agence de communication

Communication Commerciale

Standox Téléchargements

Grenoble INP-Pagora - Stratégie et action commerciale Web-to

Chef de projet PHP/MySql

graphiste - Marie