site sans réclame PHPCont@ctS'abonner

PHP: présentation synthétique

L

e PHP est un interpréteur de scripts écrits pour traiter les informations de formulaires, de bases de données (voir la page minimale MySQL) et de l'affichage HTML. Il est très vite devenu un langage complet capable d'effectuer des calculs (et même de produire des pdf et des images, ce dont il n'est pas question ici).

Cette page est issue de notes à usage personnel, présentées pour que cela puisse servir à d'autres: la doc officielle n'est pas toujours pratique (ordre alphabétique des fonctions...). Contrairement à la page python, cette page-ci ne vise pas à l'exhaustivité, et aucun suivi n'est assuré. Cela dit, un courriel est bienvenu pour toute suggestion ou correction.

Pour une sortie graphique, il est possible d'utiliser gtk, ce qui n'est pas trop conseillé car recomposer les mêmes images à partir du serveur est une surcharge inutile pour celui-ci.

4. Les chaînes

4.1 Comptage
4.2 Transformation de chaînes
4.3 Comparaisons de chaînes
4.4 Opération sur des sous-chaînes
4.5 Transformation HTML
4.6 Conversions
4.7 Encodage et contrôle
4.8 Expressions régulières
4.9 Non traités

5. Les tableaux

5.1 Tableaux indexés
5.2 Tableaux associatifs
5.3 Comptages
5.4 Opérations sur tableaux
5.5 Modification de tableaux
5.6 Déplacement dans un tableau
5.7 Tris de tableaux
5.8 Opérations ensemblistes
5.9 Non traités

6. Fichiers et répertoire

6.1 Gestion fichiers/répertoires
6.2 Attributs de fichiers
6.3 Travail sur les fichiers

7. Passage de paramètres

7.1 GET
7.2 POST
7.3 Magic Quotes
7.4 Cookies

8. Divers

8.1 Temps
8.2 Courriels
8.3 Header
8.4 Variables du système

9. Documentation

1. Préalables

1.1 PHP chez votre hébergeur

Pour savoir si l'hébergeur de votre espace Internet offre les services PHP, il faut y uploader ("envoyer") un fichier.php contenant le code suivant, puis l'appeler en indiquant son adresse dans un navigateur:

<?php
$os=PHP_OS; $version=PHP_VERSION;
echo "<html><body>
<p>$os $version</p>
</body></html>";
?>

Si PHP n'est pas installé sur le serveur, le script apparaîtra tel quel. Si PHP est installé, il affichera le nom du système d'exploitation du serveur et la version PHP qu'il utilise (PHP_OS et PHP_VERSION sont deux constantes internes à PHP).

Beaucoup de fonctionnalités dépendent de la configuration du serveur, à laquelle l'utilisateur ne peut normalement pas grand-chose, comme la possibilité de commencer ses fichiers .php par <? plutôt que <?php (quel gain de place!) ou l'inclusion de portions de code php dans une page html...

1.2 PHP en ligne de commande

Sur un système GNU+Linux, on n'est pas obligé d'installer Apache si l'on se contente de PHPsans HTML: il suffit d'installer php-cli ou php5-cli. Dans une console, on lance un script .php de la façon suivante:

$ php fichier.php

Si le fichier.php est exécutable (chmod 740 fichier.php) et commence de la façon suivante:

#! /usr/bin/php

<?php

il est possible d'exécuter le fichier directement dans la console:

./fichier.php

Il est encore possible d'exécuter du code directement en ligne de commande:

php -r "echo 8 % 3;"

Note:
- la ligne de commande ne semble pas supporter le signe =
- le mode console n'interprète pas les balises html: echo "Yop!<br>"; devra être réécrit echo "Yop!\n";

1.3 PHP chez soi: un serveur LAMP

Pour vos besoins domestiques ou pour travailler en espace clos avant de charger vos pages PHP sur le net, il est possible d'installer le serveur Apache et PHP sur votre propre machine, et MySQL si vous utilisez ce gestionnaire de base de données. En Debian 6.0 Squeeze, il a suffi d'installer

suEn mode super-utilisateur: su [Enter] apt-get install apache2 php5 libapache2-mod-php5 mysql-client mysql-server phpmyadmin

pour disposer de l'environnement LAMP/Linux-Apache-MySQL-PHP (choisir apache2 lors de l'installation). phpmyadmin n'est pas obligatoire mais permet la création et l'édition de base de données à l'aide d'une interface graphique. Le code à tester doit se placer en /var/www. Pour rendre ce répertoire accessible à vos fichiers de simple utilisateur:

suEn mode super-utilisateur: su [Enter] chmod 777 /var/www

Votre navigateur accède au contenu interprété de /var/www par l'adresse http://localhost

Si Apache a été installé séparément avant les autres applications, il ne prendra en compte PHP et MySQL qu'après suEn mode super-utilisateur: su [Enter] /etc/init.d/apache2 restart ou un reboot de votre système.

Notes:

2. Généralités

2.1 Particularités syntaxiques

Pour programmer en php, il suffit d'utiliser un simple éditeur de texte, tel le blocnote de Windows. Il existe de meilleurs éditeurs de scripts, qui offrent une coloration syntaxique (les mots-clés se colorent automatiquement). Sous Linux nano, kwrite pour KDE ou Gedit pour Gnome... Cela donne par exemple (couleurs personnalisées):

<?php // ce script donne la date du jour

$date=date("d-m-Y");
echo "<html><body><p>Nous sommes le $date</p></body></html>";

?>

La syntaxe PHP est celle du C, mais le séparateur entre fonctions/expressions, le point-virgule, est obligatoire en fin de ligne, même en fin de { bloc; } (mais reste interdit après une comparaison). Par exemple:

$a=rnd(10);
if ($a>5)
 {
  echo "$a est plus grand que 5";
 }

Sont considérés comme commentaires ce qui est compris entre /* et */, ou ce qui se trouve à droite de // ou # (si ces caractères ne sont pas contenus dans une chaîne de caractères)

Comme la finalité habituelle de ce langage est la production de pages html, il existe une fonction d'affichage très simple:

echo '<h1>Un titre</h1>';

Grosse différence avec le C ou d'autres langages, la concaténation (assemblage) de chaînes est indiquée par un point:

$chaine1="Hello"; $chaine2="World!"
echo $chaine1.' '.$chaine2;

Si la chaîne est définie par des guillemets doubles, on peut simplifier l'expression par l'inclusion de variables dans la chaîne finale:

echo "$chaine1 $chaine2";

Les caractères de contrôle, tels que \n (retour à la ligne) seront interprétés comme tels si la chaîne est entourée de guillemets doubles, et \n dans des guillemets simples.

echo "123\n456".'abc\ndef';

donnera

123
456abc\ndef

Attention: echo "Réponse: '$var'" interprétera la variable, étant donné que les 'guillemets simples' sont de simples caractères appartenant à la chaîne délimitée par des guillemets doubles. Il est par ailleurs possible d'afficher des guillemets doubles dans une chaîne délimitées par des guillemets double en les «échappant» (protégeant) par la barre inverse \:

echo "Réponse: \"$var\"";

Les ` ` (guillemets graves) permettent une commande shell. Il est possible de récupérer la sortie console de la commande. En UNIX,

$rep=`ls -l`; echo nl2br($rep);

liste avec détail le répertoire courant (nl2br remplace les retours à la ligne par des <br>).

2.2 Constantes et variables

Les constantes permettent de stocker et de rappeler une valeur invariable:

define(PI,3.1416) permet votre définition du rapport pi à 5 chiffres significatifs
define(tag,"Le Vengeur Masqué") permet de signer par un simple echo tag;
defined(tag) est vrai si la constante est définie

Les variables, de quelque type qu'elles soient, commencent par le signe $. L'assignation se fait au moyen d'un simple signe 'égal': $var=valeur;
unset($var) détruit la variable $var
isset($var) est vrai si la variable $var existe bien

Les $i++, $i--, $n+=3, $ch.='t' etc. sont d'application
++$var incrémente la variable avant son utilisation
--$var décrémente la variable avant son utilisation

Contrairement au langage C, une variable peut changer de nature:

$i=123; $i=strlen($i); echo $i;

PHP est très souple: $chaine.=2 concaténera et $nombre+="2" additionne si $nombre représente un nombre.

$new=$var assignation par valeur: copie la valeur de $var dans $new
$new=&$var assignation par référence: la valeur de $new variera en même temps que $var

2.3 Booléens TRUE et FALSE

Une condition ou une boucle permet l'exécution d'une portion de code selon l'évaluation d'une expression. On utilise le plus souvent une comparaison, par exemple $a<3, $a>3, $a==3, $a<=3, $a>=3, $a<>3 ou $a!=3 (différence), $a===3 (identité: valeur et type de variable doivent être égaux). L'expression 3=="3" est vraie (valeur booléenne TRUE, true ou trUe...), mais 3==="3" est faux (FALSE, false, fAlse...). 3!=="3" (types différents) est vrai.

Il est également intéressant de noter que 0==FALSE est vrai mais que 0===FALSE est faux, ce qui permet de faire la différence entre le renvoi de la valeur 0 et le renvoi de la valeur FALSE:

if(strpos("abcde","a")!==FALSE) { echo "a est bien contenu dans la chaine"; }

is_bool() est vrai si l'expression est booléenne
gettype() rend boolean si la valeur est booléenne

On peut convertir des valeurs en booléen. $var=(bool) val affectera false à $var si val est 0, 0.0, "0", "", null ou un tableau vide, et true pour toute autre expression.

Il est de plus possible de composer des comparaisons avec AND, OR, XOR ou ! (NOT):

2.4 Conditions if et switch

Ce qui suit est très classique: rappel seulement.

if(condition)
  { instructions si la condition est remplie; }
