ultra-concis PHP
> date de dernière modification :
12/02/2007
Ce document est (très) librement adapté de la doc PHP -- et aussi (un peu) du Précis & Concis PHP, aux éditions O'Reilly (par Rasmus Lerdorf himself).
Il est lui-même un script PHP : toutes les valeurs de renvoi des exemples (en bleu) seront retournées (en rouge) par l'analyseur ("parser") PHP de l'hébergeur de cette page.
Pour rester dans les limites du raisonnable, tout en faisant la part belle aux exemples, ce tutoriel se limite à la syntaxe de base et aux fonctions les plus courantes...
> ce document a été réalisé à l'aide de EasyPHP 1.6 (www.easyphp.org/) sous Win2k, de l'éditeur ConTEXT (http://www.fixedsys.com/context/), "normalisé" avec Tidy (tidy.sourceforge.net/), et enfin testé avec les navigateurs Internet Explorer 6.0 et Mozilla 1.3.
Si vous rencontrez des anomalies quelconques avec votre configuration, merci de me le faire savoir.
PHP (acronyme récursif pour PHP Hypertext Preprocessor), développé
initialement par Rasmus Lerdorf, est un langage de script qui
fonctionne côté serveur -- contrairement au Javascript, par
exemple, qui s'exécute sur la machine de l'utilisateur :-(
On le trouve le plus souvent inséré dans une page HTML. L'analyseur
PHP ne renverra au navigateur QUE du code HTML.
PHP est donc aussi léger et transparent que l'air :-)
Et c'est loin d'être sa seule qualité !
> le mieux est de placer le code entre les balises
<?php et ?>, comme ceci :
<html>
<body>
<?php echo "<b>Ceci est un déjà un script PHP !</b>"; ?>
</body>
</html>
> puis d'enregistrer le fichier avec l'extension *.php.
L'analyseur PHP (local ou non) retournera :
Ceci est un déjà un script PHP !
>> il est possible (voire courant) d'insérer des balises html
dans du code PHP, tout comme du code PHP à l'intérieur de balises
html :
<?php $man="http://www.php.net/manual/fr/"; ?>
<a href=<?php echo $man; ?> target=_blank>manuel PHP en ligne</a>
retourne :
manuel PHP en ligne
haut, sommaire
Dans ce tutoriel, nous présumons
que vous avez un serveur web avec le support PHP activé, et que les
fichiers terminés par l'extension .php sont traités par PHP.
(...)
Si votre serveur web supporte PHP, vous n'avez rien à faire.
Simplement, créez un dossier, puis créez un fichier texte, avec
l'extension .php : le serveur va automatiquement l'exécuter
avec PHP. Il n'y a pas de compilation, ou d'installation
compliquée. Gardez en tête que les fichiers sont comparables à des
fichiers HTML, dans lesquels vous allez utiliser des balises
magiques, qui feront beaucoup de choses pour vous.
extrait du manuel PHP
Une certaine pratique du html est nécessaire à l'apprentissage de
PHP ; ceux qui hésitent parmi les quelques dizaines de milliers de
pages qui proposent des tutoriels peuvent se rendre là.
> ceux qui pratiquent le Perl sont les bienvenus ; ils vont
pouvoir se reposer un peu, ils l'ont bien mérité ;-)
> ceux qui enregistrent leurs sources sous *.asp, bienvenue itou ; ils sauveront peut-être ainsi leur âme...
> quant à ceux qui savent leur C, le royaume des cieux, même
s'ils l'ignorent, leur appartient déjà.
haut, sommaire
Les expressions sont la pierre angulaire de PHP. Une expression
peut être : une instruction, une déclaration, une affectation,
une comparaison...
> si une instruction doit toujours se terminer par un
point-virgule (sauf lorsqu'elle précède immédiatement une balise
?> de fin de bloc de code), ce n'est pas le cas d'une
expression.
> une expression renvoie une valeur
booléenne TRUE (une valeur numérique différente de
0) ou FALSE, soit 0.
> illustrons tout ceci avec l'opérateur ternaire
(expression1) ? (expression2) : (expression3); emprunté au langage C, correspondant à l'instruction conditionnelle if/then/else :
<?php
($a=1) ? (print "\$a renvoie 'vrai'") : (print "\$a renvoie 'faux'");
?>
retourne :
$a renvoie 'vrai'
<?php
($a=0) ? (print "\$a renvoie 'vrai'") : (print "\$a renvoie 'faux'");
?>
retourne :
$a renvoie 'faux'
> le caractère d'échappement '\' protège certains
caractères (les affiche tels quels à l'écran) :
<?php echo "\$a = \"C'est comme ça...\""; ?>
retourne : $a = "C'est comme ça..."
> les séquences d'échappement, quant à elles, font de la mise en
page :
| séquence |
effet |
| \t |
insère une tabulation |
| \r |
effectue un retour chariot |
| \n |
effectue un retour à la ligne |
>> si vos séquences d'échappement ne fonctionnent pas,
encadrez votre code des balises HTML <pre> et
</pre>.
> PHP supporte les commentaires du C, C++ et ceux du Shell
Unix :
<?php
echo "Welcome !\t\t"; # commentaire sur une ligne
echo "Bienvenue !\t\t"; // commentaire sur une ligne
echo "Willkommen !\n"; /* commentaire sur
plusieurs lignes */
?>
retourne :
Bienvenue ! Welcome ! Willkommen !
L'opérateur "@" placé devant une instruction (généralement
une fonction) permet que le message d'alerte ou d'erreur généré par
PHP soit ignoré :
<?php
if (unlink("texte.txt")) { // si (supprimer "texte.txt") retourne TRUE
print "\"texte.txt\" supprimé...";
} else { // sinon
print "\"texte.txt\" n'est pas supprimé...";
}
?>
retourne :
Warning: unlink() failed (No such file or directory) in index.php on line 333
"texte.txt" n'est pas supprimé...
>> pour éviter cela :
<?php
if (@unlink("texte.txt")) {
print "\"texte.txt\" supprimé...";
} else {
print "\"texte.txt\" n'est pas supprimé...";
}
?>
retourne : "texte.txt" n'est pas supprimé...
haut, sommaire, la syntaxe
| signe |
exemple |
description |
| + (addition) |
$a + $b |
additionne $a et $b |
| - (soustraction) |
$a - $b |
soustrait $b de $a |
| * (multiplication) |
$a * $b |
multiplie $a par $b |
| / (division) |
$a / $b |
divise $a par $b |
| % (modulo) |
$a % $b |
reste de la division de $a par
$b |
| signe |
exemple |
retourne TRUE si : |
| == (égal) |
$a == $b |
$a est égal à $b |
| === (identique) |
$a === $b |
$a est égal et du même type que $b (PHP4
seulement) |
| != (différent) |
$a != $b |
$a est différent de $b |
| < (inférieur) |
$a < $b |
$a est inférieur à $b |
| > (supérieur) |
$a > $b |
$a est supérieur à $b |
| <= (inférieur ou égal) |
$a <= $b |
$a est inférieur ou égal à $b |
| >= (supérieur ou égal) |
$a >= $b |
$a est supérieur ou égal à
$b |
| signe |
exemple |
retourne TRUE si : |
| && (et) |
$a && $b |
$a et $b retournent TRUE |
| AND (et) |
$a and $b |
$a et $b retournent TRUE * |
| || (ou) |
$a || $b |
$a ou $b retourne TRUE |
| OR (ou) |
$a or $b |
$a ou $b retourne TRUE * |
| XOR (ou exclusif) |
$a xor $b |
$a ou $b (exclusivement) retourne
TRUE |
| ! (faux) |
! $a |
$a retourne FALSE |
(*) priorité inférieure à celle de l'opérateur précédent
> les opérateurs sur les bits, ainsi que
la précédence des opérateurs sont traités en
annexe
haut, sommaire, les opérateurs
Il n'est pas nécessaire de déclarer le type des données que l'on
manipule, celui-ci est affecté dynamiquement par PHP.
En revanche, il n'est pas inutile de connaître les différents types
possibles :
Un booléen (cf les expressions) exprime une
valeur VRAI 'TRUE', ou FAUX
'FALSE'.
> les expressions suivantes étant strictement identiques, on ne
sera pas, à priori, amené à utiliser explicitement un type
booléen :
<?php
($a == 0) == TRUE;
($a == 0) != FALSE;
$a == 0;
?>
> nous sommes d'accord.
Un entier (integer, ou int) est un nombre de
l'ensemble des entiers naturels {..., -2, -1, 0, 1, 2,
...}.
On peut l'exprimer de trois manières :
<?php
$a = 1234; /* nombre entier en base décimale */
$a = 02322; /* le même en base octale, préfixé 0 */
$a = 0x4D2; /* le même en base hexadécimale, préfixé 0x */
?>
Un nombre réel (float, ou double), appelé aussi
"à virgule flottante", peut être exprimé de deux manières :
<?php
$a = 1.234;
$a = 1.2e3; /* notation scientifique */
?>
Une chaîne (ou séquence) de caractères doit être encadrée de
guillemets :
> simples (' ') si elle ne contient rien qui nécessite
d'être échappé ;
> doubles (" ") si l'on veut que les
séquences d'échappement et les variables
qu'elle contient soient interprétées (on parle de "substitution de
variables") :
<?php
$meilleurs = 'Marseille';
echo "$meilleurs, eux meilleurs !"
?>
retourne : Marseille, eux meilleurs !
haut, sommaire, types de données
On déclare une variable en lui attribuant un identifiant valide
(commençant soit par un caractère alphabétique, soit par le
caractère souligné '_') préfixé du signe dollar
'$', et en lui assignant une valeur.
> sauf si elle est déclarée au sein d'une définition de fonction, la portée d'une variable est
globale (elle concernera le script entier à partir de la
déclaration, ou de la redéclaration de la variable).
> on assigne une valeur à une variable à l'aide du signe égal
'=' :
<?php
$a = 3; /* assigne la valeur entière 3 à $a */
?>
valeur de $a : 3
> on peut assigner une valeur et le produit d'une opération
arithmétique à une variable en même temps :
<?php
$a += 5; /* correspond à l'instruction $a = $a + 5 */
?>
valeur de $a : 8
> une variable peut être redéclarée ; sa valeur précédente sera
chaque fois écrasée par la nouvelle valeur qu'on lui aura
assignée :
<?php
$meilleurs = 'PSG';
echo "$meilleurs eux meilleurs !";
?>
retourne : PSG eux meilleurs !
Le signe '&' permet d'assigner la valeur d'une
variable source à une variable destination.
> modifier la valeur de l'une modifiera aussi la valeur de
l'autre :
<?php
$trop_meilleurs = 'Maseille';
$trop_meilleurs = &$meilleurs;
echo "$trop_meilleurs y sont trop meilleurs...";
?>
retourne : PSG y sont trop meilleurs...
Le point '.' permet de concaténer variables et chaînes de
caractères :
<?php
$trop_meilleurs = $trop_meilleurs . " y sont trop meilleurs...";
/* ou bien :
$trop_meilleurs .= " y sont trop meilleurs..."; */
echo $trop_meilleurs;
?>
retourne : PSG y sont trop meilleurs...
> la virgule ',' (uniquement avec la fonction
echo()) permet elle aussi la concaténation :
<?php
echo $trop_meilleurs, " mais quand même moins que Marseille !";
?>
retourne : PSG y sont trop meilleurs... mais quand même moins que Marseille !
<?php
$a = 3;
$b = $a++; /* assigne la valeur de $a à $b,
puis incrémente $a */
?>
valeur de $a : 4
valeur de $b : 3
<?php
$c = $a--; /* assigne la valeur de $a à $c,
puis décrémente $a */
?>
valeur de $a : 3
valeur de $c : 4
<?php
$d = ++$c; /* incrémente $c,
puis assigne la valeur obtenue à $d */
?>
valeur de $c : 5
valeur de $d : 5
<?php
$e = --$d; /* décrémente $d,
puis assigne la valeur obtenue à $e */
?>
valeur de $d : 4
valeur de $e : 4
haut, sommaire, les variables
Les variables prédéfinies (ou "superglobales") se présentent sous
forme de tableaux associatifs (on parle
aussi de "tableaux superglobaux"), dont les indices sont eux-mêmes
des variables prédéfinies.
> le plus évident d'entre eux est sans doute :
La disponibilité des champs de $_SERVER dépendent de la
configuration du serveur sur lequel tourne PHP.
Voici quelques-unes des entrées possibles :
> le nom relatif du serveur qui exécute le script
courant :
<?php echo $_SERVER[SERVER_NAME];
?>
retourne : thierrylhomme.developpez.com
> le chemin du répertoire racine du serveur.
<?php echo $_SERVER[DOCUMENT_ROOT];
?>
retourne : /var/www/home
> le nom du fichier du script courant, depuis la racine
($_SERVER[DOCUMENT_ROOT]) du serveur :
<?php echo $_SERVER[PHP_SELF]; ?>
retourne : /php/ultra_php/index.php
> l'adresse IP du client qui demande la page, i.e. vous ;-)
<?php echo $_SERVER[REMOTE_ADDR];
?>
retourne : 38.103.63.61
> décrit le client de la requête (votre navigateur) :
<?php echo $_SERVER[HTTP_USER_AGENT];
?>
retourne : CCBot/1.0 (+http://www.commoncrawl.org/bot.html)
> on trouvera un exemple d'utilisation de cette dernière à la
section include().
> pour connaître les champs de la variable $_SERVER
disponibles sur votre serveur, ou celui de votre FAI :
<?php print_r($_SERVER); ?>
>> la variable prédéfinie $GLOBALS est traitée à la
section les fonctions.
>> les variables prédéfinies $_POST, $_GET,
$_COOKIE, $_FILES et $_REQUEST sont
évoquées à la section traitement de
formulaires.
>> on parle de la variable prédéfinie $_SESSION à la
section les sessions.
haut, sommaire, variables prédéfinies
Contrairement à une variable, une constante ne peut pas être
redéclarée.
On la définit à l'aide de la fonction define().
> par convention, un nom de constante s'écrit en
majuscule :
<?php
define ("MA_CONST", "Armatatuxa !");
?>
> si la constante est placée entre guillements lors de l'appel,
il n'y aura pas substitution :
<?php echo "MA_CONST retourne ", MA_CONST; ?>
retourne : MA_CONST retourne armatatuxa
> un caractère de concaténation est ici indispensable ; on peut
tout aussi bien écrire :
<?php echo "MA_CONST retourne ".MA_CONST; ?>
Il existe beaucoup de constantes prédéfinies ; en voici un petit
échantillon :
> le chemin complet de la page en cours :
<?php echo __FILE__; ?>
retourne : /var/www/home/ultra_php/index.php
> le numéro de la ligne de la constante :
<?php echo "la ligne ", __LINE__, " ne contient aucune erreur ;-)"; ?>
retourne : la ligne 930 ne contient aucune erreur ;-)
<?php echo "la version de l'analyseur PHP est la : ", PHP_VERSION; ?>
retourne : la version de l'analyseur PHP est la : 5.2.6
<?php echo "le système d'exploitation du serveur est ", PHP_OS; ?>
retourne : le système d'exploitation du serveur est Linux
> TRUE et FALSE (cf les booléens) sont aussi des constantes prédéfinies.
>> la fonction get_defined_constants() renverra la
liste exhaustive des constantes (pré)définies disponibles.
haut, sommaire, les constantes
Une fonction se définit à l'aide du mot-clé function, d'un
identifiant valide, et de parenthèses '()'.
> toute instruction PHP valide peut être contenue à l'intérieur
du bloc délimité par les accolades '{}' :
<?php
function bateau() {
echo "fonction remplie !";
}
bateau(); // appel de fonction
?>
retourne : fonction remplie !
> les parenthèses peuvent renfermer un ou plusieurs
arguments :
<?php
function mult($i, $j) { // $i et $j sont des variables locales
return $i*$j; /* multiplie les valeurs des deux arguments
et retourne le résultat */
}
?>
> l'instruction return est utilisé soit pour retourner
une valeur (ou une variable), soit pour interrompre le déroulement
d'une fonction avec une valeur de retour (comme son homonyme en C).
>> pour implémenter cette fonction, passons-lui deux
variables en argument :
<?php
$a = 5;
$b = 6;
$c = mult($a, $b); /* assignation de la valeur de retour
d'une fonction à une variable */
?>
valeur de $c : 30
Une variable déclarée à l'intérieur d'une fonction n'a aucune
valeur à l'extérieur (portée locale) :
<?php
$a=5;
function compteur_non_fonctionnel($i) {
$i++;
}
compteur_non_fonctionnel($a);
?>
valeur de $a : 5
> l'opérateur d'adresse '&' permet à une variable
locale de pointer sur l'adresse d'une globale :
<?php
function compteur_fonctionnel(&$i) {
/* $i pointe désormais sur l'adresse de la variable passée en argument
lors de l'appel de fonction */
$i++;
}
compteur_fonctionnel($a);
?>
valeur de $a : 6
Une variable déclarée à l'extérieur d'une fonction (portée globale)
n'a pas cours à l'intérieur de celle-ci.
Si l'on doit faire appel à une globale à l'intérieur d'une
fonction, il faut la faire précéder du mot réservé
global :
<?php
function nouveau_compteur () {
global $a;
$a++;
}
nouveau_compteur();
?>
valeur de $a : 7
> la variable prédéfinie $GLOBALS est un tableau associatif dont les champs contiennent
les globales déclarées dans le script :
<?php
function autre_compteur () {
$GLOBALS['a']++;
}
autre_compteur();
?>
valeur de $a : 8
La fonction require() appelle et exécute un code contenu
dans un fichier externe.
> soit un fichier "phrase.inc" situé dans le même dossier que le
présent fichier :
le mot du jour :
<?php require("phrase.inc"); ?>
retourne :
le mot du jour :
Il vaut mieux qu'il pleuve un jour comme aujourd'hui qu'un jour où il fait beau !
>> l'extension .inc est par convention utilisée pour
désigner un fichier de bibliothèque.
La fonction include() est similaire à require(),
à ceci près qu'avec include() le traitement ne
s'interrompra pas en cas d'erreur, et le reste de la page
s'affichera normalement.
> voici le code d'un
test idiot, appelant conditionnellement un fichier de
bibliothèque ou un autre, selon l'indice criminogène de votre
navigateur :
<?php
if (ereg ("MSIE", $HTTP_USER_AGENT)) {
include ('IE.inc');
}
else {
include ('NOT.inc');
}
?>
>> la fonction ereg() recherche
(et renvoie TRUE si elle trouve) la chaîne 'MSIE'
dans la chaîne retournée par $HTTP_USER_AGENT.
haut, sommaire, les fonctions
Une manière simple de déclarer un tableau est d'utiliser la
fonction array() :
<?php
$tablo = array("premier élément",
"deuxième élément",
"troisième élément");
?>
> la fonction print_r permet
d'afficher une variable, quel que soit son type :
<?php
print_r($tablo);
?>
retourne :
Array
(
[0] => premier élément
[1] => deuxième élément
[2] => troisième élément
)
> ceci nous montre la structure ([indice] =>
element) d'un tableau.
>> ajoutons un élément à notre tableau :
<?php
$tablo[] = "nouvel élément";
print_r($tablo);
?>
retourne :
Array
(
[0] => premier élément
[1] => deuxième élément
[2] => troisième élément
[3] => nouvel élément
)
On parle de tableau associatif lorsque l'on affecte une valeur à
l'indice :
<?php
$tablo = array("patron" => "Marc-André",
"commercial" => "Louis-Christophe",
"Thierry"
);
print_r($tablo);
?>
retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
[0] => Thierry
)
> l'indice [0] est automatiquement affecté au premier
élément dépourvu d'indice.
>> supprimons un élément :
<?php
unset($tablo[0]);
print_r($tablo);
?>
retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
)
> la fonction unset() permet de
supprimer une variable.
>> ajoutons un élément avec un indice associé :
<?php
$tablo['secrétaire'] = "Valérie-Anne";
?>
>> affichons cet élément d'après son indice :
<?php
echo $tablo['secrétaire'];
?>
retourne : Valérie-Anne
>> + sur les tableaux : fonctions de
tableaux
haut, sommaire, les tableaux
<?php
$a = 8;
$b = 9;
echo "révision sur la pré/post incrémentation :\n";
if (++$a == $b) { // si (expression) renvoie TRUE
echo "++\$a est égal à $b"; // instruction
} elseif ($a++ == $b) { // autre si (expression) renvoie TRUE
echo "\$a++ est égal à $b"; // instruction
} else { // sinon
echo "rien de tout ça !"; // instruction
}
?>
retourne :
révision sur la pré/post incrémentation :
++$a est égal à 9
> afin d'améliorer la lisibilité du code, et/ou sa maintenance,
il est possible de le découper en blocs d'instructions :
<?php
$a = 8;
$b = 9;
?>
révision sur la pré/post incrémentation :<br>
<?php
if (++$a == $b) {
?>
++$a est égal à 9
<?php
} elseif ($a++ == $b) {
?>
$a++ est égal à 9
<?php
} else {
?>
rien de tout ça !
<?php
}
?>
retourne :
révision sur la pré/post incrémentation :
++$a est égal à 9
> la lisibilité de cet exemple sera accrue par l'adoption d'une
syntaxe alternative.
Les instructions switch et case remplacent
avantageusement if/elseif lorsque les conditions
sont plus nombreuses :
<?php
switch ($a+1) { // si ($a+1) est égal à
case ($a++): // $a++
print "(\$a+1) est égal à ($a++)"; // instruction
break; // sortir
case (++$a): // ++$a
print "(\$a+1) est égal à (++$a)"; // instruction
break; // sortir
case ($a+1): // $a+1
print "(\$a+1) est égal à ($a+1)"; // instruction
continue; // continuer
default; // rien de tout ça
print "rien de tout ça !"; // instruction
}
?>
retourne : rien de tout ça !
// forcément
:)
> permet d'exécuter l'instruction au moins une fois :
<?php
$i = 0;
do { // faire
print $i; // instruction
} while ($i > 0); // tant que (condition)
?>
retourne : 0
> ne garantit pas que l'instruction s'exécute :
<?php
$i = 0;
while ($i > 0) { // tant que (condition)
print $i; // instruction
}
?>
retourne : (rien)
>> obtenons une sortie :
<?php
$i = 0;
while ($i < 10) {
print ($i++ . " ");
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9
La boucle for remplit les mêmes fonctions que la boucle
while, mais son utilisation est plus concise :
> la plus concise :
<?php
for ($i = 0; $i < 10; print "$i ", $i++);
?>
retourne : 0 1 2 3 4 5 6 7 8 9
> en plus lisible :
<?php
for ($i = 0; $i < 10; $i++){
print "$i ";
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9
> avec break; :
<?php
for ($i = 0;;$i++) {
if ($i == 10) {
break;
}
print "$i ";
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9
> ou encore :
<?php
$i = 0;
for (;;) {
if ($i == 10) {
break;
}
print "$i ";
$i++;
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9
Les structures concernées sont : if/elseif,
switch, while, for et foreach.
> il s'agit de remplacer les accolades d'ouverture '{'
par le signe ':', et l'accolade finale de fermeture
'}' par, respectivement : 'endif;',
'endswitch;', 'endwhile;', 'endfor;' et
'endforeach;'.
> si l'on reprend l'exemple donné pour if/elseif, cela donne :
<?php
$a = 8;
$b = 9;
echo "révision sur la pré/post incrémentation :\n";
if (++$a == $b) :
echo "++\$a est égal à $b";
elseif ($a++ == $b) :
echo "\$a++ est égal à $b";
else :
echo "rien de tout ça !";
endif;
?>
retourne :
révision sur la pré/post incrémentation :
++$a est égal à 9
>> découpons à présent notre code :
<?php
$a = 8;
$b = 9;
?>
révision sur la pré/post incrémentation :<br>
<?php
if (++$a == $b) :
?>
++$a est égal à 9
<?php
elseif ($a++ == $b) :
?>
$a++ est égal à 9
<?php
else :
?>
rien de tout ça !
<?php
endif;
?>
résultat identique :
révision sur la pré/post incrémentation :
++$a est égal à 9
> c pas bô, ça ?
haut, sommaire, les structures de contrôles
Le tableau superglobal $_POST couvre l'ensemble des champs
renseignés par la méthode "post" d'un formulaire.
> la valeur du champ "name" d'un formulaire est
accessible dans les variables $_POST['valeur'] ou
$_GET['valeur'] du script cible :
> c'est
à vous
>> voici le code de l'exploit :D
<?php $tut=$_POST['tuto']; ?>
<form action="./sondage.php" method="post">
<select name="tuto">
<option
<?php
if ($tut=="horripilant") {
$tut="passionnant"; echo ' selected';
}
?>
>horripilant</option>
<option
<?php
if ($tut=="soporifique") {
$tut="fantastique"; echo ' selected';
}
?>
>soporifique</option>
<option
<?php
if ($tut=="lamentable") {
$tut="incontournable"; echo ' selected';
}
?>
>lamentable</option>
<option
<php
if($tut=="affreux") {
$tut="fabuleux"; echo ' selected';
}
?>
>affreux</option>
</select>
Le tableau $_GET couvre l'ensemble des champs renseignés
par la méthode "get" d'un formulaire.
> c'est
encore à vous
> code :
<?php
if ($_GET['go']) {
if (empty($_GET['pseudo'])||empty($_GET['qualite'])||empty($_GET['defaut'])) {
echo "Vous n'avez pas rempli tous les champs !";
} else {
echo $_GET['pseudo'] ?> , vous êtes <?php echo $_GET['qualite'] ?> , mais <?php echo $_GET['defaut']; ?> :) <?php
}
} else {
}
?>
> la fonction empty() retourne TRUE si la
chaîne passée en argument est vide.
La méthode "get" d'un formulaire génère une chaîne de caractères,
constituée d'autant de couples 'élément=valeur', séparés
par un '&', que de champs remplis dans le
formulaire.
Cette chaîne est limitée à 255 caractères ; elle s'accroche à l'url
de la page avec un point d'interrogation '?' :
> par exemple, supposons que vous ayez rempli le formulaire avec
les éléments suivants :
<?php
$_GET['pseudo']="Boulet";
$_GET['qualite']="gentil";
$_GET['defaut']="lourd";
?>
> l'url du formulaire donne quelque chose comme :
http://thierry.lhomme.free.fr/php_scripts/form.php?pseudo=Boulet&qualite= \
gentil&defaut=lourd&go=OK
> on peut analyser cette chaîne à l'aide de la fonction
parse_url(), qui retourne, dans un tableau, les différents
éléments constitutifs d'une url :
<?php
$tab=parse_url("http://thierry.lhomme.free.fr/php_scripts/form.php?pseudo= \
Boulet&qualite=gentil&defaut=lourd&go=OK");
print_r($tab);
?>
retourne :
Array
(
[scheme] => http
[host] => thierry.lhomme.free.fr
[path] => /php_scripts/form1.php
[query] => pseudo=Boulet&qualite=gentil&defaut=lourd&go=OK
)
> on peut exploiter ce dernier champ en faisant appel à la
fonction parse_str(), laquelle analyse une chaîne et
convertit les couples 'élément=valeur' en couples
'variables=valeur' :
<?php
parse_str($tab['query']);
echo "$pseudo, vous êtes $qualite, mais $defaut :)";
?>
retourne : Boulet, vous êtes gentil, mais lourd :)
<?php
setcookie("ultra", "sans_valeur", time()+3600*24);
?>
> soit un cookie, créé par la fonction setcookie(),
nommé "ultra", de valeur "sans_valeur", et d'une
durée de vie de 24 heures :
<?php
echo $_COOKIE['ultra'];
?>
retourne (pour peu que vous ayez accepté le
cookie) :
> si le champ est vide alors que vous n'avez pas bloqué le
cookie, rafraîchissez la page...
>> pour une fois que vous pouvez voir la valeur d'un cookie
s'afficher sur la page qui vous l'a envoyé :)
Soit un fichier uploadé par la méthode "post" d'un
formulaire :
<form enctype="multipart/form-data" action="traite_fichier.php" method="post">
<input type="hidden" name="MAX_FILE_SIZE" value="10000">
<input type="file" name="fichier">
<input type="submit" value="OK">
</form>
> le fichier "traite_fichier.php" peut ressembler
(sommairement) à ceci :
<?php
$rep_dest="../php_scripts/";
if(move_uploaded_file($_FILES['fichier']['tmp_name'],
$rep_dest . $_FILES['fichier']['name'])) {
print "\"fichier\" a bien été uploadé et placé dans \"php_scripts\" :)";
} else {
print "pas marché :("
}
?>
>> la fonction move_uploaded_file() vérifie si
l'upload s'est bien passé ET place le fichier dans
le répertoire spécifié.
Un tableau associatif constitué du contenu des variables
$_GET, $_POST, $_COOKIE et
$_FILES :
> dans l'état actuel des choses,
<?php print_r($_REQUEST); ?>
retourne :
Array
(
)
haut, sommaire, traitement de formulaires
Les sessions permettent de conserver un certain nombre
d'informations, sous forme de variables, de page en page au sein
d'un site.
> soit un formulaire session.php :
<form action="./login.php" method="post">
votre pseudo : <input type="text" name="pseudo" value="">
votre pwd : <input type="password" name="pwd" value="">
validez : <input type="submit" name="go" value="OK">
> le fichier login.php pourrait ressembler à
ceci :
<?php
$pseudo_valide="moi";
$pwd_valide="aspro";
if ($_POST['pseudo']==$pseudo_valide && $_POST['pwd']==$pwd_valide) {
header('location: membre.php'); // redirige vers la page "membre.php"
} else {
echo "pseudo ou password invalide :("
}
?>
>> voici à quoi pourrait ressembler le début du fichier
membre.php :
<?php
session_start(); // démarre la session
?>
<html><body>
<?php
echo "Bonjour et bienvenue,".$_SESSION['pseudo_valide']." !";
?>
etc...
<a href="deconnect.php">Déconnexion(<?php echo $_SESSION['pseudo_valide'] ?>)</a>
etc...
> la fonction session_start() doit être appelée avant
toute balise html.
Elle doit être présente dans chaque page où l'on fait appel aux
variables de session.
> ce que pourrait contenir le fichier
deconnect.php :
<?php
session_start();
session_unset(); // supprime toutes les variables de session
session_destroy(); // deux précautions valent mieux qu'une
echo "vous devriez à présent être déconnecté(e) :)";
?>
haut, sommaire, les sessions
La programmation orientée objet (POO, pour les intimes) permet
d'économiser du code.
Elle mérite donc toute notre attention :)
Le concept d'objet est indissociable du concept de classe.
Une classe se crée à l'aide du mot réservé class et d'un
identifiant valide.
> dans sa plus simple expression, notre classe ressemble à
ceci :
<?php
class commande {
var $client;
function panier() {
echo $this->client;
}
}
?>
> à l'intérieur d'une classe, on déclare ses variables (ou
"attributs") à l'aide du mot réservé var.
> une fonction (ou "méthode"), agit sur les attributs à l'aide
de la variable spéciale $this et de l'opérateur
->.
Une variable externe associée à une classe devient un objet.
Cette association est appelée "instanciation de l'objet".
> un objet devient l'instance d'une classe grâce au mot réservé
new :
<?php
$clampin01 = new commande();
?>
> on lui assigne une valeur via un attribut de la classe, et à
l'aide de l'opérateur -> :
<?php
$clampin01->client = "Pierre Duvet";
?>
> attention ! un seul $ pour cette nouvelle
variable.
Appelons à présent la méthode :
<?php
$clampin01->panier();
?>
retourne : Pierre Duvet
Afin que l'utilisation d'une classe soit un peu plus justifiée,
rajoutons à notre méthode quelques fonctionnalités.
Le propos sera de gérer le panier du client, et afficher sa
commande :
<?php
class commande {
var $client;
function panier($ref, $nbre) {
echo "client : ".$this->client;
echo "<br>votre commande : ";
echo $this->ref += $nbre; // affiche le nombre d'articles
echo " $ref<br>a bien été enregistrée...";
}
}
?>
> passons notre première commande :
<?php
$clampin01->panier("trucs", 6);
?>
retourne :
client : Pierre Duvet
votre commande : 6 trucs
a bien été enregistrée...
Pour résumer cette courte introduction à la POO selon PHP (et
rentabiliser quelque peu le code investi :)), créons un
nouvel objet, et exploitons-le :
<?php
$clampin02=new commande(); // instanciation de l'objet
$clampin02->client="Marie Couette"; // assignation de valeur via l'attribut
$clampin02->panier("bidules", 8); // appel de méthode
?>
retourne :
client : Marie Couette
votre commande : 8 bidules
a bien été enregistrée...
haut, sommaire, les objets
Il existe énormément de fonctions PHP intégrées ; on en trouvera la
liste exhaustive ici : www.php.net/manual/fr/funcref.php
> en voici quelques-unes parmi les plus courantes, classées par
domaine d'utilisation (ce classement respecte celui de la doc
pré-citée) :
> il existe une fonction de test pour chaque type de
variables :
| fonction |
retourne TRUE si la variable est : |
| is_array() |
un tableau |
| is_bool() |
de type booléen |
is_double()
alias de is_float()
et de is_real() |
un nombre réel, ou à virgule flottante |
is_int()
alias de is_long() |
un nombre entier |
| is_null() |
sans valeur |
| is_numeric() |
un nombre, ou une chaîne numérique |
| is_object() |
un objet |
| is_resource() |
une ressource PHP (pointeur, requête SQL...) |
| is_scalar() |
une variable scalaire |
| is_string() |
une chaîne de caractère |
> exemple :
<?php
$a = 'zolie variable';
(is_string($a)) ? (print "\$a est une chaîne") : (print "\$a est autre chose")
?>
retourne : $a est une chaîne
isset() permet de savoir si une variable est définie ou
non :
<?php
(isset($a)) ? (print "\$a est une $a") : (print "\$a n'existe pas")
?>
retourne : $a est une zolie variable
unset() détruit la ou les variable(s) passée(s) en
argument :
<?php
unset ($a);
(isset($a)) ? (print "\$a est toujours une $a") : (print "\$a n'existe plus")
?>
retourne : $a n'existe plus
print_r() affiche la structure simple d'une
variable :
<?php
print_r($tablo);
?>
retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
[secrétaire] => Valérie-Anne
)
var_dump() affiche la structure complexe d'une
variable :
<?php
var_dump($tablo);
?>
retourne :
array(3) {
["patron"]=>
string(10) "Marc-André"
["commercial"]=>
string(16) "Louis-Christophe"
["secrétaire"]=>
string(12) "Valérie-Anne"
}
echo() n'étant pas vraiment une fonction, mais une
structure du langage, on n'est pas tenu d'utiliser les parenthèses
'()'.
> echo() (mais pas print()) permet de
concaténer deux chaînes avec une virgule ',' :
<?php
$a = 'zolie variable'; /* ligne en question */
echo "et revoilà notre $a, déclarée ligne ", __LINE__ -1;
?>
retourne : et revoilà notre zolie variable, déclarée ligne 2308
> remarquons au passage la souplesse de PHP, qui nous permet de
situer très simplement la ligne en question.
>> comme cette structure ne fonctionne pas avec
echo() :
<?php
(isset($a)) ? (echo "\$a existe") : (echo "\$a n'existe pas")
/* ne fonctionne pas */
?>
> nous l'utiliserons avec :
print() n'étant pas non plus vraiment une fonction, la
même remarque au sujet des parenthèses s'applique.
> si l'on veut, on peut utiliser des parenthèses malgré
tout :
<?php
(isset($a)) ? (print ("\$a existe")) : (print ("\$a n'existe pas"))
?>
retourne : $a existe
printf() renvoie une chaîne formatée, à la manière de son
célèbre homologue en C :
<?php
$char = 612;
$chaine = "le code ASCII %s correspond à la lettre %c";
printf ($chaine, $char, $char);
?>
retourne : le code ASCII 612 correspond à la lettre d
> le format des arguments est sensiblement le même qu'en
C :
| signe |
description |
| %b |
un entier, au format binaire |
| %c |
un caractère, correspondant à son code ASCII |
| %d |
un entier, signé |
| %f |
un réel, ou à virgule flottante |
| %o |
un entier, au format octal |
| %s |
une chaîne de caractères |
| %u |
un entier, non signé |
| %x |
un entier, au format hexadécimal, en minuscules |
| %X |
un entier, au format hexadécimal, en
majuscules |
implode() permet de rassembler les éléments d'un tableau
en une chaîne.
> le premier argument est le signe utilisé comme séparateur de
champs :
<?php
$chaine_de_tablo = implode(" | ", $tablo);
print $chaine_de_tablo;
?>
retourne : Marc-André | Louis-Christophe | Valérie-Anne
explode() réalise l'opération inverse :
<?php
$tablo_tout_neuf = explode(" | ", $chaine_de_tablo);
print_r ($tablo_tout_neuf);
?>
retourne :
Array
(
[0] => Marc-André
[1] => Louis-Christophe
[2] => Valérie-Anne
)
>> évidemment, les indices sont passés à la trappe...
strstr() recherche la première occurence d'une
chaîne :
<?php
$email = 'user@example.com';
$domaine = strstr($email, '@');
print $domaine;
?>
retourne : @example.com
str_replace() remplace une occurence dans la chaîne
spécifiée :
<?php
$nouvel_email = str_replace('example.com', 'mydomain.net', $email);
print $nouvel_email;
?>
retourne : user@mydomain.net
str_pad() complète la chaîne spécifiée, jusqu'à atteindre
une taille n, avec le ou les caractère(s) fourni(s) en
argument :
<?php
$message = "WELCOME !";
print str_pad($message, 20, "+-") . "\n";
print str_pad($message, 20, "+-", STR_PAD_LEFT) . "\n";
print str_pad($message, 20, "+-", STR_PAD_BOTH) . "\n";
?>
retourne :
WELCOME !+-+-+-+-+-+
+-+-+-+-+-+WELCOME !
+-+-+WELCOME !+-+-+-
> si aucun caractère de remplissage n'est fourni,
str_pad() utilisera des espaces vides.
str_repeat() retourne une chaîne dont le caractère fourni
en argument sera multiplié n fois :
<?php
$chaine = str_repeat("+-", 10);
echo $chaine;
?>
retourne :
+-+-+-+-+-+-+-+-+-+-
strrchr() retourne le segment de la chaîne spécifiée qui
commence avec le dernier caractère passé en argument :
<?php
$fichier = strrchr($_SERVER[PHP_SELF], "/");
echo $fichier;
?>
retourne : /index.php
substr() retourne le segment de la chaîne spécifiée
commençant par le nième argument de la chaîne
(optionnellement de longueur n).
> le premier argument de la chaîne est indexé à 0 :
<?php
$fichier = substr(strrchr($_SERVER[PHP_SELF], "/"), 1);
echo $fichier;
?>
retourne : index.php
> la fonction basename()
retourne le même résultat.
opendir() permet d'ouvrir un répertoire (en y plaçant un
pointeur) :
<?php
$rep="confidentiel";
if ($ptr=opendir($rep)) {
print "dossier \"$rep\" ouvert !";
} else {
print "impossible d'ouvrir \"$rep\" :(";
}
?>
retourne : dossier "confidentiel" ouvert !
readdir() retourne le nom du fichier identifié par le
pointeur.
> pour lire tout le contenu du dossier ouvert (et se croire un
moment sous Linux :)) :
&gt; ls -a confidentiel<br>
<?php
while ($file=readdir($ptr)) {
echo "$file\n";
}
?>
&gt;
retourne :
> ls -a confidentiel
.
..
perso-privé.xyz
révélations.xyz
ultra-secret.xyz
>
rewinddir() replace le pointeur au début du répertoire
ouvert.
> reprenons l'exemple précédent, sans afficher le répertoire en
cours ".", ni le répertoire parent ".." :
&gt; ls confidentiel<br>
<?php
rewinddir($ptr);
while ($file=readdir($ptr)) {
if ($file != "." && $file != "..") {
echo "$file\n";
}
}
?>
&gt;
retourne :
> ls confidentiel
perso-privé.xyz
révélations.xyz
ultra-secret.xyz
>
closedir() permet de fermer un répertoire ouvert avec
opendir() :
<?php
closedir($ptr);
?>
> closedir() est de type void, et ne renvoie
donc pas de valeur ; pour tester le succès de l'appel de la
fonction, il faut forcer un peu les choses :
<?php
if (@readdir($ptr)) { /* sans le "@" on se ferait incendier ;) */
print "\"$rep\" toujours ouvert !";
} else {
print "\"$rep\" fermé :)";
}
?>
retourne : "confidentiel" fermé :)
basename() renvoie le nom de base du fichier passé en
argument :
<?php
echo basename($_SERVER[PHP_SELF]);
?>
retourne : index.php
> si l'on ne veut pas de l'extension :
<?php
echo basename($_SERVER[PHP_SELF], ".php");
?>
retourne : index
copy() copie un fichier source vers un fichier
destination :
<?php
if (!copy(basename($_SERVER[PHP_SELF]), 'ultra_php.safe')) {
print "copie impossible";
} else {
print "copie effectuée";
}
?>
> les extensions '*.foo' des noms de fichiers doivent
être soigneusement 'quotées' (pour ne pas être assimilées à des
concaténations). Ceci fonctionne également :
<?php
copy(basename($_SERVER[PHP_SELF]), ultra_php . '.safe')
?>
fopen() ouvre un fichier (local ou distant) sous forme de
flux et retourne un pointeur de fichier.
> différents modes sont possibles :
| lettre |
mode |
pointeur positionné |
| r |
lecture seule |
au début du fichier |
| r+ |
lecture / écriture |
au début du fichier |
| w |
écriture seule * |
au début du fichier |
| w+ |
lecture / écriture * |
au début du fichier |
| a |
écriture seule |
à la fin du fichier |
| a+ |
lecture / écriture |
à la fin du fichier |
(*) réduit la taille du fichier à 0.
> fopen() tente de créer le fichier s'il n'existe
pas :
<?php
$fichier = "kernighan.txt";
if (!$flux = fopen($fichier, "w+")) {
print "création de \"$fichier\" impossible :-(";
} else {
print "\"$fichier\" est ouvert en lecture / écriture...";
}
?>
"kernighan.txt" est ouvert en lecture / écriture...
fclose() ferme un flux de fichier ouvert :
<?php
if (!fclose($flux)) {
print "\"$fichier\" est toujours ouvert...";
} else {
print "\"$fichier\" est fermé !";
}
?>
"kernighan.txt" est fermé !
fwrite() permet d'écrire dans un fichier :
<?php
if (!$flux = fopen($fichier, "w")) {
print "ouverture de $fichier en écriture impossible :-(";
exit;
}
$texte = "'Text is everything,\n
data is just streams\n
of lines of text...'\n
-- Brian Kernighan";
if (fwrite ($flux, $texte)) {
print "le texte :\n\n" . "$texte\n\n" . "a bien été écrit dans \"$fichier\"";
} else {
print "je crois que ça n'a pas été possible :-(";
}
fclose($flux);
?>
retourne :
le texte :
'Text is everything,
data is just streams
of lines of text...'
-- Brian Kernighan
a bien été écrit dans "kernighan.txt"
fgets() retourne une chaîne lue depuis un flux ouvert,
jusqu'au premier retour à la ligne rencontré :
<?php
$flux = fopen($fichier, "r");
echo fgets($flux);
fclose($flux);
}
?>
retourne :
'Text is everything,
>> fgets() accepte un deuxième argument : la
longueur de la chaîne lue, exprimée en octets. Par défaut, celle-ci
est de 1024. Spécifions une valeur de 10 octets :
<?php
$flux = fopen($fichier, "r");
echo fgets($flux, 10);
fclose($flux);
}
?>
retourne :
'Text is
feof() retourne TRUE lorsque le pointeur a
atteint la fin du fichier :
<?php
$flux = fopen($fichier, "r");
while (!feof($flux)) {
echo fgets($flux);
}
?>
retourne :
'Text is everything,
data is just streams
of lines of text...'
-- Brian Kernighan
>> feof() ferme le flux ouvert, en conséquence de
quoi l'appel à fclose() générerait des erreurs.
readfile() lit (et retourne) un fichier entier :
<?php
readfile($fichier);
?>
retourne :
'Text is everything,
data is just streams
of lines of text...'
-- Brian Kernighan
Comme readfile(), file() lit le contenu d'un
fichier, mais le retourne dans un tableau :
<?php
$ker_tablo = file($fichier);
print $ker_tablo[3];
}
?>
retourne :
-- Brian Kernighan
filemtime() renvoie la date à laquelle un fichier a été
modifié :
<?php
echo "\"$fichier\" a été modifié le " . date("d/m/Y", filemtime($fichier));
?>
retourne : "kernighan.txt" a été modifié le 28/08/2008
> si l'on ne souhaite la date de dernière modification que de la
page en cours, on pourra utiliser :
getlastmod() ne concerne que la page en cours et ne prend
aucun argument :
<?php
echo "date de dernière modification : le " . date("d/m/Y", getlastmod());
?>
retourne : date de dernière modification : le 12/02/2007
unlink() efface le fichier passé en argument :
<?php
unlink($fichier);
?>
> à condition d'avoir les droits appropriés dessus ;-)
fileperms() renvoie les bits de permissions (au format
décimal) du fichier passé en argument :
<?php
$perms = fileperms($fichier);
echo $perms;
?>
retourne : 33188
> si les vous préférez au format unix :
<?php
$octal_perms = sprintf("%o", $perms);
$unix_perms = (substr($octal_perms, 2));
echo $unix_perms;
?>
retourne : 0644
Comme son homonyme sous unix, chmod() permet (au
propriétaire du fichier) de changer les bits de permissions :
<?php
if (!chmod($fichier, 0755)) {
print "droits sur \"$fichier\" inchangés";
} else {
print "vous avez désormais tous les droits sur \"$fichier\"";
}
?>
Outre array(), il existe beaucoup de
fonctions permettant de manipuler des tableaux.
Voici les plus courantes :
each() permet de parcourir un tableau :
<?php
reset($tablo); /* obligatoire avec cette structure */
while (list($indice, $element) = each ($tablo)) {
echo "$indice : $element\n";
}
?>
retourne :
patron : Marc-André
commercial : Louis-Christophe
secrétaire : Valérie-Anne
foreach() (PHP4 seulement) est un moyen simple de
parcourir un tableau :
<?php
foreach ($tablo as $indice => $element) {
echo "$indice : $element\n";
}
?>
retourne :
patron : Marc-André
commercial : Louis-Christophe
secrétaire : Valérie-Anne
array_keys() retourne (dans un tableau) les indices du
tableau passé en argument :
<?php
print_r(array_keys($tablo));
?>
retourne :
Array
(
[0] => patron
[1] => commercial
[2] => secrétaire
)
array_values() retourne (dans un tableau) les valeurs du
tableau passé en argument :
<?php
print_r(array_values($tablo));
?>
retourne :
Array
(
[0] => Marc-André
[1] => Louis-Christophe
[2] => Valérie-Anne
)
array_push() ajoute de nouveaux éléments à un
tableau :
<?php
array_push($tablo, "Olivier-Jacques");
print_r($tablo);
?>
retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
[secrétaire] => Valérie-Anne
[1] => Olivier-Jacques
)
> l'indice [1] attribué au dernier élément de
$tablo s'explique par le fait que l'indice [0]
avait déjà été attribué à un autre élément (cf tableaux associatifs). Même si cet élément a été
supprimé, son indice ne peut être réattribué à un autre.
Les bases de données se comportent de la même façon.
>> de la même façon, il n'est pas possible de renommer un
indice.
Si nous voulons que Olivier-Jacques soit compté comme technicien
dans l'entreprise, il faudra d'abord supprimer son entrée
actuelle :
<?php
unset($tablo[1]);
$tablo['technicien']="Olivier-Jacques";
?>
count() retourne le nombre d'éléments d'un
tableau :
<?php
$nbre_element=count($tablo);
echo "notre entreprise compte $nbre_element personnes :<br>";
?>
retourne : notre entreprise compte 4 personnes :
list() fait correspondre chaque élément d'un tableau à une
variable.
list() n'opère qu'avec les tableaux non-associatifs, c'est
pourquoi nous devons créer un nouveau tableau :
<?php
$new_tablo=array_keys($tablo);
list($boss, $comm, $secr, $tech) = $new_tablo;
echo "le $boss, un $comm, une $secr et un $tech.";
?>
retourne : le patron, un commercial, une secrétaire et un technicien.
Les expressions régulières sont utilisées pour manipuler des chaînes de caractères.
PHP supporte les expressions régulières avancées de POSIX (POSIX 1003.2).
Si vous avez quelques lacunes, je ne peux que vous conseiller cette excellente présentation des regex.
> voici les fonctions disponibles :
ereg() recherche (et renvoie TRUE si elle trouve)
une ou plusieurs séquence(s) de caractères dans une chaîne.
> dans l'exemple suivant, on verifie si $email contient
bien un arobase et un point :
<?php
if(ereg("@", $email) && ereg(".", $email)) {
print "email valide :)\n";
} else {
print "email non valide :(\n";
}
?>
retourne : email valide :)
> ereg() accepte un troisième argument : un
tableau contenant les résultats de la recherche, et dont l'indice
[0] contient une copie de la chaîne :
<?php
if(ereg("(user|moi)@(example|domain).(com|net)", $email, $result)) {
echo $result[0]." (".$result[1]."@".$result[2].".".$result[3].")";
} else {
print "pas trouvé :(";
}
?>
retourne : user@example.com (user@example.com)
>> eregi() est similaire à ereg(), excepté
qu'avec ereg() la recherche est sensible à la casse,
tandis qu'avec eregi() elle ne l'est pas.
ereg_replace() remplace une séquence de caractères par une
autre dans une chaîne :
<?php
$new_email=ereg_replace("^user", "moi", $email);
/* remplace la chaîne débutant par "user" par "moi" */
$new_email=ereg_replace("ex.mple", "mydomain", $new_email);
/* si l'on n'est pas sûr de l'orthographe */
$new_email=ereg_replace("com$", "net", $new_email);
/* remplace la chaîne finissant par "com" par "net" */
echo $new_email;
?>
retourne : moi@mydomain.net
>> eregi_replace() est similaire à
ereg_replace(), excepté qu' eregi_replace() est
insensible à la casse.
Comme implode() (mais avec le support des expressions
régulières), split() scinde une chaîne en un tableau :
<?php
list($nom, $dom, $suf) = split ("[@.]", $new_email);
echo "nom : $nom ; domaine : $dom ; suffixe : $suf";
?>
retourne : nom : moi ; domaine : mydomain ; suffixe : net
>> spliti() est similaire à split(),
excepté...
sql_regcase() retourne les différents caractères de la
chaîne passée en argument par paire majuscule/minuscule entre
crochets.
Cette fonction sert à préparer une requête insensible à la casse,
dans le format des expressions régulières :
<?php
echo sql_regcase("mysql");
?>
retourne : [Mm][Yy][Ss][Qq][Ll]
PHP est compatible avec bon nombre de SGBD. Parmi ces derniers, et
parcequ'il a beaucoup de choses en commun avec PHP (gratuité,
disponibilité du code source, etc), MySQL est sans conteste le plus
populaire.
Voici les principales fonctions d'interfaçage MySQL de
PHP :
> se connecte au serveur avec le trio classique "serveur",
"login", "pwd" en argument.
> retourne le message d'erreur de Mysql.
> selectionne la base passée en argument.
> envoie la requête SQL passée en argument.
> retourne le nombre de lignes du résultat de la requête passée
en argument.
> retourne une ligne du résultat de la requête passée en
argument sous forme d'un tableau associatif.
> libère la mémoire allouée pour la requête passée en
argument.
> ferme la connection passée en argument.
Soit une base dvdtek, constituée de trois tables :
films, réalisateurs et acteurs.
On souhaite connaître tous les films de Claude Chabrol dans
lesquels joue Isabelle Huppert :
<?php
$db=mysql_connect("localhost", "moi", "aspro500");
mysql_select_db("dvdtek", $db);
$sql='SELECT titre, année
FROM films, réalisateurs, acteurs
WHERE réalisateurs.réal="claude chabrol"
AND acteurs.act="isabelle huppert"
ORDER BY année ASC';
$req=mysql_query($sql) or die(mysql_error());
$num=mysql_num_rows($req);
echo "$num film(s) trouvé(s) :<br>";
while ($row=mysql_fetch_array($req)) { // tant qu'il y aura des lignes...
echo $row['titre'].", ".$row['année']."<br>";
}
mysql_free_result($req);
mysql_close($db);
?>
devrait retourner :
6 film(s) trouvé(s) :
Violette Nozière, 1978
Une affaire de femmes, 1988
Madame Bovary, 1991
La cérémonie, 1995
Rien ne va plus, 1997
Merci pour le chocolat, 2000
haut, sommaire, fonctions intégrées
| signe |
exemple |
retourne : |
| & (et) |
$a & $b |
les bits de $a et ceux de $b
positionnés |
| | (ou) |
$a | $b |
les bits de $a ou ceux de $b
positionnés |
| ^ (ou exclusif) |
$a ^ $b |
les bits de $a ou ceux de $b (exclusivement)
positionnés |
| ~ (faux) |
~ $a |
les bits de $a non positionnés |
| << (décalage à gauche) |
$a << $b |
décale $a de $b bits vers la gauche |
| >> (décalage à droite) |
$a >> $b |
décale $a de $b bits vers la
droite |
(d'après Rasmus Lerdorf)
> les opérateurs sont classés par ordre de priorité
décroissante :
| opérateurs |
associativité |
| ! ~ ++ -- @ (int) (float) (string) (array)
(object) |
droite |
| * / % |
gauche |
| + - . |
gauche |
| << >> |
gauche |
| < <= > >= |
- |
| == != |
- |
| & |
gauche |
| ^ |
gauche |
| | |
gauche |
| && |
gauche |
| || |
gauche |
| ? : (opérateur ternaire conditionnel) |
gauche |
| = += -= *= /= %= .= &= |= |
gauche |
| AND |
gauche |
| XOR |
gauche |
| OR |
gauche |
Quelques liens vers des pages qui ont beaucoup contribué à l'élaboration de celle-ci :
> merci à Cyberzoide d'avoir accepté d'ajouter cette page à la base de connaissances de developpez.com.
haut, sommaire, annexe
> critiques, encouragements, menaces, dévotions, injures, remarques, suggestions...
© Thierry Lhomme, 2003.
http://thierrylhomme.developpez.com/
|
