PHP: présentation synthétique

LE langage PHP est un interpréteur de scripts écrits pour traiter les informations de formulaires, de bases de données (voir la page minimale MySQLi pour PHP7) et de l'affichage HTML. Il est très vite devenu un langage complet capable d'effectuer des calculs.

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...) ni très lisible (trop formelle). 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.

Attention: le PHP est un langage assez désordonné:

Vous aurez vu que les conventions de nommage sont très floues: strlen() mais str_shuffle() ; decbin() mais strtolower()...

Pour une sortie graphique, il est possible d'utiliser gtk, ce qui n'est pas conseillé car le serveur doit recomposer les mêmes images pour chaque visiteur, ce qui est une surcharge pour celui-ci. Ne faites cela que pour un serveur sur votre poste.

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 Échappements (sécurité)
7.4 Cookies

8. Divers

8.1 Temps
8.2 Courriels
8.3 Header
8.4 Variables du système
8.5 Sécurité (mot de passe)

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 php7.0-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:

1.3 PHP chez soi: un serveur LAMP7.3 À réviser!

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 10.0 Buster (les noms de paquets peuvent varier d'une version à l'autre), il faut installer

#En mode super-utilisateur: su [Enter] apt-get install apache2 php libapache2-mod-php default-mysql-client default-mysql-server

pour disposer de l'environnement LAMP/Linux-Apache-MySQL-PHP (choisir apache2 lors de l'installation; mariadb-serveur/client peuvent remplacer MySQL).

Note: phpmyadmin n'est pas obligatoire mais permet la création et l'édition de base de données à l'aide d'une interface graphique. Il n'est plus disponible sur les serveurs de Debian10 et doit maintenant se télécharger sur le site.

Le code à tester doit se placer en /var/www. Pour rendre ce répertoire accessible à vos fichiers de simple utilisateur:

#En mode super-utilisateur: su [Enter] chmod 777 /var/www/html

Votre navigateur accède au contenu interprété des pages .php du répertoire /var/www/html 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 #En mode super-utilisateur: su [Enter] /etc/init.d/apache2 restart ou un reboot de votre système.

Note: Selon la version de PHPMYADMIN, on y accède avec le login root ou phpmyadmin et le mot de passe que vous avez fourni lors de l'installation. Avec Debian/Buster, il a fallu d'abord se connecter et créer une base de données

#En mode super-utilisateur: su [Enter] mysql