elseif(autre-condition)
  { sinon, d'autres instructions si "autre-condition" est remplie; }
else
  { instructions pour tous les autres cas; }

Il existe une syntaxe simplifiée if / else (sans elseif):

(condition) ? instructions-si-vrai : instructions-si-faux;

switch / case permet un codage court d'une condition multiple

switch($var) // concerne la variable $var
  {
  case valeur1: instruction1; break; // valeur1 est un nombre, une chaine...
  case valeur2: instruction2; break;
  case valeur3: instruction3; break;
  }

2.5 Boucles for, while et do

Ce qui suit est très classique: rappel seulement.

for(initialisation;condition-de-maintien;instruction-de-fin-de-cycle) { bloc-d'instructions; }

for($x=1,$y=10; $x<$y; $x++)  // $x vaut 1, $y vaut 10 ; tant que $x < $y
  {
  echo $y/$x."\n";            // on affiche la réponse de $y/$x et un retour à la ligne
  }                           // $x est incrémenté à la fin de chaque cycle

while(condition) { instructions; } commence la boucle si la condition est vérifiée et la maintient tant que la condition est respectée. Il faut s'assurer le cas échéant qu'il est possible de la quitter.
do { instructions; } while(condition) l'instruction ne vérifie la condition qu'à la sortie, la boucle est donc parcourue au moins une fois.
break interrompt une boucle; break n sort de n boucles imbriquées

Il existe encore la boucle foreach, spécifique aux tableaux.

2.6 Fonctions de l'utilisateur

Mathématiquement, une fonction renvoie au plus une valeur. C'est donc par abus de langage que l'on nomme pareillement les portions de codes isolés et appelables d'un autre endroit du script. Les fonctions peuvent être définie plus bas que la ligne qui y fait appel. Classiquement, on leur envoie des paramètres et on récupère une valeur définie après return:

function hypothenuse($c1,$c2)
  {
  return sqrt(pow($c1,2)+pow($c2,2));
  }
echo hypothenuse(4,3);

Elles peuvent ne pas prendre de paramètres, ne rien retourner comme valeur mais effectuer une tâche (ouvrir un fichier, afficher quelque chose):

function hou()
  {
  echo "hibou!";
  }
hou(); // appel de la fonction

Une fonction peut s'appeler elle-même (récursivité). L'exemple suivant, très classique, a l'intérêt de montrer qu'il peut y avoir plusieurs return dans une fonction:

function factorielle($var)
  {
  if($var<2) { return 1; }
  return $var*factorielle($var-1);
  }
echo factorielle(7);

La fonction prend la valeur 7 et la retourne en la multipliant par factorielle(6), qui elle même vaut 6 multiplié par factorielle(5)... jusqu'à factorielle(1), qui retourne 1 (surtout ne pas oublier cette condition de sortie!).

Variables globales et statiques

Une variable définie dans le script n'est pas a priori accessible à l'intérieur d'une fonction. Le script suivant n'affichera quelque chose que si l'on précise avec global $a que la variable y est également valable:

$a="hibou!"; hou();

function hou()
  {
  global $a;
  echo $a;
  }

Par ailleurs, déclarer une variable dans une fonction l'oblige à se réinitialiser à chaque appel. Pour retrouver à chaque appel la valeur acquise précédemment, il est nécessaire de l'initialiser avec static. La fonction qui suit incrémente $a chaque fois que $var n'est pas nul:

fusnction compteur($var);
  {
  static $a=0;
  if($var) { $a++; }
  return $a;
  }

2.7 Gestion des erreurs

Voir ici en attendant la suite.

die() ou exit() interrompt un script. Il est possible de prévoir une interruption et message en cas d'erreur:

$nombre=1/0 or die("Erreur majeure!");

Mieux! il est possible de prévoir ses propres exceptions:

<?php

function erreur43()
  {
  echo "Quelque chose de très grave s'est passé\n";
  }

$resultat=1/0 or erreur43();
echo "Mais tout va bien";

?>

3. Variables numériques

En général, on finit par devoir afficher les résultats de calcul, et on apprécie de pouvoir formater la sortie des résultats (limiter le nombre de décimales, séparer les milliers...):

number_format(nombre,n,d,m) retourne une chaîne formatée, n pour le nombre de décimales, les deux derniers paramètres précisent le caractère séparateur décimal (par défaut: point) et celui des milliers (par défaut: virgule). Pour les latins, il s'agit respectivement de ',' et de '.', mais l'espace est actuellement recommandé pour la séparation des milliers (pour l'espace insécable en html: '&nbsp;').

3.1 Types de nombres

Parce que le langage PHP n'est pas fortement typé (une variable peut contenir une chaîne, puis un nombre), il est parfois nécessaire de connaître le type de la valeur contenue dans la variable.

gettype() retourne la nature d'une variable ou constante: boolean, string, integer (limites d'un 32 bits signé) , double (hors de ces limites ou non-entiers), NULL si la variable n'est pas été définie, string pour une fonction utilisateur ou une chaîne non délimitée par des guillemet...

Teste (et renvoie 1 si vrai; une chaîne vide si faux):

is_bool() (rappel) si l'expression est booléenne
is_int(), is_long() ou is_integer() est vrai si l'expression représente un entier
is_numeric() est vrai si l'expression représente un entier ou non-entier, également sous forme de chaîne
is_float(), is_double() ou is_real() est vrai si l'expression est non-entière
is_scalar() est vrai si l'expression est booléenne, entière, non-entière ou une chaîne
is_finite() est vrai si l'expression est finie
is_infinite() si l'expression est infinie (log(0), mais pas 1/0!?)
is_null() si l'expression est nulle (NULL, mais pas 0 ni "")
is_nan() est vrai si l'expression n'est pas un nombre (not a number)

3.2 Opérations sur les nombres

Les quatre opérations classiques s'organisent comme on a appris à l'école.

n%d retourne le reste de la division entière (modulo) de n par d: 8 % 3 retourne 2
fmod(r,d) étend l'opérateur % aux réels: fmod(8.3,3.1) retourne 2.1
nbre<<n retourne le nombre décalé de n rangs vers la gauche: multiplication par 2 exposant n
nbre>>n retourne le nombre décalé de n rangs vers la droite: division entière par 2 exposant n

abs(reel) retourne la valeur absolue d'un nombre
max(n1,n2,n3...) ou max(array(n1,n2,n3...)) retourne la plus grande des expressions
min(n1,n2,n3...) ou min(array(n1,n2,n3...)) retourne la plus petite des expressions

3.3 Puissances et logarithmes

sqrt(n) retourne la racine carrée d'un nombre positif
pow(n,p) retourne le résultat de n à la puissance p
log10(n) retourne le logarithme en base 10

exp(n) retourne le résultat de e (2.71828182846...) à la puissance n
expm1(n) retourne le résultat diminué de 1 de e à la puissance n
log() retourne le logarithme naturel (base e)
log1p() retourne le logarithme naturel d'un nombre préalablement augmenté de 1

3.4 Arrondis

floor(reel) retourne un entier à partir d'un réel arrondi par défaut (au nombre inférieur)
ceil(reel) retourne un entier à partir d'un réel arrondi par excès (au nombre supérieur)
round(reel) retourne un nombre entier selon les règles de l'arrondi
round(reel,n) retourne un nombre arrondit à la nème décimale
number_format(nombre,n,d,m) retourne une chaîne formatée, n pour le nombre de décimales, les deux derniers paramètres précisent le caractère séparateur décimal (par défaut: point) et celui des milliers (par défaut: virgule). Pour les latins, il s'agit respectivement de ',' et de '.', mais l'espace est actuellement recommandé pour la séparation des milliers (pour l'espace insécable en html: &nbsp;).

La différence entre ces deux derniers est que round() retourne un nombre, ce qui ne garantit pas le nombre de décimales: round(3.4,2) retourne le nombre 3.4 tandis que number_format(3.4,2) retourne la chaîne 3.40

3.5 Trigonométrie

pi() retourne la valeur de pi (12 chiffres)
hypot(c1,c2) retourne l'hypoténuse à partir des deux côtés formant l'angle droit

En général, on connaît les fonctions qui suivent si on en a besoin. Attention aux limitations du domaine de définitions pour certaines d'entre elles.

sin(), cos(), tan() et les fonctions inverses acos(), asin() et atan().

sinh(), cosh(), tanh() et les fonctions inverses asin(), acosh() et atanh().

atan2(y,x) retourne l'angle de la pente pour l'accroissement x en abscisse et y en ordonnée.

Tous ces calculs sont effectués en radians:

deg2rad($deg) retourne la valeur en radian d'un angle exprimé en degrés
rad2deg($rad) retourne l'expression en degrés d'un angle en radian

3.6 Bases et conversions

Il existe d'autres bases que le décimal:

0123 un nombre commençant par 0 (sans chiffre 8 ou 9) sera considéré comme de base octale. 123 = 1*8*8+2*8+3=83
0x123 un nombre commençant par 0x sera considéré comme de base hexadécimale. 123 = 1*16*16+2*16+3=291. On utilise les chiffres a, b, c, d, e, f pour les valeurs 10, 11, 12, 13, 14, 15.

decbin() retourne un nombre binaire à partir d'un entier décimal
bindec() retourne un nombre décimal à partir d'un entier binaire
dechex() retourne un nombre hexadécimal à partir d'un entier décimal
hexdec() retourne un nombre décimal à partir d'un entier hexadécimal
decoct() retourne un nombre octal à partir d'un entier décimal
octdec() retourne un nombre décimal à partir d'un entier octal

base_convert(n,b1,b2) interprète un nombre selon la base b1 et le convertit selon la base b2:

echo base_convert(13,12,2);

13 = 1*12+3 = 15, converti en binaire 1111

3.7 Fonctions pseudo-aléatoires

Le hasard étant produit par un algoritme, on ne peut le qualifier de véritablement aléatoire.

lcg_value renvoie un nombre réel aléatoire entre 0 et 1, avec une précision de 14 chiffres.

getrandmax() retourne la plus grande valeur aléatoire possible, ce qui dépend de la machine ou du système d'exploitation
srand() (inutile depuis PHP4.10) réinitialise le générateur de nombres aléatoires
rand() retourne une valeur aléatoire jusque le nombre contenu dans getrandmax()
rand(inf,sup) retourne une valeur aléatoire entre inf et sup (compris)

mt_getrandmax(), mt_rand() et mt_srand() sont des fonctions de luxe

Voir str_shuffle pour le mélange de chaînes et shuffle pour le mélange de tableaux.

4. Chaînes

L'affectation d'une chaîne se fait par $var='des caractères'. L'utilisation de guillemets doubles permet l'interprétation de variables ou de caractères échappés: $a="Ho"; echo "$a\n$a"; sortira

Ho
Ho

alors que $a="Ho"; echo '$a\n$a'; sortira

$a\n$a

Les caractères échappés sont:

\0 octet vide
\n nouvelle ligne, quel que soit le système
\r retour chariot, sans passer à la ligne suivante
\t tabulation (tous les 8 caractères)
\x07 =chr(7) beep de 0,1 seconde (ne sert à rien de le répéter avant la fin)
\x0a =chr(10) Mac et Windows: comme \x0b; UNIX: nouvelle ligne
\x0b =chr(11) une ligne plus bas (sans retour chariot)
\x0d =chr(13) UNIX et Windows: retour chariot; Mac: nouvelle ligne

Il existe également la façon HereDoc, qui, comme les guillemets doubles, évalue les variables et les échappements:

$var="liberté";
$chaine=<<<MON_TEXTE
Un texte écrit avec\nbeaucoup de $var,
et un retour à la ligne
MON_TEXTE;
echo $chaine;

Depuis PHP5.3, il existe également la façon NowDoc, qui n'évalue ni les variables ni les échappements (comme pour les chaînes définies avec ' ')

$var="liberté";
$chaine=<<<'MON_TEXTE'
Un texte écrit avec\nbeaucoup de $var
MON_TEXTE;
echo $chaine;

Rappel: la concaténation se fait avec le point: $a.$b, $a.=$b
str_repeat($ch,n) retourne une chaîne répétée n fois

chr(n) retourne le caractère correspondant au rang ASCII précisé
ord('c') retourne le rang ASCII d'un caractère (ou le premier d'une chaîne)

is_string() est vrai si l'expression est une chaîne
is_unicode() est vrai si l'expression est une chaîne unicode
is_scalar() est vrai si l'expression est booléenne, entière, réelle ou une chaîne

4.1 Comptage

strlen retourne la taille d'une chaîne, en nombre de caractères
str_word_count retourne le nombre de mots d'une chaîne (séparateurs: espace et ponctuation)
substr_count($chaine,$segment) retourne le nombre d'occurrences de $segment dans une $chaîne
count_chars($chaine,n) compte les caractères d'une chaîne. n peut valoir:
  · 0 retourne un tableau contenant le nombre d'occurrences de chaque lettre (classement ASCII)
  · 1 retourne un tableau, mais les valeurs n'existent que si supérieures à 0
  · 2 retourne un tableau, mais les valeurs n'existent que si égales à 0
  · 3 retourne la chaîne des caractères trouvés dans la chaîne initiale
  · 4 retourne la chaîne des caractères non trouvés dans la chaîne initiale

4.2 Transformation de chaînes

strrev($ch) retourne une chaîne inversée
str_shuffle($ch) retourne la chaîne avec ses caractères mélangés de façon pseudo-aléatoire

wordwrap($ch1, n, "c", TRUE) provoque une césure à partir de 75 caractères si n n'est pas défini, par "\n" si un caractère n'est pas défini, et coupe le mot au caractère près si TRUE est précisé.

strtolower($chaine) retourne une chaîne convertie en minuscules
strtoupper($chaine) retourne une chaîne convertie en majuscules
ucfirst($chaine) retourne une chaîne dont le premier caractère est converti en majuscule
ucwords("plusieurs mots") retourne une chaîne dont le premier caractère de chaque mot est converti en majuscule
lcfirst($chaine) devrait retourner une chaîne dont la première lettre serait en majuscule à partir de la fin

trim($ch,"chaine") retourne une chaîne après suppression de certains caractères aux extrémités. Par défaut: espace, \n (fin de ligne), \t (tabulation), \r (retour chariot), \0 (octet vide), \x0B (tabulation verticale) - "chaine" permet de définir les caractères à éliminer
ltrim($ch,"chaine") idem, en début de chaîne
rtrim($ch,"chaine") ou chop($ch,'c') idem, en fin de chaîne
str_pad($ch,n,c,p)? retourne une chaîne étendue à n caractères, c est le caractère de remplissage (espace par défaut), p peut être STR_PAD_RIGHT (par défault), STR_PAD_LEFT ou STR_PAD_BOTH

4.3 Comparaisons de chaînes

strcmp($ch1,$ch2) retourne un nombre -1 si $ch1 se classe avant $ch2, 1 dans le cas contraire, 0 si $ch1==$ch2, sans tenir compte de la casse. Si une chaîne est le début de l'autre, le nombre retourné révèle la différence du nombre de caractères
strncmp($ch1,$ch2,n) comme strcmp, mais en limitant la comparaison aux n premiers caractères
strcasecmp comparaison de chaînes sensible à la casse
strncasecmp($ch1,$ch2,n) comme strcmp, mais en limitant la comparaison aux n premiers caractères
strnatcmp($ch1,$ch2) comparaison "naturelle" ('du pont'=='dupont')
strnatcasecmp($ch1,$ch2) idem, insensible à la casse

substr_compare($ch1,$ch2,n,l,TRUE) retourne un nombre -1 si $ch1 se classe avant $ch2, 1 dans le cas contraire, 0 si $ch1==$ch2, en considérant $ch1 à partir de l'offset n. Si n est négatif, on compte l'offset à partir du dernier caractère. On peut préciser une longueur et TRUE pour l'insensibilité à la casse.

levenshtein retourne la distance Levenshtein, nombre minimal de remplacements, retraits et ajouts pour tranformer une chaîne entre une autre
similar_text retourne une autre similarité entre deux chaînes (méthode Olivier: à première vue la longueur de la chaîne moins le nombre de transpositions et de disparitions)

soundex($ch) retourne la clé soundex (4 caractères), basée sur la prononciation d'un mot
metaphone retourne la clé metaphone, fonction similaire à soundex

4.4 Opération sur des parties de chaînes

strpos($ch,$ssch,n) retourne la position de $ssch dans $ch à partir d'un éventuel départ, ou FALSE.
stripos() est insensible à la casse, strrpos() à partir de la fin, strripos() combine les deux.

strstr($ch, $ssch) ou strchr() retourne la chaîne après avoir retiré ce qui est à gauche de sous-chaîne
stristr() est insensible à la casse
strrchr($ch1,$ch2) retourne les caractères de $ch1 à partir de la dernière occurrence de $ch2

substr($chaine,deb,n) retourne tous les caractères (ou n si défini) à partir de la position deb
strpbrk($chaine,$ch) (PHP5) retourne une sous-chaîne à partir du premier caractère de $chaine contenu dans $ch

str_replace($occ,$rempl,$chaine,n) remplace chaque occurrence d'une chaîne (en limitant éventuellement à n fois)
str_ireplace même fonction, insensible à la casse

substr_replace($chaine,$rempl,n,l) remplacement dans une chaîne à partir de la position n jusqu'à la fin ou L octets

substr_replace('abcdefghij','123',2); // donne ab123
substr_replace('abcdefghij','123',2,5); // donne ab123hij
substr_replace('abcdefghij','123',2,0); // donne ab123cdefghij

strtr($chaine,$c1,$c2) remplace les caractères d'une $chaine selon les caractères respectifs de $c1 par ceux de $c2

echo strtr("ici","ci","HP") // donnera PHP

strtr($chaine,$tab) remplace des portions de chaînes de caractères selon un tableau associatif

$rempl=array('e'=>'SPA',"ggs"=>"M"); echo strtr("eggs",$rempl) // donnera SPAM

strspn($ch1,$ch2,n1,n2) rend la longueur de la chaîne uniquement composée avec les caractères de $ch2, à partir de 0 ou n1 et jusqu'à la fin ou durant n2 caractères)
strcspn($ch,$car) donne la taille du premier segment de chaîne ne contenant pas certains caractères; éventuellement à partir d'une position sur une longueur

4.5 Transformation HTML

quotemeta($ch) échappe les caractères \ + . ? * ^ [ ] $ ( )
addslashes($chaine) échappe certains caractères ( ' ) avec l'antislash \'
addcslashes($chaine,"car") permet de choisir le(s) caractère(s) à échapper
stripslashes($ch) élimine les \ d'une chaîne (par exemple pour les produits d'un post)
stripcslashes($ch) comme stripslashes, mais respecte les \n, \r...

nl2br($ch) retourne une chaîne où chaque retour de chariot (\n) est remplacé par <br>
htmlspecialchars($chaine,ENT_*) transforme certains caractères sensibles en équivalents HTML:
    & est codé &amp;  -   '<' est codé &lt;   -   '>' est codé &gt; dans tous les cas
    " est codé &quot; par défaut, ou si ENT_COMPAT est précisé
    ' est codé &#039; seulement si ENT_QUOTES est utilisée
    ENT_NOQUOTES désactive le codage des guillemets simples et doubles
htmlspecialchars_decode transforme certains les entités HTML ci-dessus en caractères
htmlentities($string,$ENT,$charset,$double_encode) extension de la précédente
    ISO-8859-1 = Latin-1 ; ISO-8859-15 = extension du précédent (Euro... caractères spéciaux finlandais)
    UTF-8 Unicode 8 bits, compatible avec l'ASCII
html_entity_decode($chaine,$ENT_,$charset) inverse de la précédente
strip_tags($ch) élimine les balises HTML d'une chaîne
$tab=get_html_translation_table() retourne un tableau associatif des traductions des entités utilisées par htmlspecialchars et htmlentities ($tab["<"]...)

urlencode($str) transforme tout caractère sauf alphanumériques, point, tiret et souligné, en séquences %nn (hexadécimal)
urldecode($str) transforme les séquences %nn en leurs caractères correspondant

4.6 Conversions

str_split($chaine,n) (PHP5) débite une chaîne dans un tableau par tranche de n caractères (1 par défaut)
chunk_split($chaine,n,'c') décompose une chaîne en un tableau de caractères, ajoutant 'c' tous les n cellules
$tab=explode("ch",$chaine) débite une chaîne dans un tableau indexé selon le délimitateur 'ch' (qui disparaît)
$chain=implode("ch",$tab) ou join() rassemble un tableau en une chaîne, en insérant une éventuelle chaîne entre les éléments
strtok($chaine,"c") détache des morceaux de chaîne, le premier appel seul doit comporter la chaîne initiale:

echo strtok("azertyuiop","r")."\n";  //  détache jusqu'à 'r': retourne 'aze'
echo strtok("u")."\n";  // reste "tyuiop", détache jusqu'à 'u': retourne 'ty'
echo strtok("p")."\n";  // reste "iop", détache jusqu'à 'p': retourne 'io'

4.7 Encodage et contrôle

base64_encode($chaine) et convert_uuencode($chaine) encode une chaîne selon l'algoritme choisi (6 bits sont encodés en un caractère 8 bits imprimable)
base64_decode et convert_uudecode processus inverse
str_rot13($ch) change les lettres d'une chaîne (+13): A<->N, B<->O... t<->f... (processus réversible)

crc32(), md5(), sha1() et md5_file(), sha1_file() calculent différentes sommes de contrôle pour des chaînes ou des fichiers.

4.8 Expressions régulières

Pour rappel, les expressions régulières sont une extension du principe des jokers ? et * qui remplacent des (groupes de) lettres. Plus d'explications à la page modules python.

glob("modele") retourne un tableau des chemins/fichiers correspondant à l'expression régulière (exemple: "re*.php")
fnmatch("expr",$chaine) est vrai si la chaîne est compatible avec l'expression régulière précisée

ereg("modele",$chaine,$tab) est vrai si la $chaine correspond à "modele" modèle; $tab[0] contient la chaîne testée, $tab[1], $tab[2]... les parties de la chaîne correspondant aux parenthèses capturantes du modèle
eregi("modele",$chaine,$tab) idem, mais insensible à la casse

ereg_replace("modele","rempl",$chaine) permet le remplacement de toutes les occurrences de chaine correspondant à "modele" par la chaîne rempl
eregi_replace("modele","rempl",$chaine) idem, mais insensible à la casse
split("modele",$chaine,n) retourne un tableau (éventuellement limité à n éléments) constitué des morceaux d'une chaîne découpée par une expression régulière
spliti("modele",$chaine,n) idem, mais insensible à la casse
sql_regcase("chaine") retourne, à partir d'une simple chaîne, un pattern insensible à la casse

Les fonctions suivantes sont plus rapides et doivent se conformer à la syntaxe Perl (par exemple, les chaînes de modèles commencent et se terminent par '/'). Voir php.net: ref.pcre.php:

preg_match("modele",$chaine,$tab,PREG_OFFSET_CAPTURE,n) est vrai si le modèle correspond à une partie de la chaîne, $tab contient alors la portion de chaîne trouvée, le paramètre permet d'en connaître l'offset, et n est le premier caractère de la chaîne à être testé
preg_match_all voir php.net: preg-match-all
preg_grep("modele",$tableau,PREG_GREP_INVERT) retourne un tableau composé de tous les éléments du tableau de chaînes précisé satisfaisant au modèle (PREG_GREP_INVERT pour filtrer les éléments qui ne satisfont pas au modèle)
preg_quote(chaîne"c") retourne une chaîne où les caractères suivant sont§ échappés: . \ + * ? [ ^ ] $ ( ) { } = ! < > | :, un délimiteur autre que '\' est possible
preg_split(modele,chaine,n,param) retourne un tableau des morceaux provenant de la chaîne découpée selon des sous-chaînes correspondant à un modèle d'expression régulière. n permet de limiter à n occurrences, -1 obligatoire pour pouvoir ajouter les paramètres complémentaires: PREG_SPLIT_NO_EMPTY permet d'éviter les éléments vides.

preg_replace(modele,rempl,expr,n,cnt) retourne une chaîne ou un tableau de chaînes (selon la nature de expr) où les parties de chaîne(s) correspondant à l'expression régulière modele sera remplacée par la chaîne rempl. n limite le nombre de remplacement et la variable $cnt retourne le nombre de remplacement effectués. Si modele est un tableau, chacun de ses éléments sera un modèle à remplacer par la chaîne rempl dans expr, ou par la chaîne correspondante du tableau rempl.

4.9 À traiter

crypt, convert_cyr_string, hebrev, hebrevc, localeconv, nl_langinfo, setlocale, strcoll, parse_str, str_getcsv, print, printf, fprintf sprintf, vprintf, vfprintf, vsprintf, money_format, quoted_printable_decode, sscanf...

5. Tableaux

Pour les conversions chaînes/tableaux, voir Conversions

Il existe deux sortes de tableaux en PHP, les tableaux conventionnels, numériquement indexés, où les éléments sont classés en file indienne, et les tableaux associatifs, où les éléments sont accessibles par une clé.

var_dump($tab) permet l'affichage des valeurs d'un tableau (echo $tab; donne Array)

5.1 Tableaux numériquement indexés

Un tableau indexé est un ensemble de valeurs accessibles selon leur numéro d'ordre.

$tab=array(3,1,4,1,6) crée le tableau $tab de cinq éléments: $tab[0] vaut 3, $tab[1] vaut 1, $tab[2] vaut 4, $tab[3] vaut 1 et $tab[4] vaut 6. Il est possible de redéfinir chaque élément - pour le deuxième: $tab[1]=8 - ou d'ajouter un élément en fin de tableau - par exemple: $tab[]=77

La boucle foreach() permet de parcourir tous les éléments d'un tableau indexé:

$tab=array(1,3,5,7,9); $n=0;
foreach($tab as $val)
  { echo "tab[$n] = $val\n"; $n=$n+1; }

range(deb,lim,pas) crée un tableau de valeurs numériques commençant à deb, s'accroissant de pas jusqu'à lim (non compris)
in_array(valeur,$tableau) retourne TRUE si le tableau contient la valeur

5.2 Tableaux associatifs

Un tableau associatif est un ensemble de valeurs accessibles par des clés. Lors d'une définition d'un tableau associatif ou lors d'un ajout, il faut toujours spécifier une clé et une valeur:

$tab=array('egg'=>'oeuf','eggs'=>"oeufs","spam"=>"C'est quoi, ça?",9=>"neuf") crée le tableau de quatre éléments $tab: $tab[egg] vaut 'oeuf', etc. Attention: pour ajouter un nouvel élément, il faut préciser une nouvelle clé, par exemple: $tab['huit']=8 . Une même clé ne peut avoir qu'une valeur, mais plusieurs clés peuvent avoir la même valeur.

La boucle foreach permet de parcourir tous les éléments (pas les clés) d'un tableau associatif:

$tab=array(3=>'trois',5=>'cinq',7=>'sept',9=>'neuf');
foreach($tab as $cle => $val)
  { echo "$cle => $val\n"; }

array_key_exists(cle,$tableau)) renvoie TRUE si la clé existe dans un tableau
in_array(valeur,$tableau) retourne TRUE si le tableau contient la valeur

Il ne faut pas surestimer la différence entre tableau indexé et tableau associatif:

$tableau=array(3,1,4); // tableau indexé de trois éléments, de $tableau[0] à $tableau[2]
$tableau[99]="16";
echo var_dump($tableau);

apparaîtra comme un tableau associatif, avec pour clés 0, 1, 2 et 99.

array(4) {
  [0]=>
  int(3)
  [1]=>
  int(1)
  [2]=>
  int(4)
  [99]=>
  string(2) "16"
}

5.3 Comptages

count($tab) ou sizeof($tab) retourne le nombre d'éléments d'un tableau
array_sum($tab) retourne la somme des valeurs numériques d'un tableau (ce qui n'est pas un nombre vaut 0, TRUE vaut 1)
array_product($tab) retourne le produit des valeurs d'un tableau (ce qui n'est pas un nombre vaut 0, TRUE vaut 1)
$cpt=array_count_values($tab) retourne un tableau associatif dont les clés sont les valeurs du tableau initial et les valeurs leurs fréquences.

