Developpez.com - PHP
X

Choisissez d'abord la catégorieensuite la rubrique :


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.


sommaire


présentation

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


pré-requis

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


la syntaxe


les expressions

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'


les séquences d'échappement

> 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>.


les commentaires

> 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 !

contrôle d'erreur

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


les opérateurs


opérateurs arithmétiques

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


opérateurs de comparaison

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


opérateurs logiques

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


types de données

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 :


booléens

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.


entiers

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 */
?>

réels

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 */
?>

chaînes de caractères

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


les variables


définition

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 !


assignation par référence

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...


concaténation

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 !


post-incrémentation/décrémentation

<?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


pré-incrémentation/décrémentation

<?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


variables prédéfinies


définition

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 :

$_SERVER

La disponibilité des champs de $_SERVER dépendent de la configuration du serveur sur lequel tourne PHP.
Voici quelques-unes des entrées possibles :

SERVER_NAME

> le nom relatif du serveur qui exécute le script courant :

<?php echo $_SERVER[SERVER_NAME]; ?>

retourne :   thierrylhomme.developpez.com


DOCUMENT_ROOT

> le chemin du répertoire racine du serveur.

<?php echo $_SERVER[DOCUMENT_ROOT]; ?>

retourne :   /var/www/home


PHP_SELF

> 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


REMOTE_ADDR

> l'adresse IP du client qui demande la page, i.e. vous ;-)

<?php echo $_SERVER[REMOTE_ADDR]; ?>

retourne :   54.92.192.156


HTTP_USER_AGENT

> décrit le client de la requête (votre navigateur) :

<?php echo $_SERVER[HTTP_USER_AGENT]; ?>

retourne :   CCBot/2.0 (http://commoncrawl.org/faq/)

> 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


les constantes


définition

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; ?>

constantes prédéfinies

Il existe beaucoup de constantes prédéfinies ; en voici un petit échantillon :

__FILE__

> le chemin complet de la page en cours :

<?php echo __FILE__; ?>

retourne :   /var/www/home/ultra_php/index.php


__LINE__

> 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_VERSION

<?php echo "la version de l'analyseur PHP est la : ", PHP_VERSION; ?>
retourne :   la version de l'analyseur PHP est la : 5.3.29


PHP_OS

<?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


les fonctions


définition

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


passation d'arguments

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


$GLOBALS

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


require()

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.


include()

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


les tableaux


déclaration

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
)

tableaux associatifs

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


les structures de contrôle


if/elseif

<?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.


switch/case

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 :)


do/while

> 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


while

> 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


for

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


syntaxe alternative

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


traitement de formulaires


$_POST

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>

$_GET

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 :)


$_COOKIE

<?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é :)


$_FILES

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é.


$_REQUEST

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

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


les objets

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


fonctions intégrées

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) :

fonctions de test de type

> 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


fonctions de variables


isset()

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()

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()

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()

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"
}

fonctions de chaînes


echo()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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.


fonctions de répertoires


opendir()

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()

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 :)) :
&ampgt; ls -a confidentiel<br>
<?php
 while ($file=readdir($ptr)) {
 echo "$file\n";
 }
?>
&ampgt;
retourne :  

> ls -a confidentiel
révélations.xyz
perso-privé.xyz
ultra-secret.xyz
..
.
>


rewinddir()

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 ".." :
&ampgt; ls confidentiel<br>
<?php
 rewinddir($ptr);
 while ($file=readdir($ptr)) {
  if ($file != "." && $file != "..") {
  echo "$file\n";
  }
 }
?>
&ampgt;
retourne :  

> ls confidentiel
révélations.xyz
perso-privé.xyz
ultra-secret.xyz
>


closedir()

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é :)



fonctions de fichiers


basename()

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()

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()

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()

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()

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()

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()

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()

readfile() lit (et retourne) un fichier entier :
<?php
 readfile($fichier);
?>
retourne :
'Text is everything,
data is just streams
of lines of text...'
-- Brian Kernighan

file()

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()

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 01/10/2016


> si l'on ne souhaite la date de dernière modification que de la page en cours, on pourra utiliser :


getlastmod()

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()

unlink() efface le fichier passé en argument :
<?php
unlink($fichier);
?>
> à condition d'avoir les droits appropriés dessus ;-)


fileperms()

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


chmod()

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\"";
 }
?>

fonctions de tableaux

Outre array(), il existe beaucoup de fonctions permettant de manipuler des tableaux.
Voici les plus courantes :

each()

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()

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()

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()

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()

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()

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()

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.


fonctions d'expressions régulières

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(), eregi()

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(), eregi_replace()

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.


split(), spliti()

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()

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]


fonctions MySQL

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 :


mysql_connect()

> se connecte au serveur avec le trio classique "serveur", "login", "pwd" en argument.

mysql_error()

> retourne le message d'erreur de Mysql.

mysql_select_db()

> selectionne la base passée en argument.

mysql_query()

> envoie la requête SQL passée en argument.

mysql_num_rows()

> retourne le nombre de lignes du résultat de la requête passée en argument.

mysql_fetch_array()

> retourne une ligne du résultat de la requête passée en argument sous forme d'un tableau associatif.

mysql_free_result()

> libère la mémoire allouée pour la requête passée en argument.

mysql_close()

> 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


annexe


opérateurs sur les bits

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


précédence des opérateurs

(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


liens

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/

powered by PHP


Contacter le responsable de la rubrique PHP