...qui vous permet la saisie de ces lignes suivantes (beatles, paul et whenim64 ne sont que des exemples de base de données, d'utilisateur et de mot de passe):

CREATE DATABASE beatles;
Query OK, 1 row affected (0.00 sec)
CREATE USER 'paul'@'localhost' IDENTIFIED BY 'whenim64';
Query OK, 0 row affected (0.00 sec)
GRANT ALL PRIVILEGES ON beatles.* TO paul@localhost;
Query OK, 0 row affected (0.00 sec)
quit

Cette base de donnée contient les identifiants pour administrer vos tables via PHPmyADMIN, en introduisant l'adresse http://localhost/phpmyadmin/index.php dans FireFox ou dérivés.

En cas d'erreur Il manque l'extension mysqli, décommenter dans le fichier /etc/php/7.3/apache2/php.ini la ligne extension =mysqli:

; extension =mysqli

doit devenir:

extension =mysqli

et relancez apache2 (ou votre système):

#En mode super-utilisateur: su [Enter] /etc/init.d/apache2 restart

Attention: le code PHP qui fontionne chez vous ne fonctionnera pas nécessairement sur un serveur distant: des versions des PHP installés et de leur configuration. Les serveurs peut avoir des contraintes (sécurité) plus grandes qu'un serveur sur un poste, et peut peuvent garder un retard pour des problèmes de comptabilité (avec des services comme les éditeurs de contenus: WordPress). Un conseil: fuyez les hébergeurs qui ne proposent que le PHP5.

2. Généralités

2.1 Particularités syntaxiques Rév. 2020.03

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 ou mc en mode console, kwrite pour KDE, gedit pour Gnome ou pluma pour Mate-Desktop... 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 ressemble fortement à 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 ="Bon"; $chaine2 ="jour"
echo $chaine1.$chaine2;

Ce distinguo entre l'addition + et la concaténation . vient du fait que le PHP est un langage à variables faiblement typées. Dans ce qui suit,

$n1 ="12"; $n2 =13;
echo $n1+$n2;
echo $n1.$n2;

...$n1 a été défini comme chaîne, $n2 comme nombre, et pourtant + les a considéré tous les deux comme nombres (résultat: 25) et . comme chaînes (résultat: 1213). Cette souplesse peut-être la cause d'erreurs!

L'utilisation de guillemets doubles permet de simplifier la concaténation par l'inclusion de variables dans une chaîne:

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

De la même manière, les guillemets doubles interprètent les caractères de contrôle, tels que \n (retour à la ligne), ce qui n'est pas le cas des guillemets simples:

$var ="abc";
echo "$a\n456".'$a\n456';

...donnera

abc 456$var\n456

...où le \n est interprété en HTML comme une espace enter la valeur abc de la variable et la chaîne 456. La chaîne entre guillemets simples n'est pas du tout interprétée.

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 doubles en les «échappant» (protégeant) par la barre inverse \:

echo "Réponse: \"oui\"" ;

donnera

Réponse: "oui"

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

echo nl2br(`ls -l`) ;

liste avec détail le répertoire UNIX courant (`dir` pour Windows? — nl2br remplace les retours à la ligne par des <br />)

2.2 Constantes et variables Rév. 2020.03

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') vaut 1 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;

Il existe comme en langage C l'assignation conditionnelle:

$var =(condition) ? expr-si-vrai : expr-si-faux ;
Selon que la condition est vrai ou fausse, la variable prendra comme valeur la première ou la seconde expression (valeur ou variable). Par exemple:
$n =13 ; $ch =($n < 10) ? "un chiffre" : "deux chiffres" ; echo $ch ;

Depuis PHP 7, elle est accompagnée d'une autre:

$ch = $var ?? expr; La première variable $var est affectée à $ch, mais si elle n'existe pas ou vaut NULL, c'est la seconde expression (variable ou valeur) qui sera affectée.

unset($var) détruit la variable $var
isset($var) retourne 1 si la variable $var existe bien

Contrairement au langage C, une variable peut changer de nature, ici de string à integer:

$i ="abc"; echo gettype($i); $i =strlen($i); echo gettype($i);

PHP est très souple:

echo "2"+"3"; retourne le nombre 5
echo 2.3; retourne la chaîne 23

$new =$var; assignation par valeur: copie la valeur de $var dans $new ; les deux variables évoluent séparément
$new =&$var; assignation par référence: la valeur de $new variera en même temps que celle de $var, que l'on modifie l'une ou l'autre variables liées

2.3 Booléens TRUE et FALSE Rév. 2020.03

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 (égalité! $a =3 est une assignation), $a<>3 ou $a! =3 (différence)...

Lorsqu'une de ces expressions est vraie, elle contient la valeur booléenne TRUE, true... (la casse n'a pas d'importance), et FALSE, false... si elle est fausse.

$a ===3 teste l'identité: valeur et type de variable doivent être égaux. L'expression 3 =="3" est vraie (valeur booléenne TRUE, true, trUe...), mais 3 ==="3" est faux (FALSE, false, fAlse...).

3 !=="3" retourne TRUE (types différents).

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

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

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

Les valeurs peuvent servir de booléens. Sont false 0, 0.0, "0", "", null ou un tableau vide, et true pour toute autre expression et un tableau qui contient au moins une cellule, même contenant "" ou 0.

Il est possible de composer des comparaisons avec AND, OR, XOR ou encore ! (inversion logique):

2.4 Conditions if et switch Rév. 2020.03

Pour la boucle foreach, voir tableaux.

Ce qui suit est très classique:

if (condition)
  {
  instructions si la condition est remplie ;
  }
elseif (autre-condition) // facultatif
  {
  autres instructions si autre-condition est remplie ;
  }
else // facultatif
  {
  instructions pour tous les autres cas ;
  }

else { } peut parfois être évité. Pour la marque de pluriel à partir de $n =2:

$s ="" ; if ($n > 1) { $s ="s" ; }

Il existe l'affectation conditionnelle qui raccourcit un peu l'expression:

$s = ($s > 1) ? $s ="s" : $s ="" ;

switch / case permet un codage court d'un test conditionnel multiple:

switch($var) // concerne la variable $var
  {
  case expr1: instructions; break; // expr1 est une variable ou une valeur
  case expr2: instructions; break;
  case expr3: instructions; break;
  default: instructions si aucun cas rencontré ; // facultatif
  }

2.5 Boucles for, while et do Rév. 2020.03

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 ; x augmente de 1 à chaque tour
  {
  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.

continue passe à l'itération suivante sans parcourir la boucle entière (utilisé dans une condition)
break interrompt une boucle; break n sort de n boucles imbriquées. Par défaut donc, break vaut 1.

2.6 Fonctions de l'utilisateur

Mathématiquement, une fonction ne renvoie qu'une valeur. C'est donc par abus de langage que l'on nomme pareillement toute portion de code isolée et appelable 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:

function 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!");

Attention! Le messages d'erreur peuvent donner des indications aux crackers, comme le nom des variables utilisées... La fonction die() ne doit donc être utilisée qu'en mode de développement.

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 (booléen) 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 (par exemple log(0) ; 1/0 enverra de plus un avertissement)
is_null() si l'expression est nulle (NULL, mais pas 0!)
is_nan() est vrai si l'expression n'est pas un nombre (not a number)

settype() permet de tenter de forcer le type d'une variable avec:

$a ="1";
settype($a, "integer");
echo is_integer($a);

intval() transforme une chaîne en entier lorsque c'est possible, tronquant les éventuelles décimales; zéro s'il ne s'agit pas d'un nombre; intval("",base) tient compte de la base
floatval() transforme une chaîne en nombre lorsque c'est possible; zéro s'il ne s'agit pas d'un nombre
strval() transforme une expression numérique en chaîne

3.2 Opérations sur les nombres

Les quatre opérations classiques s'organisent comme on a appris à l'école. Les variables numériques acceptent la notation courte des opérations:

$n +=4 vaut pour $n =$n+4 ; $n -=3 vaut pour $n =$n -3 ; $n *=2 vaut pour $n =$n *2 ; $n /=2 vaut pour $n =$n /2 ; $n **2 pour la puissance de deux.

L'incrémentation est également utilisée:

echo $i++; affiche la valeur de $i avant de l'augmenter de 1
echo $i--; affiche la valeur de $i avant de la diminuer de 1
echo ++$i; augmente de 1 la valeur de $i avant de l'afficher
echo --$i; diminue de 1 la valeur de $i avant de l'afficher

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

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

intdiv(17, 3) permet la division entière

$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.
0b101 un nombre commençant par 0b (seul les chiffres 0 et 1 sont acceptés) sera considéré comme binaire. 101 = 1*2*2+0*2+1*1 =5

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,bd,bc) interprète un nombre selon la base de départ bd et le convertit selon la base de conversion bc:

echo base_convert(13,12,2);

13 = 1*12+3 = 15, converti en chaîne binaire '1111'

Notes:

3.7 Fonctions pseudo-aléatoires

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

rand(inf,sup) retourne une valeur aléatoire entière de inf et sup compris
rand() retourne une valeur aléatoire jusqu'au nombre contenu dans getrandmax()
getrandmax() retourne la plus grande valeur aléatoire possible, ce qui dépend de la machine ou du système d'exploitation. Il peut s'agir de 2147483647, le plus grand nombre positif signé en quatre octets.
srand() réinitialise le générateur de nombres aléatoires (inutile depuis PHP4.10 mais toujours existante en 7.3)

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

lcg_value() renvoie un nombre «réel» aléatoire entre 0 et 1, avec un nombre variable de chiffres après la virgule. En PHP 7.3 sur GNU/Linux:

for ($i =0; $i<1000000; $i++) // un million d'appels de la fonction lcg_value()
  { $len =strlen(lcg_value()); $tab["$len"] =$tab["$len"]+1; }
ksort($tab); var_dump($tab); // tableau de fréquences du nombre de caractères

a par exemple donné (ne faites pas ça sur un serveur extérieur)

array(8) { [11] => int(6) [12] => int(85) [13] => int(823) [14] => int(7966) [15] => int(82019) [16] => int(819063) [17] => int(81199) [18] => int(8839) }

str_shuffle mélange les caractères d'une chaîne
shuffle mélange les cellules d'un tableaux.

4. Chaînes

L'affectation d'une chaîne à une variable se fait au moyen de guillemets simples: $var ='des caractères' ou doubles: $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 et MacOSX: nouvelle ligne
\x0b =chr(11) une ligne plus bas (sans retour chariot)
\x0d =chr(13) UNIX et Windows: retour chariot; jusqu'à MacOS9: nouvelle ligne

Il existe également la façon HereDoc, qui permet de définir une chaîne sur pusieurs lignes, évaluant les variables et les échappements, comme les chaînes à "guillemets doubles":

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

La façon NowDoc n'évalue ni les variables ni les échappements, comme les chaînes à 'guillemets simples':

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

La concaténation se fait avec le point: $ch =$ch1.ch2

Les variables chaînes connaissent la concaténation en notation courte:

$ch. ="ajout" ; vaut pour $ch =$ch."ajout" ; cela peut même être plus complexe:

$ch. ="$var2 et $var2" ;

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 caractère d'une chaîne)

Types

gettype() rend string si la valeur est une chaîne

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

is_null($var) est vrai si la variable n'est pas définie (ce qui n'est pas le cas de "")