5.4 Opérations sur tableaux

array_fill(deb,n,val) crée un tableau de n éléments de la valeur spécifiée à partir de l'index deb
array_fill_keys($tab,val) crée un tableau associatif à partir d'un tableau de valeurs qui deviendront les clés
array_combine($cle,$val) crée un tableau associatif (attention aux doublons de $cle)
array_flip($tab) retourne un tableaux où clés et valeurs sont inversées (attention au valeurs répétées)
array_values($tab) retourne un tableau réindexé des valeurs d'un tableau
array_chunk($tab,n,TRUE) découpe un tableau en sous-tableaux de dimension n, TRUE permet de conserver les clés si le tableau de départ est associatif
array_merge($t1,$t2) fusionne plusieurs tableaux (perd les clés)
array_unique retourne un tableau purgé de ses doublons

5.5 Modification de tableaux

array_push($tab,element1,element2...) ajoute un ou plusieurs éléments en fin de tableau indexé
$var=array_pop($tab) retourne et élimine le dernier élément d'un tableau
$var=array_shift($tab) retourne et élimine le premier élément d'un tableau
array_unshift($tab,element1,element2...) ajoute un ou plusieurs éléments au début d'un tableau
array_rand($tab,n) retourne au hasard un index possible d'un tableau, ou un tableau d'index au hasard si un nombre est précisé
array_slice($tab,début,long,TRUE) retourne une portion de tableau, définie par un début et une longueur. TRUE (facultatif) permet de ne pas déranger les clés
$tab2=array_splice($tab,début,long,$tabrempl) efface une portion de tableau indexé et (facultatif) la remplace par un autre tableau
$tab=array_pad($tab,long,val) étend un tableau à la longueur voulue avec une valeur. si la longueur est négative, le remplissage se fait au début de tableau