settype($var,"string") permet de tenter de convertir une variable en chaîne:

$a =123;
settype($a, "integer");
echo gettype($a);

strval() transforme en chaîne une expression numérique

Pour intval() et floatval(), voir Types de nombres.

4.1 ComptageRév.2020.03

iconv_strlen($ch, "utf-8") retourne la taille d'une chaîne, en nombre de caractères
strlen retourne la taille d'une chaîne en nombre d'octets utilisés pour la coder (égal à icon_strlen($ch, "iso8859-1")
count_chars($chaine, n) compte le nombre d'octets composant une chaîne, de façon déterminée par n:

substr_count($chaine,$segment) retourne le nombre d'occurrences de $segment dans une $chaîne
str_word_count($chaine) retourne le nombre de mots d'une chaîne, avec pour séparateurs: espace, ponctuation et caractères accentué si chaîne en UTF-8
str_word_count($chaine, n, "æœàçéêèëîïôûüù") permet:

4.2 Transformation de chaînes

strrev($ch) retourne une chaîne inversée
$ch =str_shuffle($ch) mélange les caractères d'une chaîne

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. Il s'agit dune position en octets. En UTF-8, un caractère peut être codé avec plusieurs octets
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($ssch, $rempl, $chaine, $n) remplace chaque sous-chaîne d'une chaîne. L'éventuelle variable $n vous retournera le nombre de remplacements effectués
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: toutes les lettres remplacées à partir de la position 2
substr_replace('abcdefghij','123',2,5); // donne ab123hij: les lettres de la position 2 à 2+5 (non comprise) remplacées
substr_replace('abcdefghij','123',2,0); // donne ab123cdefghij: insertion à la position 2

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 \ + . ? * ^ [ ] $ ( ) vér. 7.0

addslashes($chaine) échappe les guillemets simples et doubles, l'antislash (\) et le caractère nul en les précédant de l'antislash \ vér. 7.0
addcslashes($chaine,"car") permet de choisir le(s) caractère(s) à échapper vér. 7.0
stripslashes($ch) élimine les \ d'une chaîne (// disparaît, \r et \n conservés) vér. 7.0
stripcslashes($ch) supprime les \ avant ' et ", en respectant les codages de texte \n \r \t et les valeurs \a \b \e \f \v vér. 7.0

nl2br($ch) retourne une chaîne où chaque retour de chariot (\n) est remplacé par <br> vér. 7.0

htmlspecialchars($chaine,ENT_*) transforme certains caractères sensibles en équivalents HTML: vér. 7.0

htmlspecialchars_decode() transformation inverse vér. 7.0
htmlentities($string,ENT_*,charset,TRUE) extension de la précédente

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

$tab =explode("del", $chaine, n) débite une chaîne dans un tableau indexé selon un délimitateur (qui disparaît), éventuellement limité à n éléments
$chain =implode("ch",$tab) ou join() rassemble un tableau en une chaîne, en insérant une éventuelle chaîne entre les éléments

str_split($chaine,n) 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 un caractère ('c') tous les n cellules

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

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ésRév. 20.03

Un tableau indexé est un ensemble de valeurs accessibles selon leur numéro d'ordre. Attention: le premier élément se situe à l'indice 0.

$tab =array(3, 1, 4, 1, 6) crée le tableau $tab comprenant cinq éléments: $tab[0] vaut 3, $tab[1] vaut 1, $tab[2] vaut 4, $tab[3] vaut 1 et $tab[4] vaut 6.

$tab[1] =8 attribue la valeur 8 au deuxième élément
$tab[] =77 ajoute un nouvel élément en fin de tableau, avec 77 pour valeur

Les éléments d'un tableau peuvent être de natures différentes: nombre, chaîne, tableau, booléen...

$tab =range(deb, lim, pas) crée un tableau de valeurs numériques commençant à deb, s'accroissant de pas à chaque élément jusqu'à lim (non comprise)
$tab =array_fill(deb,n,val) crée un tableau de n éléments de la valeur spécifiée à partir de l'index deb
$tab =array_pad($tab, n, val) étend un tableau à n éléments avec la valeur préciée pour remplissage. Il faut que n soit plus grand que la longueur du tableau initial pour obtenir un effet. Si la n est négatif, le remplissage se fait au début de tableau

var_dump($tab) permet d'énoncer l'ensemble des éléments du tableau:
array(5) { [0] => int(3) [1] => int(1) [2] => int(4) [3] => int(1) [4] => int(6) } signifie que le tableau est composé de 5 éléments, celui à l'indice 0 est un entier de valeur 3, celui à l'indice 1 etc. Cela se complique lorsqu'un élément de tableau est lui-même un tableau.

Conditions et boucles

in_array(valeur, $tableau) retourne TRUE si le tableau contient la valeur précisée, ce qui permet un test avant une portion de code.

if("a" in $alphabet) { code; }

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<br>"; $n =$n+1; }

Retraits et ajouts Rév. et aj. 2020.04

$var =array_pop($tab) retourne et élimine le dernier élément d'un tableau
array_push($tab, element1, element2...) ajoute un (ou plusieurs éléments) en fin de 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. La séquence des éléments est conservée

$autre =array_slice($initial, i) copie les cellules du tableau initial à partir de l'indice i dans le tableau d'arrivée
$autre =array_slice($initial, i, n) copie n cellules d'un tableau à partir de l'indice i dans le tableau d'arrivée
$autre =array_slice($initial, 0, n) copie les n premières cellules du tableau initial dans le tableau d'arrivée
$autre =array_slice($initial, i, -n) copie les cellules à partir de l'indice i, sauf les n dernières

$autre =array_splice($initial, i, n) fait la même chose, mais retire du tableau initial ce qu'il copie dans le tableau d'arrivée (slice + split). Pour enlever une cellule à un endroit déterminé (pop() de python), on ne se préoccupe pas du tableau de réception (exemple fonctionnel ; jouer sur le dernier chiffre pour le nombre de cellules à enlever ; attention: la position 3 désigne la 4e cellule):

$tab =array("a", "b", "c", "d", "e") ;
$pos =3 ; array_splice($tab, $pos, 1) ;
foreach($tab as $cel) { echo "$cel "; }

$autre =array_splice($initial, i, n, $rempl) la portion prélevée (n cellules à partir de i) est remplacée par un ou plusieurs élément(s). Cela permet d'insérer une cellule (insert() de python) ou des cellules à un endroit déterminé (exemple fonctionnel ; une chaîne pour une cellule, un tableau pour plusieurs ; n doit être nul pour conserver l'intégralité du tableau initial):