list(va,ri,ab,le,s)=$tab une liste de variables récupère des données d'un tableau

$tab=array('enclumier','chinchard','GB','amphibie','listes');
list(,$a,$b,,$c)=$tab;   // il n'est pas obligatoire de tout prendre
echo "$a $b $c\n";       // il en ressort "chinchard GB listes"

$tab=array_change_key_case($tab,CASE_UPPER) convertit les clés d'un tableau (CASE_LOWER par défaut)
if(array_key_exists('cle',$tab)) est vrai si la clé est contenue dans un tableau
$var=array_keys($tab) retourne un tableau indexé de toutes les clés d'un tableau associatif

if(in_array($val,$tab)) vrai si la valeur appartient au tableau
array_search(val,$tab) retourne la première clé ou index associé-e à la valeur

5.6 Déplacements dans un tableau

current($tab) ou pos($tab) contient l'élément courant du tableau
key retourne la clé courante d'un tableau associatif
each retourne l'association clé/valeur courante, sous forme de tableau. L'index 0 ou la clé 'key' retourne la clé, l'index 1 ou la clé 'value' retourne la valeur

reset($tab) réinitialise le pointeur de tableau (à zéro) et retourne l'élément du tableau
next($tab) avance le pointeur d'un tableau et retourne l'élément du tableau
prev($tab) recule le pointeur d'un tableau et retourne l'élément du tableau
end($tab) positionne le pointeur de tableau en fin de tableau et retourne l'élément du tableau

5.7 Tris de tableaux

sort($tab) trie un tableau indexé en ordre ascendant des valeurs
rsort trie un tableau en ordre descendant des valeurs

asort trie un tableau selon les valeurs (garde les associations clé/valeur)
arsort trie un tableau selon les valeurs en sens inverse

ksort trie un tableau selon les clés (garde les associations clé/valeur)
krsort trie un tableau selon les clés en sens inverse

natsort trie un tableau selon les règles du bottin: "deauville" avant "de paris"
natcasesort idem, insensible à la casse

uasort, uksort et usort permettent un tri selon une fonction-utilisateur: usort($tab, "votre_fonction"). Cette fonction doit posséder deux arguments et renvoyer -1, 0 ou 1 selon que la fonction considère que le premier argument est plus petit, égal ou plus grand que le second. Cela permettrait par exemple d'améliorer le tri "naturel" des noms: "d'outremont" après "doultremont".

$tab=array_reverse($tab) inverse l'ordre des éléments d'un tableau
shuffle($tab) retourne le tableau aux éléments mélangés de façon pseudo-aléatoire

array_multisort($t1,p,$t2) trie le premier tableau et modifie les suivants en fonction des reclassements du premier. p peut prendre les valeurs SORT_ASC, SORT_DESC, SORT_REGULAR, SORT_NUMERIC, SORT_STRING

5.8 Opérations ensemblistes

array_diff($t1,$t2) retourne un tableau des éléments que l'on trouve dans $t1 mais pas dans $t2
array_diff_key($t1,$t2) retourne un tableau dont les clés se trouvent dans $t1 mais pas dans $t2
array_diff_assoc($t1,$t2) retourne un tableau des éléments dont les associations clés/valeurs se trouvent dans $t1 mais pas dans $t2

array_intersect($t1,$t2) retourne un tableau des valeurs retrouvées dans les deux tableaux
array_intersect_key($t1,$t2) retourne un tableau des éléments dont les clés se trouvent dans $t1 et dans $t2. Si la même clé a deux valeurs différentes, la valeur du premier tableau prévaut
array_intersect_assoc($t1,$t2) retourne un tableau des éléments dont les associations clé/valeurs se trouvent dans $t1 et dans $t2

5.9 Non traité

extract, compact, array_map, array_walk, array_merge_recursive, array_reduce, array_filter

6. Fichiers

Rappelons qu'en UNIX, les répertoires et les partitions (et même les processus) sont considérés comme des fichiers.

6.1 Gestion de fichiers et répertoires

On suppose que les notions de chemin relatif et absolu sont connus.

rename("avant","ensuite") renomme un fichier (renommer le chemin le fait déplacer)
copy("fichier","autre") copie un fichier (autre nom ou autre chemin et nom)
delete("fichier") ou unlink("fichier") détruit un fichier

file_exists() est vrai si l'expression désigne un fichier ou répertoire existant
is_file() est vrai si l'expression représente un fichier
is_binary()est vrai si l'expression représente un fichier binaire
is_buffer()est vrai si l'expression représente un fichier binaire ou unicode
is_dir() est vrai si l'expression représente un répertoire
filetype() retourne dir, file, link...

basename(cheminfichier) retourne le nom d'un fichier ou répertoire
dirname(cheminfichier) retourne le chemin d'un fichier ou répertoire
realpath(fichier) retourne le chemin complet d'un fichier (basename+dirname)
mkdir(chaine) fabrique un répertoire dans le répertoire courant ou dans le chemin indiqué
rmdir(path) détruit un répertoire dans le répertoire courant ou dans le chemin indiqué var_dump(pathinfo('file.ext')) retourne

  ["dirname"]=>
  string(1) "."
  ["basename"]=>
  string(5) "file.ext"
  ["extension"]=>
  string(3) "x"
  ["filename"]=>
  string(1) "file"

6.2 Attributs de fichiers

On suppose que les notions de propriétaire, groupe, permission et lien sont connues.

fileowner('') retourne le numéro du propriétaire du fichier ou répertoire
chown('',n) fixe le propiétaire du fichier ou répertoire selon son numéro

filegroup('') retourne le numéro d'utilisateur propriétaire du fichier ou répertoire
chgrp('',n) fixe le groupe utilisateur du fichier ou répertoire selon son numéro

is_readable('') est vrai si le fichier est lisible
is_writable('') ou is_writeable() est vrai si le fichier est éditable
is_executable('') est vrai si le fichier est exécutable
decbin(fileperms('')) retourne l'ensemble des permissions accordées
chmod('',mode) fixe les droits selon le codage binaire suivant: mode=1000UGSrwxrwxrwx, où
  1000 est constant
  U est UID: positionné, un exécutable produit des fichiers dont le propriétaire est celui de l'exécutable
  G est GID: positionné, un exécutable produit des fichiers dont le groupe est celui de l'exécutable
  S est Sticky: un exécutable reste en mémoire; seul le propriétaire d'un répertoire peut y effacer des éléments
  rwxrwxrwx sont les droits (lecture/écriture/exécution) du propriétaire, du groupe et de tout le monde

L'utilisation de l'octal facilite la transcription. Pour l'exemple 0107654:
  0 initial introduit un nombre en base 8
  10 représente en octal le binaire 1000
  7 représente 4 pour UID, 2 pour GID, 1 pour Sticky
  6 représente 4 pour r, 2 pour w, 0 pour x
  5 représente 4 pour r, 0 pour w, 1 pour x
  4 représente 4 pour r, 0 pour w, 0 pour x

is_link('') est vrai si le fichier est un lien (symbolique?)
link(fichier,autre) crée un lien
symlink(fichier,autre) crée un lien symbolique

disk_free_space('') ou diskfreespace('') retourne le nombre d'octets disponibles sur la partition précisée
disk_total_space('') retourne le nombre d'octets total sur la partition précisée

filesize('') donne la longueur du fichier (pas l'ensemble des données d'un répertoire)
fileinode('') retourne le numéro d'inode du fichier ou répertoire

La date est un entier représentant le nombre de secondes comme indiqué à la section temps

filemtime('') retourne la date de la création ou de la dernière modification du fichier ou répertoire
filectime('') retourne la date de la dernière modification de l'inode d'un fichier ou répertoire (droits)
fileatime('') retourne la date du dernier accès au fichier ou répertoire

stat(fichier) retourne un tableau associatif contenant la plupart des attributs dont il a été question ci-dessus

6.3 Travail sur les fichiers

include("/chemin/fichier") permet l'inclusion d'un fichier texte (html, script) dans un fichier php.
require("/chemin/fichier") idem, mais le script appelant s'interrompt en cas d'erreur

$handle=fopen(nom,mode) ouvre un fichier et retourne un identifiant de fichier (handle), selon un mode:

Depuis PHP4.3.2, uniqauement avec des fichiers locaux:

fclose($handle) ferme un fichier. Les modifications ne sont certaines qu'après fermeture.