$tab =array("a", "b", "c", "d", "e") ;
$ins =array('1', '2') ; $pos =3 ;
array_splice($tab, $pos, 0, $ins) ;
foreach($tab as $cel) { echo "$cel " ; }

Vous trouverez sur cette page un moyen simple de déplacer une cellule dans un tableau (permutation).

$nouv =array_chunk($tab, n) découpe un tableau en sous-tableaux de dimension n:

$tab =array_chunk(array(0, 1, 2, 3, 4, 5, 6), 3); var_dump($tab);

array(3) { [0] => array(3) { [0] => int(0) [1] => int(1) [2] => int(2) } [1] => array(3) { [0] => int(3) [1] => int(4) [2] => int(5) } [2] => array(1) { [0] => int(6) } }

Il existe des dizaines de fonctions concernant les tableaux.

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 de quatre clés: array(4) { [0] => int(3) [1] => int(1) [2] => int(4) [99] => string(2) "16" }

$nouv =array_chunk($tab,n,TRUE) découpe un tableau en sous-tableaux de dimension n, ?TRUE permet de garder les clés

5.3 ComptagesVér. 20.03

count($tab) ou sizeof($tab) retourne le nombre d'éléments d'un tableau indexé ou associatif
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 ; "43" vaut 43
array_product($tab) retourne le produit des valeurs d'un tableau. Ce qui n'est pas un nombre vaut 0 ; TRUE vaut 1 ; "43" vaut 43

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

var_dump(array_count_values(array(0, 0, 0, 1, 1, 2, 2, 2, 4, 4)));

retournera array(5) { [0] => int(3) [1] => int(2) [2] => int(3) [3] => int(2) [4] => int(1) }

array_unique retourne un tableau expurgé de ses doublons, gardant comme clés ou indices celles ou ceuux de la première occurrence de chaque valeur

5.4 Opérations sur tableaux

array_fill_keys($tab,val) crée un tableau associatif à partir d'un tableau de valeurs qui deviendront les clés
array_combine($tabcle,$tabval) 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_merge($t1,$t2) fusionne plusieurs tableaux (perd les clés)

5.5 Modification de tableaux

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

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

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) mélange un tableau (le tableau initial est transformé)

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>

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

<?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 Échappements (sécurité)

Les guillemets permettent dans certains cas d'introduire des commandes malsaines dans des directives MySQL («injection de code»). Pour s'en prémunir, il peut être intéressant de les échapper (' est par exemple remplacé par \') et les rendre inoffensifs. Certaines fonctions ou techniques ont été proposées, puis éventuellement retirées – cela dépend du paramétrage du serveur par l'hébergeur. Une autre manière est de remplacer l'éventuelle apostrophe dactylographique ' par l'apostrophe typographique

La fonction magic_quotes() est abolie à partir du PHP 5.4 pour des raisons d'inefficacité et du faux sentiment de sécurité qu'elle entraînait. La sécurité dépasse le propos de cette page et il est utile de se reférer au site à la page secure.php.net/manual/fr/security.php si vos pages manipulent des bases de données.

La fonction get_magic_quotes_gpc(), qui testait la possibilité d'utiliser magic_quotes() sur un serveur particulier, est également abolie.

Si le PHP de votre serveur a été configuré en ce sens (cela semble moins le cas), apostrophes, guillemets et antislashes sont automatiquement échappés lors du passage de valeurs (GET, POST...) ou du chargement d'un fichier.

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

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. Mais cette fonctionnalité ne semble plus être de mise. Toutes les chaînes ne doivent pas nécessairement subir ce traitement, qui n'a pas non plus une efficacité universelle.

addslashes() (voir HTML) échappe guillemets simples et doubles, mais d'aucuns nie le caractère protecteur pour MySQL, qui ne les interprètent pas comme PHP le fait

htmlentities() (voir HTML)

Note! Il est important de tester votre serveur avant d'utiliser ces fonctions, car beaucoup de paramètrages sont possibles, et de refaire ces tests ou vous documenter lorsque vous changez d'hébergeur.

7.4 Les cookies

Le cookie est une information délivrée par le serveur au navigateur de l'internaute. Il en existe des volatils, qui ne subsistent que la durée de fonctionnement du navigateur, et des permanents, capables de survivre des années sur le PC même lorsqu'on a fermé le navigateur. Un paramétrage du navigateur permet cependant d'effacer les cookies lors de la sortie de l'application, comme dans Firefox. Les permanents ont quand même une durée qui dépend d'un paramètre lors de l'envoi par le site.

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 et permet garde la connexion à chaque changement de page).