La pointeur indique l'endroit à partir duquel on peut lire ou écrire dans le fichier.

ftell($handle) retourne la position du pointeur de fichier
fseek($handle,n,mode) fixe la position du pointeur de fichier à n. mode=SEEK_SET (ou 0; n positif): par rapport à la position de départ (par défaut); mode=SEEK_CUR (ou 1; n positif ou négatif) par rapport à la position actuelle; mode=SEEK_END (ou 2; n positif) distance par rapport à la fin du fichier
rewind($handle) remet le pointeur à la position zéro, équivaut à fseek($handle,0)

feof($handle) est vrai si le curseur a atteint la fin du fichier; s'utilise surtout en boucle

$handle=fopen("nomdufichier",'r');
while(!feof($handle)) { echo fgetc($handle); }
fclose($handle);

fgetc($handle) lit un caractère à la position du pointeur, qui est ensuite incrémenté de 1
fgets($handle,n) retourne une chaîne, limitée à une fin de ligne ou de fichier, ou à n caractères
fgetss() supprime de plus les balises de la chaîne lue
fread($handle,n) lit n octets d'un fichier binaire (contrairement à un fichier-texte, un fichier binaire comporte des caractères non imprimables: exécutable compilé, image, son...)

fputs ou fwrite($handle, chaine,n) écrit n octets de la chaîne dans le fichier ouvert en r+, w(+) ou a(+)
fclose($handle) ferme le fichier ouvert sous le numéro de handle précisé

file($chemin) retourne les lignes d'un fichier dans un tableau de chaînes contenant chacune la fin de ligne (\n)
file_get_contents($nom,0,null,deb,max) retourne un fichier dans une variable chaîne, soit la séquence fopen-fread-fclose
file_put_contents($nom,$donnee) inscrit des données dans un fichier, soit la séquence fopen-fwrite-fclose

var_dump(fstat($h)) retourne un tableau associatif de toutes sortes de renseignements sur un fichier ouvert
var_dump(lstat($h)) également, mais en cas de lien, sur le lien lui-même plutôt que sur le fichier pointé

Il est possible de traiter des fichiers CSV, où chaque ligne représente une rangée de tabeau, à l'intérieur de chaque ligne, les cellules sont séparées par une virgule. Les chaînes sont entourées de guillemets doubles, le caractère d'échappement est '\' (la chaîne Un "artiste" engagé se code "Un \"artiste\" engagé" )

$tab=fgetcsv($handle) charge un CSV dans Pour traiter une ligne de fichier de données à champs séparés:
fputcsv($handle,$tab) le séparateur étant la virgule, les guillemets étant double, le caractère d'échappement \.

7. Passage de paramètres

7.1 GET

Lors de l'appel de la page .php, on passe une ou plusieurs valeurs dans l'url, après un point d'interrogation et séparées par &. Par exemple:

<a href='essai.php?page=index.htm&bla=4'>lien</a>

Depuis PHP4.2 - obligatoire depuis PHP5 - la réception des variables de l'url se fait par la lecture du tableau $_GET en début de script, qui contient au minimum ceci:

<?php

$var1=$_GET[page];
$var2=$_GET[bla];

echo "<html><body>
<p>Les valeurs passées sont $var1 et $var2</p>
</body></html>";

?>

Rien n'empêche d'utiliser le même nom pour la variable de l'url et celle du script:

<?php

$page=$_GET['page'];
$bla=$_GET['bla'];

echo "<html><body>
<p>Les valeurs passées sont $page et $bla</p>
</body></html>";

?>

7.2 POST

La méthode POST peut être utilisée pour le traitement des données venant d'un formulaire HTML (exemple fonctionnel):

<!DOCTYPE HTML>
<html lang='fr'><head>
<title>Vos avis, vos questions...</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8'>
</head><body>

<h1>Avis ou questions</h1>

<form method='post' action='envoyer.php'>
<p>
Objet: <input name='objet' size=60 value='' />
</p><p>
<input type=submit value='Envoyer' />
</p><p>
<textarea rows=10 cols=60 name='contenu' type='text'></textarea>
</p><p>
Votre@dresse <input name='auteur' size='30' value='' /> (pour une réponse)
</p><p>
<input type='checkbox' name='chg' value='chg' />
je désire être au courant des changements sur le site
</p>
</form>

</body></html>

Lorsque le bouton "Envoyer" est cliqué, les données (envoi, contenu, auteur et chg) sont envoyées au script "envoyer.php", sont récupérées dans des variables par l'interrogation du tableau-système $_POST (depuis PHP 4.2, obligatoire en PHP5).

<?php
$to="nom@serveur.fr"; // il s'agit de l'adresse à qui sera envoyé le message
$auteur=stripslashes($_POST[auteur]);
if ($auteur=="") { $auteur="Auteur anonyme"; }
$objet=stripslashes($_POST[objet]);
if ($objet=="") { $objet="Pas de sujet"; }
$contenu=stripslashes($_POST[contenu]);
$chg=$_POST[chg];
$entete="From: $auteur";

echo "<!DOCTYPE HTML>
<html><head><title>Merci pour votre message</title>
<link rel='stylesheet' href='style.css' type='text/css' media='screen'>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8'>
</head><body><h2>Votre message...</h2>";

echo "<p>$auteur</p>";
echo "<p><b>$objet</b></p>";
echo "<p style='border-style: solid;'>".str_replace("\n","<br>",$contenu)."</p>";

if ($chg=="chg")
 {
  $contenu= $contenu."\n\nDésire être tenu-e au courant";
  echo "<p>Désire être tenu-e au courant</p>";
 }

echo "<h3>Votre message a été envoyé. Merci.</h3>
<p>Retour à <a href='index.htm'>index.htm</a></p>";

echo "</body></html>";

mail($to, $objet, $contenu, $entete); // l'envoi du mail
?>

La séquence str_replace('\n','<br>',$chaine) remplace la fin de ligne pouvant être contenue dans la plage textarea par la balise <br> pour l'affichage par echo.

Voir courriels pour une fonction mail() mieux exploitée.

7.3 Magic quotes, échappements

Pour autant que PHP ait été convenablement configuré, lors du passage de valeurs (GET,POST...) ou du chargement d'un fichier, apostrophes, guillemets et antislashes sont échappés, c'est-à-dire préfixés de la barre inverse \.

' devient \'
" devient \"
\ devient \\

En chargeant le fichier ci-dessous sur le serveur

<?php

$chaine=$_GET[chaine];

echo "<html><body>";
echo "<p>".$chaine."</p>";
echo "</body></html>";

?>

et en le visualisant de cette manière essai.php?chaine=C'est bon, on obtient l'affichage C\'est bon.

La raison de cette complication est que le guillemet et l'apostrophe sont utilisés comme marqueurs de chaînes. Leur utilisation en milieu de chaîne pose donc un problème. Il est par exemple possible d'insérer du code dans un champ éditable, et par exemple de se faire passer pour un administrateur ou de manipuler des champs SQL. Il s'agit donc d'une sécurité.

Pour retrouver la chaîne originelle, on utilise la fonction stripslashes():

<?php

$chaine=stripslashes($_GET[chaine]);

echo "<html><body>";
echo "<p>".$chaine."</p>";
echo "</body></html>";

?>

l'affichage sera alors C'est bon.

7.4 Les cookies

Le cookie est une information délivrée par le serveur au navigateur. Il en existe des volatils, qui ne subsistent que la durée de fonctionnement du navigateur, et des permanents, qui peuvent rester des années sur un ordinateur.

Un cookie de session ne tient que tant que le navigateur est ouvert. Il permet une facilité de navigation (par exemple, un logging réussi installe le cookie, qui sera lu à chaque changement de page).

setcookie($nom,$chaine);

$nom est le nom du cookie (il est possible d'en envoyer plusieurs)
$chaine est une chaîne, où l'on code ce que l'on veut. Cela peut être "Coucou", mais il vaut mieux prévoir une chaîne improbable qu'on ne pourra réutiliser jour après jour.

Pour récupérer un cookie, on place en début de fichier l'expression

$coo=$_COOKIE['nomducookie'];

Un cookie permanent est obtenu en ajoutant un paramètre, qui sera un nombre:

setcookie ($nom,$chaine,$extinction);

L'extinction est le temps exprimé en nombre de secondes à partir de la date de référence Unix (le 01.01.1970 à 0h). Sachant que time() est le nombre de secondes depuis lors, il suffit de fixer $extinction= time()+60*60*24 pour 24 heures ; un milliard de secondes valent un peu plus de 31 années.

Pour effacer un cookie "permanent" avant son terme:

setcookie($nom,$chaine,0);

8. Divers

8.1 Temps

La référence temporelle UNIX (le temps "0") est le 1er janvier 1970 à 0h. L'empreinte temporelle ("timestamp") est le nombre de secondes écoulées depuis lors.

time() retourne l'empreinte temporelle (nombre entier) du temps présent.
microtime(TRUE) idem, mais retourne un réel:

1221394453.88

microtime() retourne une chaîne comportant la partie décimale suivie de la partie entière du précédent:

0.88041500 1221394453

sleep(n) provoque une suspension du script (en secondes)
usleep(n) provoque une suspension du script (en micro-secondes)

set_time_limit(n) fixe le nombre de seconde avant l'abandon d'un script (30sec par défaut, 0 pour infini).

date("argument",n) retourne une chaîne date/heure selon l'argument passé. n est une empreinte temporelle quelconque, ou celle du temps présent time() s'il fait défaut. L'inclusion des lettres suivantes signifie:

Y année sur 4 chiffres; y année sur 2 chiffres; L bissextile: 1 oui, 2 non
m mois, de 01 à 12; n mois, de 1 à 12; F mois, de January à December; M mois, de Jan à Dec
d jour du mois, de 01 à 31; j jour du mois, de 1 à 31; t nombre de jours pour le mois, de 28 à 31
l jour de la semaine complet (Monday, Tuesday...); D jour de la semaine abrégé (Mon, Tue...)
w jour de la semaine, de 0 (dimanche) à 6 (samedi); N (PHP5.1) idem, mais le dimanche vaut 7
z jour de l'année, de 0 à 364; 365 pour l'année bissextile; W semaine (commençant le lundi) de l'année, de 1 à 53

H heure, de 00 à 23; G heure, de 0 à 23; i minutes, de 00 à 59; s secondes, de 00 à 59;
h heure, de 01 à 12; g heure, de 1 à 12; a retourne am ou pm; A retourne AM ou PM
Z secondes de décalage horaire, négative à l'ouest, positive à l'est
O heures de décalage horaire: +0100
I heure d'été? 1 oui, 2 non

c (PHP5) date au format ISO-8601: 2007-11-11T14:32:47+01:00
r date au format RFC-2822: Thu, 11 Nov 2007 14:32:47 +0100

echo date("Y.m.d - H:i:s, l",1000000000); retourne 2001.09.09 - 03:46:40, Sunday

Il est possible d'utiliser un nombre négatif, mais on ne peut remonter au-delà de 1901-12-13 20:45:52 (limite d'un entier négatif codé sur 4 octets).

$tab=getdate(n) retourne un tableau associatif déterminé par une empreinte temporelle:

  $tab['seconds'] retourne le nombre de secondes (0-59)
  $tab['minutes'] retourne le nombre de minutes (0-59)
  $tab['hours'] retourne le nombre d'heure (0-23)
  $tab['mday'] retourne le jour courant (1-31)
  $tab['wday'] retourne le jour de la semaine courante (0=dimanche)
  $tab['mon'] retourne le mois (1 à 12)
  $tab['year'] retourne l'année en quatre chiffres
  $tab['yday'] retourne le jour de l'année (0-365)
  $tab['weekday'] retourne le jour anglais (Sunday-Saturday)
  $tab['month'] retourne le mois anglais (January-December)
  $tab['0'] retourne l'empreinte temporelle considérée

strtotime("chaine") retourne une empreinte temporelle à partir d'une chaîne:

  strtotime("next Monday") lundi prochain à 00:00:00 locale
  strtotime("1981-5-10") ou strtotime("10 May 1981") au 10 mai 1981 à 00:00:00
  strtotime("March 2008") au 1er mars 2008 à 00:00:00
  strtotime("last month") au moins dernier, même jour (1-31), à l'heure présente
  strtotime("next week") la semaine prochaine, même jour (Monday-Sunday), à l'heure présente
  'last day', 'next day', 'last year', 'next year' suppose l'heure présente; 'yesterday' et 'tomorrow' 0:00:00

Il est possible de préciser l'heure: strtotime("1981-5-10 9:15") ou strtotime("1981-5-10 9:15:37")

8.2 Courriels

Faire envoyer un mail en PHP est très simple, pour autant que le serveur hébergeant le script le permette:

mail($dest,$obj,$msg,$entete);
$entete= "From: Manneken Pis <contact@votre_domaine.ext>\n";  //expéditeur
$entete.= "Bcc: autre <autre@server2.net>\n";       // éventuelles copies cachées
$entete.= "Reply-To: autre@ailleurs.org\n";         // adresse de réponse
$entete.= "Date: Tue 6 Jul 1971 10:35:00\n";        // format obtenu avec date("r");
$entete.= "Content-Type: text/plain; charset='ISO-8859-1'\n";

Il est assez difficile d'envoyer un mail sans qu'il ne paraisse suspect par certains webmails, pour plusieurs raisons:

Mails composites

Pour les mails mixtes, il faut prévoir dans l'entête la version de MIME (Multipurpose Internet Mail Extensions) et un séparateur (chaîne ASCII suffisamment improbable pour ne pas figurer dans votre texte) entre les différentes parties du message:

$entete.="MIME-Version: 1.0";
$entete.="Content-Type: multipart/mixed; boundary='ZKQZJXW'";

Chaque partie du message sera précédée du séparateur ainsi que d'un type de contenu. Le texte du mail sera précédé de:

$msg= "--ZKQZJXW\n";
$msg.= "Content-Type: text/plain; charset=utf-8\n";  // ou ISO-8859-1/

Les partie suivantes, qui contiennent un attachement, seront plus complexes parce que nécessitant un codage:

$msg.= "--ZKQZJXW\n";
$msg.= "Content-Type: image/png; name='nomdufichier'\n"; // ou image/jpg ou image/gif pour une image...
$msg.= "Content-Transfer-Encoding: base64\n";
$msg.= "Content-Disposition: attachment; filename='nomdufichier'\n";
$msg.= "X-Attachment-Id: file0\n\n";

suivi dans ce cas du fichier de l'image transformé par base64_encode($chaine).

Le message se termine par le séparateur entouré de --

$msg.= "--ZKQZJXW--\n";

Attention: la ligne de séparation et les lignes "Content" doivent former un bloc sans ligne vide intermédiaire. Si vous utilisez CRLF comme séparateur de ligne (Windows), il faudra peut-être remplacer chaque "\n" par "\r\n".

D'autres types de contenus: application/ogg, application/pdf, application/zip, image/tiff, image/jpg, image/gif, audio/mpeg (mp3), video/mpeg... voir fr.wikipedia.org/wiki/Type_de_média_internet

header("Location: tellepage.htm"); permet de charger la page mentionnée (chemin absolu ou relatif). N'est permis que tant que le script n'a encore rien affiché (echo)

php.net/manual/fr/function.header.php donne d'autres exemples d'utilisation de cette fonction.

8.4 Variables du système

$_SERVER['HTTP_REFERER']; contient l'adresse complète (chemin absolu) de la page appelante.

www.php.net/manual/fr/reserved.variables.server.php donne d'autres exemples d'utilisation de cette fonction.

9. Documentation

www.php.net/: le site officiel, mais pas le plus pratique: string dechex ( int $number ) signifie que l'on passe un entier à la fonction et qu'une chaîne est renvoyée.

www.manuelphp.com: par recherche ou par thème

www.devguru.com/technologies/php/: par thèmes, en anglais

www.info-3000.com/phpmysql/index.php: par thèmes, certaines informations ont vieilli.

www.easyphp.org/index.php installation intégrée d'Apache, PHP et mySQL pour Windows.