setcookie($nom,$chaine);

$nom est le nom du cookie: il est possible d'en envoyer plusieurs, sous des noms différents
$chaine est une chaîne, où l'on place ce que l'on veut. Il vaut mieux prévoir une chaîne improbable qui change souvent.

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 (3600) pour une heure.

Pour effacer un cookie «permanent», ou avant son terme:

setcookie($nom,$chaine,0);

Avec une restriction: un cookie mis à zéro subsiste quand même jusqu'à la fermeture du navigateur. Certains sites affirment que la chaîne doit être la même pour effacer valablement le cookie, d'autres parlent de nombre négatif ou simplement d'une empreinte temporelle inférieure à date() (le présent) pour la date d'expiration. D'après une recherche sur les forums, les navigateurs ne semblent pas avoir le même comportement concernant la politique des cookies ; peut-être que cela dépend également de la version de PHP.

8. Divers

8.1 Temps

La référence temporelle UNIX (le moment "0") est le 1er janvier 1970 à 0h. L'empreinte temporelle ("timestamp") est la durée exprimée en secondes depuis ce moment.

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é sous forme de chaîne. 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 ='UTF-8'\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.

<?php phpinfo(); ?> est un mini-fichier à placer sur votre site pour générer une page HTML indiquant tous les paramétrages du serveur concernant le PHP. À votre usage exclusif, bien entendu: ne laissez pas ce fichier sous le nom phpinfo.php dans votre site.

8.5 Sécurité (mot de passe)

Il est possible (et d'ailleurs recommandé) de crypter les mots de passe, avec ajout d'un «grain de sel» automatique renforçant la sécurité. Les deux fonctions décrites ici utilisent et remplacent crypt() auparavant utilisée.

$code =password_hash($mdp, PASSWORD_BCRYPT); renvoie une chaîne de 60 caractères issue du hashage du mot de passe par l'algorithme CRYPT_BLOWFISH. Cette chaîne doit être stockée dans une base de données pour vérification ultérieure. Notez bien que:

$check =password_verify($chaine,$code); vérifie que la chaîne proposée est compatible avec le code issu de password_hash(), par exemple lors d'un login. $check vaut 1 (booléen) en cas de correspondance.

Note: d'autres algorithmes existent, selon les directives de compilation de la version PHP de votre hébergeur.

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/content/technologies/php/: par thèmes, en anglais

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