PHP

le langage PHP.

1.Introduction au langage

1.1.Syntaxe de base du langage PHP

Comme pour tous les langages de programmation, PHP obéit à certaines règles syntaxiques sous peine d'engendrer un dysfonctionnement des pages web.

1.2.Le séparateur d'instructions

Les instructions PHP doivent être terminées par un point-virgule, à l'instar du Javascript.

// instruction_PHP;

echo "Bienvenue dans le cours PHP !";

Si une instruction n'est pas terminée dans un script, alors cette erreur risque de perturber le fonctionnement correct de la page, voire de déclencher une erreur d'exception.

Si les marqueurs sont placés de part et d'autre de l'instruction, alors il est possible d'omettre le séparateur puisque la balise de fermeture marque implicitement la fin de l'instruction.

<?php echo "Instruction correcte" ?>

1.3.Les commentaires

A l'instar de la plupart des langages, PHP accepte au sein de ses lignes de codes des commentaires permettant de rendre le script facilement compréhensible.

Les commentaires peuvent être insérés dans un script selon plusieurs méthodes différentes.

// Commentaire sur une ligne

/* Commentaire sur

plusieurs lignes */

# Commentaire Unix Exemple

1.4.Insertion des scripts

Les scripts écrits en PHP doivent être intégrés dans une page HTML par le biais d'un balisage spécifique.

<? Script PHP... ?>

Dans le style des instructions de traitement XML, les scripts PHP sont encadrés par une balise d'ouverture <? et une autre de fermeture ?>. Cela n'est possible que si l'option d'exécution short_open_tag ou l'option de complation --enable-short-tags. est activée.

Il est également possible d'intégrer le mot clé php après la première balise de telle sorte à adopter le style de balisage spécifique à PHP, lequel est évidemment le plus couramment utilisé dans les applications PHP.

<?php Script PHP... ?>

Par ailleurs, l'utilisation des marqueurs HTML de scripts est permise avec l'attribut language paramétré pour le langage PHP.

<script language="PHP">

Script PHP...

</script>

Enfin, le code PHP peut être encadré par le balisage réservé à ASP, si l'option d'exécution asp_tags ou l'option de compilation --enable-asp-tags est activée.

<% Script PHP... %>

2.Les fichiers externes

Les scripts PHP peuvent être contenus dans des fichiers externes afin d'être réutilisés par plusieurs documents HTML différents.

Ainsi, un mécanisme d'inclusion permet d'insérer puis d'évaluer le contenu d'un fichier externe dans des pages HTML
(la fonction retourne 0 ou 1 selon qu'elle ait fonctionné ou pas).

<?php include("nom_fichier.inc"); ?>

Une autre instruction contribue à garantir que le fichier externe ne sera inclus et évalué qu'une seule et unique fois dans le document hôte.

<?php include_once("nom_fichier.inc"); ?>

L'instruction require réalise le même travail, mais plante le script si le fichier ne peut pas être copié

            <?php require("nom_fichier.inc"); ?>

A l'instar de l'instruction include, require possède son pendant permettant une unique substitution dans le document hôte.

<?php require_once("nom_fichier.inc"); ?>

Le fichier inclus peut porter n'importe quelle extension (souvent .inc) et contient par défaut du HTML, s'il contient du php, il doit être encadré de <?php et de ?>

3.Types de données

Il n'existe que quatre types de données dans le langage PHP.

Les variables comme dans de nombreux langages web ne possèdent pas de types de données prédéfinis. Seul le contenu de la variable en cours de traitement définira son type de données. Les variables peuvent donc changer de type à n'importe quelle étape du script.

4.Variables et constantes

Les constantes sont des noms chargés de représenter des valeurs invariables et inaltérables.

NOM_CONSTANTE = valeurConventionnellement,

Les constantes sont toujours écrites en majuscules pour des raisons de clarté du code.

Les constantes acceptent uniquement des valeurs parmi les types suivants :

• chaîne de caractères,

• entier,

• double,

• booléen.

La création d'une constante est réalisée par l'intermédiaire de la fonction define.

define(NOM_CONSTANTE, valeur_constante);

Une constante est simplement appelée par son nom avec une casse correcte et sans le signe $ dévolu aux variables.

echo NOM_CONSTANTE;

Les constantes sont utilisables partout dans le code puisqu'elles sont par définition, globales.

4.1.Les constantes prédéfinies

Plusieurs constantes prédéfinies existent dans le langage PHP dans le but de rendre disponible certaines valeurs utiles dans une application web.

La fonction get_defined_constants permet de retourner la liste de toutes les constantes prédéfinies et créées par define, ainsi que leur valeur associée.

echo get_defined_constants();

// affiche la liste : constante => valeur

Les variables dans le langage PHP se distinguent par le caractère dollar ($) placé devant leur nom.

$nom_variable

Les noms de variables doivent être composés de caractères valides [a-zA-Z_] et de plus sont sensibles à la casse.

Les variables peuvent contenir n'importe quel type de donnée supporté par le langage PHP, soit :

• une chaîne de caractères,

• un entier,

• un nombre réel (avec des décimales),

• un booléen,

• un tableau,

• un objet,

• une ressource,

• un null.

L'assignation d'une valeur à une variable s'effectue par l'intermédiaire du signe égal (=).

• $variable = valeur;

• $i = 0;

• $nb = 3.14;

• $hex = 0x24;

• $chaine = "Un texte court...";

• $paragraphe = $paragraphe . $chaine;

• $tableau = array(1,2,3,4,5);

En ajoutant une esperluette (&) devant la variable, il devient possible d'assigner une référence à une variable,
c'est-à-dire que la variable réceptrice en changeant de valeur affectera celle de la variable référencée,
ou, dit autrement, le même espace mémoire possède maintenant deux noms.

$variable = &$variable_réferencée;

exemple

$prenom = 'Pierre';

$prenom_temp = &$prenom;   # $prenom_temp = 'Pierre'

$prenom_temp = 'Jean' . $prenom_temp;

// $prenom_temp = $prenom = 'Jean-pierre'

4.2.La portée des variables

La portée des variables diffère selon son emplacement au sein du code PHP dans une page web.

Les variables peuvent avoir une portée globale si elles sont définies en dehors d'une fonction. Dans le cas contraire, elles seront locales.

Les fichiers inclus dans un autre peuvent non seulement, accéder aux variables globales définies dans la page hôte, mais également les modifier.

4.3.Les variables dynamiques

Les variables dynamiques permettent d'affecter un nom différent à une autre variable.

$nom_variable = 'nom_var';

$$nom_variable = valeur;

// équivaut à

$nom_var = valeur;

Cette technique facilite donc, la modification dynamique du nom d'une variable.

Les variables tableaux sont également capables de supporter les noms dynamiques ; cependant il est nécessaire de faire attention à la syntaxe à utiliser afin d'éviter toute équivoque lors d'un appel à $$variable. C'est pourquoi, l'adjonction d'accolades rend l'expression plus sûre.

$nom_variable = array("val0", "val1", ...,"valN");

${$nom_variable[0]} = valeur;

$val0 = valeur;

$nom_variable = "nom_var";

${$nom_variable}[0] = valeur;

$nom_var[0] = valeur;

Les accolades servent aussi à éviter toute confusion lors du rendu d'une variable dynamique.

echo "Nom : $nom_variable - Valeur : ${$nom_variable}";

// équivaut à

echo "Nom : $nom_variable - Valeur : $nom_var";

4.4.Le transtypage

Le transtypage permet de convertir le type d'une variable dans un autre type explicite.

$variable = (operateur_typage) valeur;

Opérateur	Description
(int) (integer)	convertit une variable en un nombre entier.
(real) (double) (float)	convertit une variable en un nombre décimal.
(string)	convertit une variable en une chaîne de caractères.
(array)	convertit une variable en un tableau.
(object)	convertit une variable en un objet.

Une variable peut délivrer son type de donnée en utilisant une fonction PHP spécifique.

$chaine_type = gettype($variable);

Fonction	Description
gettype()	retourne le type d'une variable (integer, double, string, boolean, NULL, array, object, resource, user function, unknown type).
is_numeric()	indique si la variable est de type numérique.
is_int() is_integer() is_long()	indique si la variable est un entier.
is_double() is_real() is_float()	indique si la variable est un nombre décimal.
is_string()	indique si la variable est une chaîne de caractères.
is_array()	indique si la variable est un tableau.
is_object()	indique si la variable est un objet.
is_bool()	indique si la variable est booléenne.
is_null()	indique si la variable est nulle.
is_resource()	indique si la variable est une ressource.
is_scalar()	indique si la variable est scalaire, si elle contient des entiers, des nombres décimaux, des chaînes de caractères ou des booléens.

Les fonctions is_* retournent une valeur booléenne, true si la comparaison est vraie, sinon false.

true | false = is_integer($variable);

4.5.Les variables prédéfinies

De nombreuses variables prédéfinies sont disponibles à partir de la configuration courante de PHP.

Evidemment, le langage PHP pouvant fonctionner sur de multiples plateformes et serveur web, les variables peuvent fortement différer d'une installation à une autre.

C'est pourquoi, avant d'utiliser une de ces variables, il sera nécessaire de vérifier son existence à l'aide de la fonction phpinfo.

Les informations fournies par cette commande peuvent être les options de configuration principales et standards ou encore celles d'extensions comme pour MySQL, ODBC ou XML, des informations sur le serveur, mais aussi les variables d'environnement et les variables PHP prédéfinies, les en-têtes HTTP, ainsi que la licence GNU Public.

echo phpinfo(constante);

Les informations indiquées par phpinfo peuvent être sélectionnées par catégorie à l'aide de l'argument constante.

Ces variables peuvent être utilisées n'importe où dans un script PHP à condition de placer devant leur nom le fameux signe dollar ($).

echo $HTTP_USER_AGENT echo $PHP_OS // retourne OS400 sur un I5 ou un AS/400

nom_ordinateur = $_ENV["COMPUTERNAME"]

4.6.Les fonctions de variables

Le langage PHP dispose de nombreuses fonctions permettant de travailler sur les variables.

• true | false = empty($variable);
  indique si la variable est vide.

• chaine_type = gettype($variable);
  retourne une chaîne de caractères représentant le type de la variable (integer, double, string, boolean, NULL, array, object, resource, user function, unknown type).

• tableau = get_defined_vars();
  retourne une liste de toutes les variables définies.

• entier = intval($variable);
  retourne le nombre entier de la variable.

• true | false = isset($variable);
  indique si la variable est affectée.

• settype($variable, type);
  affecte un type à une variable (boolean, integer, double, string, array, object).

• unset($variable [, variableN]);
  détruit une ou plusieurs variables séparées par une virgule.

• var_dump($variable) ;
  affiche des informations à propos d'une variable.

5.Les Opérateurs

Les expressions permettent d'évaluer, par l'intermédiaire d'opérateurs spécifiques, différentes valeurs numériques littérales.

Le langage PHP possède un jeu complet d'opérateurs permettant de multiples combinaisons d'expressions.

5.1.Les Opérateurs d'affectation

Un opérateur d'affectation assigne la valeur de l'opérande gauche basée sur la valeur de l'opérande droite.

L'opérateur d'affectation de base est le signe d'égalité (=), qui assigne la valeur de son opérande droite à son opérande gauche. C'est-à-dire, droite = gauche assigne la valeur de gauche à droite.

Les autres opérateurs d'affectation sont sténographiés pour des exécutions standard, comme montré dans la table suivante.

5.2.Les Opérateurs d'incrémentation et de décrémentation

Les opérateurs d'incrémentation et de décrémentation permettent respectivement d'augmenter de un la variable concernée.

5.3.Les opérateurs arithmétiques

Les opérateurs arithmétiques prennent des valeurs numériques (des littéraux ou des variables) comme leurs opérandes et renvoient une valeur numérique.

Les opérateurs arithmétiques standards sont l'addition (+), la soustraction (-), la multiplication (*), et la division (/).

5.4.Les opérateurs de comparaisons

Ce type d'opérateur compare ses opérandes et renvoie une valeur logique en fonction du résultat. Si la comparaison est vraie, la valeur logique true est retournée sinon false.

Les opérandes peuvent être des valeurs numériques ou des chaînes de caractères.

Les chaînes de caractères sont comparées sur la base du standard lexicographique, en utilisant des valeurs d'Unicode.

5.5.Les opérateurs logiques

Les opérateurs logiques sont typiquement utilisés pour comparer des expressions ou des nombres et retournent en résultat des valeurs booléennes.

5.6.Les opérateurs de concaténations

En plus des opérateurs de comparaison qui peuvent être utilisés sur des valeurs de chaîne de caractères, l'opérateur d'enchaînement permet de concaténer deux chaînes de caractères, en retournant une autre qui est le résultat de la concaténation des deux opérandes.

L'opérateur d'affectation .= peut également être utilisé pour enchaîner des chaînes de caractères en boucle.

<?php echo "mon"  .  " "  .  "programme" # retourne "mon programme" ?>

<?php $texte = "Un programme"; $texte_2 = "Hypertext Preprocessor"; resultat = $texte . " " . $texte_2; # retourne "Un programme Hypertext Preprocessor" ?>

6.Instructions de contrôle

Les instructions conditionnelles permettent de poser une condition avant d'exécuter un bloc d'instructions.

L'instruction conditionnelle la plus répandue dans les scripts demeure la fameuse structure if.

6.1.Structure IF

if (condition) { bloc d'instructions... }

if ($y != 0) { echo "$x / $y = " . $x / $y; } // peut aussi s'écrire if ($y != 0)  {   echo "$x / $y = " . $x / $y;  } // mais aussi avec : et endif if ($y != 0)  :   echo "$x / $y = " . $x / $y;  endif

L'instruction if peut être accompagnée de else, voire d'une combinaison else if afin de formuler une alternative par défaut (sinon) ou une ou plusieurs conditions différentes (sinon si).

if (Première condition) { Premier bloc d'instructions... }

else if (Seconde condition) { Second bloc d'instructions... }

...

else if (Nième condition) { Nième bloc d'instructions... }

else { bloc d'instructions par défaut... }

if ($journee == 'matin') { echo "C'est le matin !"; }

else if ($journee == 'après-midi') { echo "C'est l'après-midi !"; }

else if ($journee == 'soirée') ( echo "C'est la soirée !"; )

else { echo "C'est la nuit !"; }

Néanmoins, une telle structure conditionnelle peut être remplacée par une instruction switch dont le fonctionnement est similaire mais dont la syntaxe est bien plus compacte.

6.2.Switch

switch ($variable)

{

case valeur_1 : Premier bloc d'instructions... break;

case valeur_2 : Second bloc d'instructions... break; ...

case valeur_N : Nième bloc d'instructions... break;

default : bloc d'instructions par défaut... break;

}

switch ($journee)

{

case 'matin' :  echo "C'est le matin !";  break

case 'après-midi' :  echo "C'est l'après-midi !";  break

default : echo "C'est la nuit !";

}

La variable $variable est comparée successivement à chacune des valeurs explicitées par l'instruction case.

C'est pourquoi, l'instruction break est nécessaire afin de quitter la structure conditionnelle après que la condition adéquate eut été trouvée.  Par ailleurs, correspondant à else, l'instruction default fournit une alternative par défaut à switch.

6.3.L'instruction ternaire

L'instruction ternaire offre une structure plus compacte sous réserve de ne proposer que deux possibilités selon une condition spécifiée.

$resultat = condition ? première_alternative : seconde_alternative;

Si la condition est vraie alors la première alternative est retournée, sinon c'est la seconde.

6.4.Les boucles

Les boucles permettent de répéter des opérations jusqu'à ce qu'une ou plusieurs conditions soient réunies.

Le langage PHP possède plusieurs instructions itératives. Certaines sont plus orientées vers des opérations spécifiques, d'autres sont utilisables plus généralement.

6.4.1.Les boucles For et Foreach

La boucle for se démarque par sa compacité puisqu'elle contient entre parenthèses trois expressions permettant de l'initialiser (ex : i = 0;) de poser une condition pour continuer (ex : i < 10) et de l'incrémenter ou décrémenter automatiquement (ex : i++).

for (initialisation; condition; incrémentation)

{

bloc d'instructions...

}

Le bloc d'instructions à exécuter dans une boucle for peut être contenu soit à l'intérieur d'accolades, soit une instruction de terminaison spéciale endfor indique sa fin.

for (initialisation; condition; incrémentation)

bloc d'instructions...

endfor;

Littéralement, cette boucle accomplit des opérations à partir d'un état initial et jusqu'à une certaine condition par un pas défini

La boucle foreach est utilisée exclusivement pour les tableaux ou pour toutes autres structures tabulaires.

A chaque itération, l'instruction foreach extrait chaque valeur d'un tableau en la rendant disponible dans le bloc d'instructions.

foreach ($tableau as $valeur) { bloc d'instructions... }

Littéralement, cette boucle accomplit des opérations pour chaque valeur d'un tableau.

6.4.2.Les boucles while et do...while

La boucle while contient essentiellement comme argument une condition d'arrêt toujours évaluée avant chaque itération. L'initialisation et l'incrémentation devront être explicitées dans le code.

while (condition) { bloc d'instructions... }

A l'instar de la boucle for, while possède une instruction de fin endwhile.

while (condition)

bloc d'instructions...

endwhile;

La boucle do...while contrairement à while...endwhile évalue la condition après chaque itération.

do { bloc d'instructions... } while (condition);

Littéralement, ces boucles accomplissent des opérations tant qu'une condition est vraie (faire... tant que...).

6.4.3.Les instructions break et continue

Les instructions break et continue facilitent respectivement la sortie immédiate et l'arrêt pour l'itération en cours d'une boucle, suite à une condition particulière nécessitant une action précise.

while(condition) { Bloc d'instructions... break; // sortie de la boucle avant la prochaine itération

Bloc d'instructions... }

while(condition) { Bloc d'instructions...

continue; /* arrêt de la boucle à l'itération en cours mais passage à l'itération suivante */ Bloc d'instructions... }

Dans le cas d'une imbrication de plusieurs boucles, les instructions break et continue peuvent utiliser un argument indiquant le niveau de la ou des boucles à quitter.

for(initialisation; condition; incrémentation) while(condition) foreach($tableau as $valeur) { Bloc d'instructions... break n; } endwhile; endfor;

Si la valeur n = 1, alors la sortie de la boucle foreach se produit (niveau 1)

Si la valeur n = 2, alors la sortie des boucles foreach et while se produit (niveau 2)

Si la valeur n = 3, alors la sortie des trois boucles se produit (niveau 3)

Le fonctionnement est identique pour l'instruction continue.

6.4.4.Sortie anticipé du script

6.4.5.Récapitulatif

if	Si
else	Autrement
elseif	Autrement Si
switch	Selon
while	Chaque fois que (boucle)
for	Tant que (boucle)
==	Strictement égal à
!=	Différent de
<	Plus petit que
>	Plus grand que
<=	Plus petit ou égal
>=	Plus grand ou égal
and ou &&	Et
or ou ||	Ou

7.Chaînes de caractères

Les chaînes de caractères peuvent être constituées de n'importe quel caractère alphanumérique et de ponctuation, y compris les caractères spéciaux.

\t La nouvelle monnaie unique, l' €uro, est enfin là...\n\r

Une chaîne de caractères doit être toujours entourée par des guillemets simples (') ou doubles (").

"Ceci est une chaîne de caractères valide."

'Ceci est une chaîne de caractères valide.'

"Ceci est une chaîne de caractères invalide.'

Des caractères spéciaux à insérer directement dans le texte, permettent de créer directement certains effets comme des césures de lignes.

7.1.Les fonctions de chaînes de caractères 

Le langage PHP dispose de nombreuses fonctions permettant de travailler sur les chaînes de caractères.

• chaîne_result = addCSlashes(chaîne, liste_caractères);
  ajoute des anti-slashs dans une chaîne devant les caractères indiqués

• chaîne_result = addSlashes(chaîne);
  ajoute un anti-slash devant tous les caractères spéciaux.

• chaîne_result = chop(chaîne);
  supprime les espaces blancs en fin de chaîne.

• caractère = chr(nombre);
  retourne un caractère en mode ASCII.

• echo expression_chaîne;
  affiche à l'écran une ou plusieurs chaînes de caractères.

• $tableau = explode(chaîne, délimiteur);
  scinde une chaîne de caractères en fragments à l'aide d'un délimiteur et retourne un tableau.

• chaîne_result = htmlentities(chaîne, mode_guillemet); convertit tous les caractères spéciaux en entité HTML avec un argument pour l'affichage des guillemets pouvant être ENT_COMPAT (conversion uniquement des guillemets doubles), ENT_QUOTES (conversion de tous les guillemets) et ENT_NOQUOTES (aucune conversion).

• chaîne_result = htmlspecialchars(chaîne, mode_guillemet); convertit tous les caractères spéciaux en entité HTML. Le traitement des guillemets est identique à celui de la fonction htmlentities.

• chaîne_result = implode(délimiteur, $tableau);
  concatène tous les éléments d'un tableau dans une chaîne séparés par une chaîne de caractères.

• chaîne_result = join(délimiteur, $tableau);
  concatène tous les éléments d'un tableau dans une chaîne séparés par une chaîne de caractères.

• chaîne_result = ltrim(chaîne);
  supprime les espaces blancs en début de chaîne de caractères.

• chaîne_result = nl2br(chaîne);
  convertit les sauts de ligne dans une chaîne de caractères en balises HTML <br />.

• parse_str(chaîne, $tableau);
  analyse une chaîne de caractères contenant des paires "nom=valeur" et en extrait des variables et leur valeur.

• print(expression_chaîne);
  affiche à l'écran une chaîne de caractères.

• nombre = printf(format, $variable, ..., variableN);
  affiche à l'écran une ou plusieurs chaînes de caractères formatée.

• chaîne_result = rtrim(chaîne);
  supprime les espaces blancs en fin de chaîne de caractères.

• chaîne_result = sprintf(format, $variable, ..., variableN); retourne une chaîne de caractères formatée.

• chaîne_result = strchr(chaîne, occurrence);
  retourne une chaîne à partir de la première occurrence d'un caractère d'une chaîne spécifiée.

• nombre = strcmp(chaîne_1, chaîne_2);
  compare en binaire deux chaînes de caractères et retourne un nombre négatif si la première chaîne est plus petite que la seconde, un positif dans le cas contraire ou un nul en cas d'égalité.

• nombre = strcoll(chaîne_1, chaîne_2);
  compare deux chaînes de caractères localisées (tenant compte du langage) et retourne un nombre négatif si la première chaîne est plus petite que la seconde, un positif dans le cas contraire ou un nul en cas d'égalité.
  le langage est fixé dans la locale par setlocale(LC_COLLATE, 'fr_FR')

• nombre = strcspn(chaîne_1, chaîne_2);
  retourne la longueur du premier fragment de la chaîne de caractères qui ne contient aucun caractère de la seconde chaîne.

• chaîne_result = strip_tags(chaîne [, balise]);
  supprime les balises HTML et PHP d'une chaîne de caractères hormis les [balises] à conserver.

• chaîne_result = stripSlashes(chaîne);
  supprime les slashs ajoutés par la fonction addslashes.

• chaîne_result = stristr(chaîne_1, chaîne_2);
  recherche dans chaîne_1 et retourne la chaîne allant de chaîne_2 à la fin

• nombre = strlen(chaîne);
  retourne la longueur de la chaîne.

• nombre = strnatcmp(chaîne_1, chaîne_2);
  compare avec une sensibilité à la casse, deux chaînes de caractères dans l'ordre naturel et retourne un nombre négatif si la première chaîne est plus petite que la seconde, un positif dans le cas contraire ou un nul en cas d'égalité.
  l'ordre naturel classe img12.gif après img1.gif et img2.gif, alors que le classement informatique l'aurait mis après

• nombre = strnatcasecmp(chaîne_1, chaîne_2);
  compare insensiblement à la casse, deux chaînes de caractères dans l'ordre naturel et retourne un nombre négatif si la première chaîne est plus petite que la seconde, un positif dans le cas contraire ou un nul en cas d'égalité.

• nombre = strncmp(chaîne_1, chaîne_2, nombre);
  compare en binaire deux chaînes de caractères sur un certain nombre de caractères et retourne un nombre négatif si la première chaîne est plus petite que la seconde, un positif dans le cas contraire ou un nul en cas d'égalité.

• chaîne_result = str_pad(chaîne_1, nb, chaîne_2, emplacement);
  concatène la seconde chaîne de caractères à la première selon l'emplacement spécifié, en l'occurrence soit STR_PAD_RIGHT (à droite), STR_PAD_LEFT (à gauche) ou STR_PAD_BOTH (des deux côtés).

• nombre = strpos(chaîne, caractère [, position_recherche]);
  retourne la position de la première occurrence d'un caractère dans une chaîne à partir de la position spécifiée.

• chaîne_result = strrchr(chaîne, caractère);
  recherche la partie terminale d'une chaîne à partir d'un caractère spécifié.

• chaîne_result = str_repeat(chaîne, nombre);
  retourne une chaîne de caractères concaténée sur elle-même un certain nombre de fois.

• chaîne_result = strrev(chaîne);
  inverse l'ordre des caractères d'une chaîne.

• nombre = strrpos(chaîne, caractère);
  retourne la position de la dernière occurrence d'un caractère dans une chaîne.

• nombre = strspn(chaîne_1, chaîne_2);
  retourne la longueur du premier fragment qui correspond à la seconde chaîne.

• chaîne_result = strstr(chaîne, caractère);
  retourne la sous-chaîne à partir de la première occurrence du caractère dans la chaîne de caractères spécifiée.

• chaîne_result = strtok(chaîne, délimiteur);
  découpe une chaîne de caractères selon un délimiteur.

• chaîne_result = strtolower(chaîne);
  transforme tous les caractères d'une chaîne en minuscules.

• chaîne_result = strtoupper(chaîne);
  transforme tous les caractères d'une chaîne en majuscules.

• resultat = str_replace(chaîne_1, chaîne_2, chaîne);
  remplace toutes les occurrences de la première chaîne par la seconde dans la dernière chaîne de caractères.

• chaîne_result = strtr(chaîne, chaîne_1, chaîne_2);
  remplace dans la première chaîne de caractères, toutes les occurrences d'un caractère dans chaîne_1 par un autre de chaîne_2.

• chaîne_result = substr(chaîne, position, longueur);
  retourne un fragment de la chaîne de caractères à partir de la position spécifiée et jusqu'à une certaine longueur.

• nombre = substr_count(chaîne, sous-chaîne);
  retourne le nombre de sous-chaînes trouvées dans la chaîne de caractères.

• chaîne_result = substr_replace(chaîne, chaîne_remplacement, position[, longueur]);
  remplace les occurrences de chaîne_remplacement dans un fragment de la chaîne de caractères, délimité par les positions position et la position + longueur.

• chaîne_result = trim(chaîne);
  supprime les espaces blancs au début et à la fin d'une chaîne de caractères.

• chaîne_result = ucfirst(chaîne);
  retourne la chaîne de caractères avec son premier caractère en majuscule.

• chaîne_result = ucwords(chaîne);
  retourne la chaîne de caractères avec chaque premier caractère de mot en majuscule.

8.Tableaux

Le langage PHP reconnaît deux types de tableaux, les indicés et les associatifs, permettant de regrouper différentes variables ordonnées respectivement par rapport à un indice numérique ou à une chaîne de caractères.

Les tableaux indicés sont composés de plusieurs éléments dont chacun est repéré par une valeur numérique unique.

La première cellule d'un tableau commence toujours par l'indice zéro (0).

Les tableaux indicés peuvent être remplis par l'intermédiaire d'affectations de valeurs à une variable, suivie d'un indice entre crochets.

$tableau[indice] = valeur;

$jour[3] = "Mercredi";

$note[0] = 20;

Il est également possible d'utiliser la fonction array afin de créer et de remplir un tableau.

$tableau = array(valeur0, valeur1,..., valeurN);

$jour = array("Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi");

$note = array(20, 15, 12.6, 17, 10.2, 11, 18, 19);

L'accès aux valeurs contenues dans un tableau indicé s'effectue par l'intermédiaire de son indice numérique.

$variable = $tableau[indice];

$JJ = $jour[6]; # affecte "Samedi" à $JJ

echo $note[1] + $note[5];

8.1.Les tableaux associatifs

Les tableaux associatifs permettent de ranger des données par rapport à une valeur quelconque, telle qu'une chaîne de caractères ou un nombre, utilisé en tant que "clé".

$tableau["indice"] = valeur;

$jour["Dimanche"] = 7

$jour["Mercredi"] = "Le jour des enfants"

Il est également possible d'utiliser la fonction array afin de créer et de remplir un tableau.

$tableau = array(ind0 => val0, ind1 => val1,..., indN => valN);

$jour = array("Dimanche" => 1, "Lundi" => 2, "Mardi" => 3,

"Mercredi" => 4, "Jeudi" => 5,

"Vendredi" => 6, "Samedi" => 7);

L'accès aux données des tableaux associatifs s'effectue par l'intermédiaire de la valeur indiciaire.

$variable = $tableau["indice"];

$JJ = $jour["Vendredi"]; # affecte 6 à $JJ

echo $jour["Lundi"]; # retourne la valeur 2

8.2.Les tableaux multidimensionnels

Dans le langage PHP, il n'existe pas d'outils pour créer directement des tableaux multidimensionnels. Néanmoins, l'imbrication des tableaux étant possible, l'ajout de plusieurs dimensions devient tout à fait réalisable.

$tab1 = array(Val0, Val1,..., ValN);

$tab2 = array(Val0, Val1,..., ValN);

// Création d'un tableau à deux dimensions

$tableau = array($tab1, $tab2);

$mois = array("Janvier", "Février", "Mars", "Avril", "Mai", "Juin", "Juillet", "Août", "Septembre",

                         "Octobre", "Novembre", "Décembre");

$jour = array("Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi");

$element_date = array($mois, $jour);

L'accès aux valeurs contenues dans un tableau indicé s'effectue par l'intermédiaire de l'indice numérique du tableau conteneur suivi de celui du second tableau.

$variable = $tableau[indice][indice];

$MM = $element_date[0][0]; # affecte "Janvier" à $MM

echo $element_date[1][4] ." 7 ". $element_date[0][2] ." 2002";

// retourne "Jeudi 7 Mars 2002"

Bien qu'il soit possible de créer des tableaux multidimensionnels avec des valeurs panachées, il est préférable d'éviter ce genre de structure dont l'exploitation se révélera vite fastidieuse.

$tableau = array("chaîne", $tab1, Nombre, $tab2);

En général, le parcours des éléments d'un tableau s'effectue au moyen de boucles.

8.3.Le parcours des tableaux

Généralement, le parcours des éléments d'un tableau s'effectue par l’intermédiaire d'une boucle while et plus spécifiquement foreach.

La boucle while nécessite l'utilisation de trois fonctions supplémentaires :

• la fonction reset permet de réinitialiser le pointeur du tableau,

• la fonction list contient une série de variables provenant du tableau,

• la fonction each retourne le couple clé/valeur en cours et pointe l'élément suivant du tableau.

La condition de la boucle while consiste à comparaître la liste de variables au couple clé/valeur en cours.

$tableau = array(val1, val2, ..., valN); reset($tableau);

while (list(, $valeur) = each($tableau)) { echo "Valeur: $valeur"; }

$jour = array("Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi");

$i = 0; reset($jour);

while (list(, $JJ) = each ($jour)) { echo "La cellule n° ". $i . " : " . $JJ . "<br>"; $i++; }

La boucle foreach permet de parcourir tous les éléments d'un tableau à partir d'une structure de boucle simple.

$tableau = array(val1, val2, ..., valN); foreach($tableau as $valeur) { echo "Valeur: $valeur"; } $jour = array("Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"); $i = 0; foreach($jour as $JJ) { echo "La cellule n° ". $i . " : " . $JJ . "<br>"; $i++; }

Le parcours d'un tableau associatif est réalisable en ajoutant avant la variable $valeur, la clé associée.

$tableau = array(clé1 => val1, clé2 => val2, ..., cléN => valN);

foreach($tableau as $clé => $valeur) { echo "Valeur ($clé): $valeur"; }

$jour = array("Dimanche" => 7, "Lundi" => 1, "Mardi" => 2, "Mercredi" => 3, "Jeudi" => 4, "Vendredi" => 5, "Samedi" => 6);

foreach($jour as $sJJ => $nJJ) { echo "Le jour de la semaine n° ". $nJJ . " : " . $sJJ . "<br>"; }

8.4.Les fonctions de tableaux

Le langage PHP dispose de nombreuses fonctions permettant de travailler sur les tableaux.

• $tableau_indice = array(val_0, val_1, ..., val_N);
  crée un tableau indicé.

• $tab_assoc = array(cle0=>val0, cle1=>val1, ..., cleN=>valN);
  crée un tableau associatif.

• $tableau = array_count_values($variable);
  retourne un tableau contenant la liste des valeur en tant que clé et le nombre d'occurence en tant que valeurs

• $tableau = array_flip($variable);
  intervertit les paires clé/valeur dans un tableau.

• $tableau = array_keys($variable [, valeur]);
  retourne toutes les clés d'un tableau ou les emplacements d'une valeur dans un tableau.

• $tableau = array_push($variable, val_1 [, ..., val_N]);
  ajoute une ou plusieurs valeurs à la fin un tableau.

• $tableau = array_reverse($variable, true | false);
  inverse l'ordre des valeurs d'un tableau tout en conservant l'ordre des clés si le second argument est true.

• $tableau = array_rand($variable, nombre);
  extrait d'une façon aléatoire un certain nombre de valeurs d'un tableau.

• $première_valeur = array_shift($variable);
  supprime la première valeur d'un tableau tout en la retournant.

• $tableau = array_slice($variable, position, nombre);
  retourne un tableau contenant un certain nombre d'éléments d'un tableau à partir de la position spécifiée.

• valeur = array_sum($variable);
  retourne la somme des valeurs d'un tableau sous forme d'un nombre entier ou à virgule flottante.

• $tableau = array_unique($variable);
  supprime les doublons d'un tableau.

• $tableau = array_unshift($variable, val [, ..., val_N]);
  ajoute des valeurs au début d'un tableau.

• $tableau = array_values($variable);
  retourne les valeurs d'un tableau.

• arsort($tableau);
  trie un tableau dans un ordre inverse tout en conservant l'ordre des clés.

• asort($variable);
  trie les valeurs d'un tableau en conservant le couple clé/valeur.

• $tableau = compact($variable [, ..., $variableN]);
  crée un tableau associatif dont les variables sont les clés et leurs contenus les valeurs.

• valeur = count($variable);
  retourne le nombre d'éléments d'un tableau.

• valeur = current($variable);
  retourne l'élément courant désigné par le pointeur d'un tableau.

• $tableau = each($variable);
  retourne chacune des paires clé/valeur dans un tableau à quatre éléments (0 => clé, 1 => 'valeur', key => clé, value => 'valeur').

• end($variable) ;
  place le pointeur sur le dernier élément du tableau.

• nombre = extract($variable, action, prefixe);
  crée des variables dont les noms sont les clés et les contenus sont les valeurs d'un tableau. En cas d'existence des variables, l'argument action peut avoir différentes valeurs pour réécrire la variable existante (EXTR_OVERWRITE), ne pas réécrire la variable existante (EXTR_SKIP), ajouter un préfixe prefixe et créer une nouvelle variable (EXTR_PREFIX_SAME), ajouter le préfixe prefixe, et créer une nouvelle variable (EXTR_PREFIX_ALL) ou enfin ajouter un préfixe prefixe uniquement sur les variables aux noms invalides ou de type numérique.

• true | false = in_array(valeur, $variable [, true | false]);
  recherche la valeur spécifiée dans un tableau en vérifiant en même temps la concordance du type si true est indiqué en argument.

• clé | false = array_search(valeur, $variable [, true | false]);
  retourne la clé associée en cas de réussite de la recherche de la valeur spécifiée dans un tableau en vérifiant en même temps la concordance du type, si true est indiqué en argument.

• clé = key($variable):
  retourne la clé en cours dans le tableau.

• nombre = krsort($variable);
  trie les clés d'un tableau dans l'ordre inverse en conservant les paires clé/valeur.

• nombre = ksort($tableau);
  trie les clés d'un tableau en conservant les paires clé/valeur.

• list($variable , ..., $variableN);
  affecte une série de variables en une seule opération.

• natsort($variable);
  trie un tableau dans l'ordre naturel en respectant la casse.

• natcasesort($tableau);
  trie un tableau dans l'ordre naturel sans respecter la casse.

• valeur | false = next($variable);
  avance le pointeur au prochain élément et retourne la valeur correspondante.

• valeur | false = pos($variable);
  retourne la valeur de l'élément courant désigné par le pointeur.

• valeur | false = prev($variable);
  déplace le pointeur sur l'élément précédent et retourne la valeur.

• $tableau = range(nb_max, nb_min);
  retourne un intervalle de tous les éléments numériques (série de caractères possible depuis la V4.10)  compris entre un minimum et un maximum sous forme d'un tableau.

• valeur = reset($variable);
  déplace le pointeur sur le premier élément d'un tableau et retourne sa valeur.

• rsort($variable);
  trie un tableau dans un ordre décroissant.

• shuffle($variable);
  mélange au hasard tous les éléments d'un tableau après un appel de la fonction range.

• nombre = sizeof($variable);
  retourne le nombre d'éléments d'un tableau.

• sort($variable);
  trie un tableau dans un ordre croissant.

• uasort($variable, fonction) ;
  trie les éléments d'un tableau par rapport à une fonction.

• uksort($variable, fontion);
  trie les clés d'un tableau par rapport à une fonction.

• usort($variable, fonction);
  trie les valeurs d'un tableau par rapport à une fonction.

9.Fonctions utilisateurs

Les fonctions sont des modules où un ensemble d'instructions accomplit une tâche spécifique dans le but de retourner une ou plusieurs valeurs au programme appelant.

Les fonctions peuvent être créées par l'intermédiaire de l'instruction function.

L'utilisation d'une fonction nécessite la définition d'un nom, puis éventuellement d'un ou plusieurs paramètres avec le cas échéant leur valeur par défaut qui seront traités par un bloc d'instructions.

Enfin, le nom de la fonction et des arguments permettront l'appel de la fonction à un endroit quelconque d'une application PHP.

Les paramètres dans une fonction peuvent être facultatifs, car la valeur de retour peut être indépendante de toute donnée extérieure.

// fonction sans argument function RepeterCesure() {  for($i = 0; $i < 5; $i++)  {    $cesure .= '<br>';  }  return $cesure; } echo RepeterCesure()

// fonction avec argument

function RepeterCesure($nombre) { for($i = 0; $i < $nombre; $i++) { $cesure .= '<br>'; } return $cesure; }

echo RepeterCesure(5);

Les fonctions retournent un résultat au programme appelant par l’intermédiaire de l'instruction return. Les valeurs de retour peuvent être de n'importe quel type comme des nombres, des chaînes de caractères, des tableaux ou des objets.

Les fonctions variables consistent à affecter à des variables, des fonctions. Ces variables particulières utilisent les instructions de la fonction à leur profit.

function multiplication($nombre, $multiplicateur) { echo '$nombre * $multiplicateur = ' . $nombre * $multiplicateur; }

$fois = 'multiplication';

$fois(100, 12); // retourne '100 * 12 = 1200'

9.2.Arguments de fonction

Il est possible de passer des arguments à une fonction soit par valeur, soit par référence.

Les valeurs passées puis traitées par la fonction peuvent être des valeurs simples de tout type, y compris des tableaux.

function fonction($tableau) {  foreach($tableau as $valeur)  {    $resultat *= $valeur;  }  return $resultat; } $valeurs = array(1, 2, 3, 4, 5); echo fonction($valeurs); # retourne 120

Dans le premier cas, les arguments sont des valeurs passées à la fonction lors de l'appel de cette dernière.
Par la suite, ces valeurs affectées à leur variable respective dans la fonction, sont utilisées dans le bloc d'instructions.

<?php

function prefixe($pfx, $balise) { $balise = $pfx . '.' . $balise; return $balise; }

$balise = 'element_racine';

echo '<' . $balise . '>'; # retourne '<element_racine>'

echo '<' . prefixe('rso', $balise) . '>'; # retourne '<rso.element_racine>'

echo '<' . $balise . '>'; # retourne '<element_racine>'

?>

Les paramètres sont facultatifs, et contiennent NULL, sauf à fournir une valeur par défaut sous la forme function fonction(param1=dft1, param2=dft2)

Dans cet exemple, la variable $variable définie dans la fonction ne modifie absolument pas la variable de même nom déclarée dans le programme appelant.

Ainsi, dans le cas d'un passage d'argument par valeur, la variable contenant cette valeur dans le programme appelant ne sera pas affectée par des opérations dans la fonction.

Néanmoins, il est possible de passer des arguments par référence (comme en RPG). Cela entraîne la possibilité de modification des variables du programme appelant impliquées par la fonction.

// Passage d'arguments par référence sur la fonction

function incrementation(&$inc) { return $inc += 100; }

$i = 0;

echo 'i = ' . $i; # affiche 0;

incrementation($i);

echo 'i = ' . $i; # affiche 100;

// Passage d'arguments par référence lors de l'appel de la fonction

function incrementation($inc) { return $inc += 100; }

$i = 0;

echo 'i = ' . $i; # affiche 0;

incrementation(&$i);

echo 'i = ' . $i; # affiche 100;

incrementation($i);

echo 'i = ' . $i; # affiche 100 et non 200;

Le passage d'arguments par référence défini au niveau de la fonction implique une modification constante de la variable spécifiée, alors que si le passage par référence s'effectue lors de l'appel de la fonction, le résultat demeure le même tout en restant limité à cet appel.

9.3.Variables des fonctions

Les variables présentes au sein d'une fonction sont par définition locales, mais sous réserve d'une déclaration spéciale, leur portée peut être globale ou par ailleurs d'un type statique.

Toutes les variables déclarées dans une fonction sont utilisables localement. Elles ne peuvent être appelées et utilisées dans le corps du programme.

function SurfaceTriangle($largeur, $hauteur) { $resultat = ($largeur * $hauteur) / 2; return $resultat; }

echo SurfaceTriangle(20, 10) . " cm<sup>2</sup>; // retourne 100 cm2

echo "($largeur * $hauteur) / 2 = " . $resultat; // instruction erronée : variables indéfinies.

Les variables globales peuvent être utilisées dans une fonction à condition de déclarer à nouveau les variables dans la fonction avec le mot-clé global ou en utilisant le tableau associatif prédéfini $GLOBALS.

$var_glo = valeur;

function Fonction() { global $var_glo; $var_glo++; }

function Autre_Fonction() { $GLOBALS["var_glo"]++; }

Par ailleurs, des variables peuvent être déclarées statiques dans une fonction afin de les utiliser récursivement dans la fonction elle-même.

function Fonction() { static $variable = 0; $variable++;   if($variable <= 0) {   Fonction();  } }

Dans cet exemple, si la variable n'est pas statique, sa valeur restera toujours nulle puisque son initialisation à zéro annulera son incrémentation.

10.Expressions régulières

Les expressions régulières sont des modèles utilisés pour vérifier des combinaisons spécifiques de caractère dans les chaînes.

Plusieurs fonctions et instructions utilisent de tels modèles afin d'accomplir diverses opérations sur des chaînes de caractères.

10.1.Les symboles de délimitation

Les expressions régulières permettent d'effectuer des manipulations complexes de chaînes de caractères, en utilisant des modèles (pattern) répondant à des règles de syntaxes précises.

Tout d'abord, plusieurs symboles spéciaux permettent de délimiter précisément un modèle :

• ^ : indiquant le début d'une chaîne de caractères.

• $ : indiquant la fin d'une chaîne de caractères.

• \b : indiquant une limite de mot d'une chaîne de caractères, soit la position entre un mot (\w) et un espace ou un caractère de ponctuation (\W).

• \B : indiquant ce qui n'est pas une limite de mot dans une chaîne de caractères.

• \d : indique un chiffre comprenant les caractères suivants
  [0-9].

• \D : indique ce qui n'est pas un chiffre [^0-9].

• \n : indique une nouvelle ligne.

• \r : indique un retour chariot.

• \s : indique un espace blanc comme \t, \n, \r, ou \f.

• \S : indique ce qui n'est pas un espace blanc (\t|\n|\r|\f).

• \t : indique une tabulation verticale.

• \w : indique un mot comprenant les caractères suivants
  [0-9a-zA-Z_].

• \W : indique ce qui n'est pas un mot [^0-9a-zA-Z_]

$chaine = "Le loup est dans la bergerie."; // recherche 'Le' en début de chaîne $regexp = "^Le"; // recherche 'rie.' en fin de chaîne $regexp = "rie\.$";

// recherche 'ber' au début d'un mot ex: 'bergerie' $regexp = "\bber"; $regexp = "\sber"; $regexp = "\Wber"; // recherche 'rie' à la fin d'un mot ex: 'bergerie' $regexp = "rie\b"; $regexp = "rie\W";

/* recherche 'rie' à la fin d'un mot mais ne le trouve pas car 'bergerie' se termine par un point et pas par un espace blanc */ $regexp = "rie\s"; // recherche 'but' à la fin d'un mot ex: 'début' $regexp = "but\s" // recherche 'ger' dans un mot ex: 'bergerie' $regexp = "\Bger"; $regexp = "\Sger"; $regexp = "\wger";

Si une expression régulière ne contient aucun des deux symboles '^' ou '$', alors le domaine de recherche peut être situé n'importe où dans la chaîne de caractères (si la chaine contient ..)

$regexp = "dans"

$regexp = "loup"

10.2.Nombre d'occurrences

Trois symboles spéciaux, soit les signes : étoile (*), plus (+) et point d'interrogation (?), fournissent des solutions pour signifier un certain nombre d'occurrences possible d'un caractère dans une expression régulière.

• * : indique zéro ou plusieurs occurrences du caractère précédent.

• + : indique une ou plusieurs occurrences du caractère précédent.

• ? : indique zéro ou une occurrence du caractère précédent.

// recherche '21', 210', '2100', '21000', etc..

$regexp = "21*";

// recherche 'cré', 'créé'

$regexp = "cré+";

// recherche 'pa' ou 'pas'.

$regexp = "pas$";

// recherche 'occurrence', 'occurrences' mais aussi malgré

une orthographe erronée 'ocurence' ou 'ocurences', etc..

$regexp = "oc+ur+ences?";

Afin de limiter ou de préciser le nombre d'occurrences, il suffit d'utiliser ce nombre à l'intérieur d'accolades placées avant le caractère.

// recherche 'créé'

$regexp = 'cré{2}';

// recherche de '1000' jusqu'à '1000000000'.

$regexp = '10{3, 9}';

// recherche 'as' ou 'ass'.

$regexp = 'as{1, 2}';

10.3.Mise en correspondance des caractères

Le point (.) dans une expression régulière représente n'importe quel caractère.

Les crochets ([]) dans une expression régulière servent à mettre en place une structure alternative où chacun des caractères qu'elle comprend pourra se trouver dans une chaîne de caractères. Un signe moins (-) entre deux caractères désigne une plage de lettres ou de chiffres.

Il est également possible d'exclure des caractères par l'intermédiaire de l'accent circonflexe (^) à l'intérieur des crochets.

// exclut les chiffres de la recherche. $exp = "[^0-9]"; /* exclut les lettres alphabétiques minuscules et les chiffres en fin de chaîne. */ $regexp = "[^a-b0-9]$";

Le caractère d'échappement anti-slash (\) permet d'inclure des caractères spéciaux dans une expression régulière.

// recherche le signe euro, dollar ou livre.

$regexp = "(€|\$|£)";

/* recherche un point d'interrogation à la fin d'une chaîne de caractères. */

$regexp = "\?$";

// recherche le crochet ouvrant

$regexp = "\["Les crochets évitent l'utilisation du caractère d'échappement pour les caractères spéciaux.

// recherche les caractères indiqués.

$regexp = "[(){}.*+?$\]";

10.4.Les fonctions d'expressions régulières

Le langage PHP dispose de plusieurs fonctions permettant de travailler sur les expressions régulières (regexp).

• nombre = ereg(modèle, chaîne [, $tableau]);
  recherche un modèle dans une chaîne de caractères et enregistre les résultats dans le tableau.

• chaîne_res=ereg_replace(modèle, chaîne_remplacemt, chaîne);
  remplace le fragment de chaîne correspondant au modèle par la chaîne de substitution.

• nombre = eregi(modèle, chaîne [, $tableau]);
  recherche en ignorant la casse, un modèle dans la chaîne de caractères puis enregistre les résultats dans le tableau.

• chaîne_result = eregi_replace(modèle, chaîne_remplacement, chaîne);
  remplace le fragment de chaîne correspondant au modèle par la chaîne de substitution en ignorant la casse.

• $tableau = split(modèle, chaîne [, nombre]);
  scinde une chaîne de caractères selon un modèle et éventuellement une longueur limite.

• chaîne_result = spliti(modèle, chaîne [, nombre]);
  scinde en ignorant la casse, une chaîne de caractères selon un modèle et éventuellement une longueur limite.

• chaîne_result = sqlrecase(chaîne);
  crée une expression régulière insensible à la casse à partir d'une chaîne de caractères.

11.Fonctions Date et Heure

Le langage PHP dispose de nombreuses fonctions permettant de travailler sur les dates et les heures.

• true | false = checkdate(mois, jour, année);
  vérifie la validité d'une date.

• $timestmpUnix = mktime(h , mn, s[, d , m , y]);
  retourne un time stamp Unix à partir de heure/minutes/secondes et éventuellement jour/mois/année

• $chaine = date(format [, timestampUnix]);
  retourne une chaîne de caractères date/heure selon le format spécifié et représentant la date courante par défaut.

• $tableau = getdate([timestampUnix]);
  retourne les éléments de date et d'heure dans un tableau associatif.

• $tableau = gettimeofday();
  retourne l'heure courante dans un tableau associatif.

• $tableau = localtime([TimestampUnix][, tab_associatif]);
  retourne l'heure locale dans un tableau indicé par défaut ou associatif (1).

• $nombre = time();
  retourne le timestamp UNIX courant (nombre de secondes depuis le 1er janvier 1970).

11.1.Les formats de date et d'heure

Plusieurs fonctions traitant des dates et des heures contiennent un argument spécifique pour le formatage d'expressions temporelles.

$format = "d / m / Y";

$chaine = date($format);

// $chaine contient '24 / 03 / 2002'

12.Les formulaires

Les formulaires permettent de retourner des informations saisies par un utilisateur vers une application serveur.

<form method="GET | POST" action="page_cible.php"> <input type="text" name="Champ_saisie" value="Texte"> <select name="Liste_Choix" size="3"> <option value="Option_1">Option_1</option> <option value="Option_2">Option_2</option> <option value="Option_3">Option_3</option> </select> <textarea name="Zone_Texte" cols="30" rows="5"> Texte par défaut </textarea> <input type="checkbox" name="Case_Cocher" value="Case_1"> Case à cocher 1<br> <input type="checkbox" name="Case_Cocher" value="Case_2"> Case à cocher 2<br> <input type="checkbox" name="Case_Cocher" value="Case_3"> Case à cocher 3<br> <input type="radio" name="Case_Radio" value="Case radio 1"> Case radio 1<br> <input type="radio" name="Case_Radio" value="Case radio 2"> Case radio 2<br> <input type="radio" name="Case_Radio" value="Case radio 3"> Case radio 3<br> <input type="cancel" name="Annulation" value="Annuler"> <input type="submit" name="Soumission" value="Soumettre"> </form>

La transmission d'un formulaire s'effectue selon une des deux méthodes d'envoi GET ou POST.

La méthode GET place les informations d'un formulaire directement à la suite de l'adresse URL de la page appelée. Mais cette méthode n'offrant aucune discrétion tend à devenir obsolète.

http://www.site.com/cible.php?champ=valeur&champ2=valeur

La méthode POST regroupe les informations dans l'entête d'une requête http ; assurant ainsi une confidentialité des données efficace.

Lors de la soumission à une page de traitement, quand l'option register_global est fixée à on dans php.ini, chaque élément de saisie est assimilé à une variable PHP dont le nom est constitué par la valeur de l'attribut name et son contenu par la valeur de l'attribut value.

<?php

$resultat = $Champ_saisie . "<br>";

$resultat .= $Liste_Choix . "<br>";

$resultat .= $Zone_Texte . "<br>";

for ($i = 0; $i < count($Case_Cocher); $i++) { $resultat .= $Case_Cocher[$i] . "<br>"; }

$resultat .= $Case_Radio . "<br>";

?>

La plupart des éléments d'un formulaire n'acceptent qu'une seule et unique valeur, laquelle est affectée à la variable correspondante dans le script de traitement.

$Champ_Saisie = "Ceci est une chaîne de caractères.";

Tandis que pour des cases à cocher et les listes à choix multiples, plusieurs valeurs peuvent être sélectionnées entraînant l'affectation d'un tableau de valeurs aux variables correspondantes.

$Case_Cocher[0] = "Case radio 1";

$Case_Cocher[1] = "Case radio 3";

il faut alors utiliser :

1. $_GET['le nom du champ'] pour un formulaire utilisant la méthode GET
   (ou la tableau associatif$HTTP_GET_VARS['lenom'].)
2. $_POST['le nom du champ'] pour un formulaire utilisant la méthode POST
   (ou la tableau assiciatif$HTTP_GET_VARS['lenom'].)

<?php

if ( isset($_POST['Champ_saisie'] )) { $champ = $_POST['Champ_saisie']; } else { $champ = $_GET['Champ_saisie']; }

?>

La page de traitement d'un formulaire peut être aussi bien un document cible spécifique que la page elle-même. Dans ce cas, la page doit contenir un dispositif spécial permettant de recueillir ses propres données et la valeur de l'attribut ACTION de la balise FORM doit être sa propre adresse. Un moyen simple consisterait à utiliser une variable d'environnement telle que $PHP_SELF, $PATH_INFO ou encore $SCRIPT_NAME.

13.Objets

Le langage PHP supporte certaines notions de la programmation orientée objet et permet ainsi de développer ses propres objets possédant des caractéristiques spécifiques pour des applications Internet ambitieuses.

Les objets sont issus d'instanciations de classes qui leur fournissent des attributs, des propriétés et des méthodes permettant d'accomplir des tâches prédéfinies dans un script.

13.1.Les classes

Une classe est une structure de référence à partir de laquelle se concrétise un objet.

Le code au sein d'un module de classe décrit :

• Les attributs, soit les variables que l'objet passera à la classe.

• Des méthodes, soit des fonctions définies au sein de la classe.

D'autre part, les caractéristiques des attributs telles que leur type de données et leur valeur sont appelées les propriétés que possédera l'objet suite à sa création.

Une classe est conçue à partir de l'instruction class qui contiendra la déclaration des attributs ainsi que les fonctions et leurs instructions.

class nom_classe { // Déclarations des attributs var $attribut_1; var $... var $attribut_N; // Déclarations des fonctions function nom_fonction_1 (param_1, ..., param_N) { [$this->attribut_1 = valeur;] Bloc d'instructions... } ... function nom_fonction_N (param_1, ..., param_N) { [$this->attribut_1 = valeur;] Bloc d'instructions... } }

Dans une classe, la variable spéciale $this permet à une fonction d'accéder aux propriétés d'un attribut.

Ensuite, un objet est créé au moyen d'une instanciation de la classe par l'intermédiaire de l'instruction new.

$objet = new nom_classe;

A partir de l'objet, il devient possible d'accéder à ses propriétés et à ses méthodes en utilisant un tiret '-' suivi d'un signe supérieur à '>' entre le nom de l'objet et respectivement le nom de l'attribut et de la fonction déclarées dans la classe.

// Accès aux propriétés de l'objet

$nom_objet->nom_attribut = valeur;

// Accès aux méthodes de l'objet

$nom_objet->nom_fonction(param_1, ..., param_N);

14.Gestion des fichiers

Le langage PHP propose de nombreux outils permettant de manipuler les fichiers et les dossiers présents sur les disques durs du serveur.

Evidemment, une telle application ne devra pas être accessible aux utilisateurs ne disposant pas d'une permission appropriée. Les risques de malveillance sont d'autant plus importants, qu'il est nécessaire de renforcer la sécurisation du serveur.

L'ouverture d'un dossier ou d'un fichier s'effectue respectivement par l'entremise des fonctions opendir et fopen.

<?php $repertoire = "repertoire/"; $dossier = opendir($repertoire); $fichier = readdir($dossier); fopen($fichier, r+); ?>

La fonction readdir permet de lire une entrée du dossier spécifié, soit le fichier sur lequel est disposé le pointeur de dossier.

Plusieurs fonctions PHP servent à vérifier une caractéristique intrinsèque ; par exemple, si une variable de système de fichiers est un répertoire (is_dir), un fichier (is_file), un exécutable (is_executable), un lien (is_link) ou encore si le fichier est ouvert en lecture seule (is_readable), en écriture seule (is_writeable) et enfin si le fichier a été téléchargé par la méthode HTTP POST (is_uploaded_file).

<?php $chemin = "c:\\site\\"; if (is_dir($chemin)) { echo $chemin . " est un dossier !"; } $chemin = "c:\\site\\index.html"; if (is_file($chemin)) { echo $chemin . " est un fichier !"; } ?>

Pour les fichiers, la fonction file_exists s'assure de l'existence du fichier au chemin spécifié.

$valide = file_exists($fichier);

Il est possible de parcourir les entrées d'un dossier en utilisant une boucle while, dont la condition peut être la lecture d'un dossier par la fonction readdir renvoyant lorsque la fin est atteinte, la valeur booléenne false.

<?php $i = 0; $dir = "C:\\Inetpub\\wwwroot\\laltruiste\\coursphp\\"; $dossier = opendir($dir); while ($entree = readdir($dossier)) { $i++; echo $i . ' : <a href="http://www.laltruiste.com/cousphp/' . $entree . '">' . $entree . '</a><br>'; } closedir($dossier); ?>

Les fichiers peuvent être lus fread ou écrits fwrite, suite à leur ouverture par fopen.

<?php $id_fichier = fopen("fichier.html", "r"); $taille = filesize("fichier.html"); echo str_replace("<", "&lt;", fread($id_fichier, $taille)); ?>

<?php

$id_fichier = fopen("fichier.html", "w");

$script = '<?php echo getlastmod() ?>';

fwrite($id_fichier, $script);

fclose($id_fichier);

?>

Les fichiers peuvent délivrer plusieurs informations à l'aide de fonctions appropriées telles que filesize pour leur taille, filetype pour le type, fileatime, filectime et filetmime pour la date et l'heure du dernier accès ou de la dernière modification, ou encore stat, fstat, et lstat retournant un tableau de caractéristiques.

D'autre part, le pointeur de fichier se place directement au début, soit à l'octet 0 d'un fichier lors de l'ouverture de ce dernier. La fonction fseek est capable de modifier la position du pointeur d'un certain nombre d'octets, tandis que ftell retourne cette position. Quant à rewind, il le ramène à la position initiale du fichier.

<?php

$chemin = "c:\\autoexec.bat";

$id_fichier = fopen($chemin, "r");

echo "Position initiale : " . ftell($id_fichier) . "<br>";

fseek($id_fichier, filesize($chemin));

echo "Position de fin : " . ftell($id_fichier) . "<br>";

rewind($id_fichier);

echo "Position de retour : " . ftell($id_fichier) . "<br>";

fclose($id_fichier);

?>

La fermeture d'un dossier s'accomplit par la fonction closedir, alors que celle d'un fichier se fait par fclose.

14.1.Le téléchargement de fichier

Le langage PHP 4 dispose de plusieurs outils facilitant le téléchargement vers le serveur et la gestion des fichiers provenant d'un client.

Un simple formulaire comportant un champ de type file suffit au téléchargement d'un fichier qui par la suite, devra être traité par un script PHP adapté.

Un champ caché doit être présent dans le formulaire afin de spécifier une taille maximum (MAX_FILE_SIZE) pour le fichier à télécharger. Cette taille est par défaut égale à deux mégaoctets.

En PHP 4, le tableau associatif global $HTTP_POST_FILES contient plusieurs informations sur le fichier téléchargé, à condition que l'option de configuration track_vars soit activée dans le fichier php.ini.

• $HTTP_POST_FILES['fichier']['name']
  fournit le nom d'origine du fichier.

• $HTTP_POST_FILES['fichier']['type']
  fournit le type MIME du fichier.

• $HTTP_POST_FILES['fichier']['size']
  fournit la taille en octets du fichier.

• $HTTP_POST_FILES['fichier']['tmp_name']
  fournit le nom temporaire du fichier.

PHP 3 quant à lui, peut faire appel au variable globale ou/et au tableau associatif global $HTTP_POST_VARS à condition que les options de configuration register_globals et track_vars soient activées respectivement dans le fichier php.ini.

• $fichier : renvoie le nom temporaire du fichier.

• $fichier_name : renvoie le nom d'origine du fichier.

• $fichier_size : renvoie la taille en octets du fichier.

• $fichier_type : renvoie le type MIME du fichier.

• $HTTP_POST_VARS['fichier']
  fournit le nom temporaire du fichier.

• $HTTP_POST_VARS['fichier_name']
  fournit le nom d'origine du fichier.

• $HTTP_POST_VARS['fichier_type']
  fournit le type MIME du fichier.

• $HTTP_POST_VARS['fichier_size']
  fournit la taille en octets du fichier.

Par défaut, le fichier envoyé par le client est stocké directement dans le répertoire indiqué par l'option de configuration upload_tmp_dir dans le fichier php.ini.

upload_tmp_dir = c:\PHP\uploadtemp

Il est possible de télécharger plusieurs fichiers en même temps, en utilisant des crochets à la suite du nom du champ afin d'indiquer que les informations relatives aux fichiers seront stockées dans un tableau.

Les fichiers téléchargés sont automatiquement effacés du répertoire temporaire au terme du script. Ainsi, il est nécessaire de déplacer les fichiers vers un autre endroit ou de les renommer si ceux-ci doivent être conservés.

14.2.Les fonctions de dossiers

Le langage PHP dispose de nombreuses fonctions permettant de travailler sur les dossiers.

• nombre = chdir($chaine);
  définit le dossier en cours comme celui précisé par la chaîne de caractères.

• $objet = dir($chaine);
  crée un objet à partir du dossier spécifié.

• closedir($identificateur_dossier);
  ferme le dossier à partir d'un identificateur retourné par opendir.

• $chaine = getcwd();
  retourne le nom du dossier en cours.

• $identificateur_dossier = opendir($chaine);
  ouvre un dossier et retourne un identificateur de l'objet.

• $chaine = readdir($identificateur_dossier);
  retourne le fichier suivant dans le dossier spécifié par l'entremise de son identificateur.

15.Les erreurs

15.1.Le préfixe arobase @

Le préfixe arobase @ devant une expression entraîne l'annulation du rapport d'erreur de cette expression, tout en conservant les messages d'erreurs dues aux erreurs d'analyse.

@file("http://www.site.com/fichier.txt");

Toutefois, si une erreur se produisait alors que l'option de suivi des erreurs dans php.ini serait activée (track_errors TRUE), il sera possible de récupérer le message d'erreur dans la variable globale, $PHP_ERRORMSG.

Message : <?php echo $PHP_ERRORMSG ?>.

L'opérateur de désactivation de rapport d'erreur @ agit pour toutes les erreurs, ce qui pourrait provoquer un arrêt impromptu du script sans aucune indication. C'est pour cela qu'il est nécessaire d'utiliser avec précaution cet opérateur afin d'éviter tout problème inopportun.

15.2.Les erreurs HTTP 404

Un message d'erreur de type HTTP 404 correspond à un fichier non trouvé car l'adresse n'est pas valide ou le fichier n'existe pas sur le serveur.

Dans le cas où le serveur web du site est Apache, il suffit alors de copier un fichier dénommé .htaccess sous la racine du site.

Le fichier .htaccess doit comporter une ligne spécifiant le fichier personnalisé auquel le système devra accéder en cas d'erreur HTTP 404.

ErrorDocument 404 /error.php

Ainsi, lorsqu'un utilisateur essaiera d'accéder à une page par un lien invalide, la page error.php s'ouvrira en affichant un contenu personnalisé.

L'adresse URL fautive peut être précisée dans la page en utilisant une variable spéciale $REDIRECT_URL.

L'adresse URL <? echo $REDIRECT_URL?> n'est pas valide.

Par ailleurs, le fichier error.php peut contenir diverses fonctionnalités comme une redirection automatique sur la page précédente avec un envoi d'un rapport d'erreur à la boîte email d'un responsable ou à un fichier journal, ou encore à une base de données.

16.Les cookies

Les cookies permettent de sauvegarder chez le client des informations relatives à sa visite sur un site.

Lors de la prochaine visite, PHP est capable de lire ces informations afin d'authentifier l'utilisateur et de reconstituer un environnement adapté.

La fonction setcookie permet d'envoyer un cookie sur l'ordinateur client.

setcookie(nom_cookie [, valeur [, date_expiration [, chemin [, domaine [, sécurisation]]]]]);

• La date d'expiration indique la durée de vie du cookie chez le client. En général, la fonction time est utilisée avec une expression numérique précisant un intervalle de temps.Si vous ne précisez pas de valeur, le cookie disparait à la fermeture du navigateur

time()+3600*12 : cookie valable entre : 10:12:00 - 22:12:00

Une date précise peut être également entrée en utilisant la fonction mktime.

mktime(0,0,0,31,12,2002)
// Le cookie sera valable jusqu'au 31 décembre 2002

• Le chemin indique le répertoire du site où le cookie possède une validité. La valeur par défaut est la racine du site web.

• Le domaine indique le nom DNS du site sur lequel le cookie possède une validité. Par défaut, le nom du domaine est celui à partir duquel le cookie a été envoyé. La valeur de cet argument doit comporter deux points '.', un au début et l'autre avant le suffixe.

• L'argument sécurisation est un nombre entier indiquant si le cookie est sécurisé (1) ou s'il ne l'est pas (0 - par défaut).

Les cookies faisant partie des en-têtes HTTP, la fonction setcookie doit être appelée avant l'affichage d'un document ; c'est pourquoi il faut placer l'instruction avant le balisage HTML.

<?php setcookie("Nom", "Valeur"); ?> <html> ... </html>

Les cookies envoyés au client sont automatiquement retournés à l'application PHP afin d'être convertis en une variable à l'instar des champs de saisie des formulaires, toujours avec la même option dans php.ini : register_global.

<?php echo $Session_site; // si register_global echo $HTTP_COOKIE_VARS["Session_site"]; ?>

Il existe deux possibilités pour récupérer les valeurs d'un cookie, soit par la variable globale correspondante (si register_global), soit par $_COOKIE['le nom'], ou par le tableau associatif global $HTTP_COOKIE_VARS.

Il est possible de passer plusieurs valeurs à un cookie par l'intermédiaire de crochets '[]' suivant le nom du cookie.

<?php setcookie( "site['sid']", SID ); setcookie( "site['couleur']", $couleur ); setcookie( "site['police']", $police ); if (isset($site)) { while(list($nom, $valeur) = each($site)) { echo $nom . " = " . $valeur . "<br>"; } } ?>

La suppression d'un cookie peut s'effectuer par l'intermédiaire de la réémission d'un cookie de même nom mais avec une valeur vide.

setcookie("Session_site");

17.Sessions

Les sessions permettent de conserver des informations relatives à un utilisateur lors de son parcours sur un site web.

Ainsi, des données spécifiques à un visiteur pourront être transmises de page en page afin d'adapter personnellement les réponses d'une application PHP.

Chaque visiteur en se connectant à un site reçoit un numéro d'identification dénommé identifiant de session (SID).

La fonction session_start se charge de générer automatiquement cet identifiant unique de session et de créer un répertoire

<?php

session_start();

$Session_ID = session_id(); // $Session_ID = 7edf48ca359ee24dbc5b3f6ed2557e90

?>

La fonction session_start doit être placée au début de chaque page afin de démarrer ou de continuer une session.

Par ailleurs, un répertoire est créé sur le serveur à l'emplacement désigné par le fichier de configuration php.ini, afin de recueillir les données de la nouvelle session.

Le fichier php.ini peut également préciser un nom de session par l'option session.name ou sa durée de vie par session.gc_maxlifetime.

La session en cours peut être détruite par le truchement de la fonction session_destroy. Cette commande supprime toutes les informations relatives à l'utilisateur.

session_destroy();

17.1.La gestion des connexions

Le langage PHP dispose de plusieurs outils permettant de gérer les connexions des utilisateurs sur un site web.

Il existe trois états possibles en ce qui concerne le statut des connexions.

• NORMAL : signifie que la connexion est ouverte et le script est en cours d'exécution.

• ABORTED : signifie que le client a annulé la connexion et le script est arrêté par défaut.

• TIMEOUT : signifie que le script a provoqué une déconnexion due à la fin de la durée d'exécution convenue.

Les deux états ABORTED et TIMEOUT peuvent survenir en même temps dans le cas où, d'une part si PHP est configuré de telle sorte à ignorer les déconnexions et d'autre part lorsque le script arrive à expiration.

En principe, l'état ABORTED interrompt logiquement le script dès que l'utilisateur se déconnecte du site. Toutefois, il est possible de modifier ce comportement en activant l'option de configuration ignore_user_abort dans le fichier php.ini.

En outre, si une fonction de fermeture a été enregistrée avec l'instruction register_shutdown_function, le moteur de script se rendra compte après que le client se soit déconnecté puis lors de la prochaine exécution du script que celui ci n'est pas terminé, ce qui provoquera l'appel de la fonction de fermeture mettant fin au script. Lorsque le script se termine normalement, cette fonction sera également appelée.

L'instruction connection_aborted permet d'exécuter une fonction spécifique à la déconnexion d'un client. Si la déconnexion est effective, la fonction connection_aborted retourne true.

Un script expire par défaut après une durée de 30 secondes. Néanmoins, ce temps peut être modifié par l'intermédiaire de l'option de configuration max_execution_time dans le fichier php.ini.

Une fonction se chargeant de terminer le script sera appelée si le délai arrive à expiration ou si le client se déconnecte.

Les fonctions connection_timeout, connection_aborted et connection_status permettent respectivement de vérifier si l'état de la connexion est ABORTED, TIMEOUT et si les trois états possibles.

17.2.Les fonctions de connexions

Le langage PHP dispose de plusieurs fonctions permettant de gérer les connexions des clients sur une application PHP.

• $nombre = connection_aborted();
  vérifie si le client a abandonné la connexion.

• $nombre = connection_status();
  retourne les bits représentant le statut de la connexion.

• true | false = connection_timeout();
  vérifie l'expiration du script en cours.

• $nombre = ignore_user_abort(paramètre);
  détermine si lors de la déconnexion d'un client, le script doit continuer ou arrêter son exécution. Le paramètre peut valoir soit '0' pour un comportement normal, '1' pour un abandon et '2' pour une expiration.

17.3.Le traitement des variables de session

Les variables de session sont chargées dans une session par l'intermédiaire de la fonction session_register ou $_SESSION

<?php

session_start();

session_register("nom_variable"); // si register_global

...

$_SESSION['nom_variable'] = $nom_variable; //sinon,

?>

Deux options de configuration déterminent le traitement des variables d'une session dans une application PHP.

Si l'option de configuration track_vars est activée et register_globals désactivée, les variables de la session seront disponibles seulement avec $_SESSION['le nom'] ou à partir du tableau associatif global $HTTP_SESSION_VARS.

$_SESSION["nom_variable"] = $VALEUR;

...

echo $_SESSION["nom_variable"] ;

Si l'option de configuration register_global est activée, les variables de la session seront disponibles à partir des variables globales correspondantes.

session_register("nom_variable");

...

echo $nom_variable;

Si les options track_vars et register_globals sont activées, les variables globales et $HTTP_SESSION_VARS contiendront les valeurs des variables de la session en cours.

Le transport des informations entre les documents est réalisé soit par l'entremise d'un cookie, soit d'une requête HTTP. La dernière solution semble être la plus fiable puisque les cookies peuvent ne pas être acceptés par le client ou celui-ci pourrait les détruire en cours de session.

$Session_ID = session_id(); $nom_session = session_name(); $adresse = 'http://www.site.com/doc.html'; $lien = 'Le prochain document'; print_f('<a href="%s?%s=%s">%s</a>', $adresse_url, $nom_session, $Session_ID, $lien); echo '<a href="' . $adresse_url . SID . '">' . $lien . '</a>' /* affichent <a href="http://www.site.com/ doc.html? PHPSESSID=7edf48ca359ee24dbc5b3f6ed2557e90"> Le prochain document</a> */ // redirection automatique header("Location:" . "$adresse . "?" . SID);

Il suffit donc simplement de concaténer l'identifiant de session à l'adresse URL de la page cible pour que cette dernière puisse accéder aux informations conservées par la session. De plus, un mot-clé spécial SID contient le nom de session et l'identifiant séparé par un signe égal.

Si la directive de compilation enable-trans-sid est activée, il sera possible de ne pas ajouter l'identifiant de session à l'adresse URL pointée. Pour savoir si cela est le cas, il suffit de rechercher la directive dans la page résultant de la fonction phpinfo.

Par défaut, PHP tente de passer par les cookies pour sauvegarder l'identifiant de session dans le cas où le client les accepterait. Pour éviter cela, il suffit de désactiver l'option de configuration session.use_cookies dans le fichier php.ini.

Dans la situation où il serait nécessaire d'utiliser les cookies, il est impératif de doubler les moyens de conservation du SID.

17.4.Les fonctions de sessions

Le langage PHP dispose de nombreuses fonctions permettant de travailler avec les sessions.

• true | false = session_start();
  initialise les données d'une session.

• true | false = session_destroy();
  détruit les données d'une session en cours.

• $chaine = session_name([$chaine]);
  retourne ou affecte le nom de la session en cours.

• $chaine = session_module_name([$chaine]);
  retourne ou affecte le nom du module en cours de la session actuelle.

• $chaine = session_save_path([$chaine]);
  retourne ou affecte le chemin de sauvegarde de la session en cours.

• $chaine = session_id([$chaine]);
  retourne ou affecte l'identifiant de la session en cours.

• true | false = session_register(nom_variable, ..., nom_variableN);
  enregistre une ou plusieurs variables dans la session en cours.

• true | false = session_unregister(nom_variable);
  supprime une variable dans la session en cours.

• session_unset();
  supprime la totalité des variables de la session en cours.

• true | false = session_is_registered(nom_variable);
  vérifie si une variable a été enregistrée dans la session en cours.

• $tableau = session_get_cookie_params();
  retourne un tableau associatif contenant les paramètres du cookie (clés : lifetime, path, domain) de la session en cours.

• session_set_cookie_params(durée, chemin, domaine);
  définit les paramètres du cookie (durée de vie, chemin d'accès, domaine d'accès) de la session en cours.

• session_set_save_handler(ouverture, fermeture, lecture, écriture, destruction, durée);
  définit les fonctions à utiliser pour la gestion du stockage des sessions.

• session_end();
  enregistre les données de la session en cours et la termine.

• session_readonly();
  lit les variables de la session en cours en lecture seule.

18.Envoi de courrier

L'envoi de courrier électronique s'effectue par l'intermédiaire de la fonction mail().

true | false = mail(destinataires, sujet, message[, entête][, paramètres])

Cette instruction permet d'envoyer des messages simples à un ou plusieurs destinataires,

ou installez la version définitive de ZendCore for I5/OS (V1.4 et suivantes) qui rend cette fonction disponible.

Toutefois, il est nécessaire de configurer correctement le fichier php.ini , section [mail function] pour utiliser cette fonction.

Des courriers électroniques plus complexes peuvent être construits comportant non seulement une structure de message élaborée en HTML par exemple, mais aussi un entête (headers) spécifique correspondant au contenu et devant suivre les spécifications MIME.

Un courrier électronique est décomposable en plusieurs parties dont la première constitue l'entête du message avec des champs indiquant les adresses du destinataire et de l'expéditeur, ainsi que le sujet du message entre autres et la seconde correspondant au corps du message. Ce dernier peut également être divisé en plusieurs sous-parties renfermant un contenu mixte ou alternatif.

$entete = "From: expediteur@dom.com";

$entete .= "To: destinataire@dom.net";

mail($adresse, $sujet, $corps, $entete);

Exemple de traitement d’un formulaire pour l’envoi d’un message

15.Programmation Orientée Objet (POO)

La base de la programmation orientée objet est la classe.

La classe est un modèle contenant des variables (publiques ou privées dites propriétés) et des fonctions nommées méthodes.

A partir de cette classe vous allez créer des objets (une instance) chargée en mémoire qui, elle, pouvent contenir des données

Exemple avec une méthode (pour parler de l'objet en cours on utilise this )

chaque élément peut être déclaré :

• Public l'élement est visible y compris de l'extérieur
    pour une variable elle est modifiable, pour une méthode elle peut être appelée.
• Private seul le code propre à cette classe peut utiliser cet élément
• Protected seul le code propre à cette classe et aux classes héritant de cette classe peuvent utiliser cet élément

15.1.Constructeurs

Vous pouvez écrire un fonction nommée __construct qui sera lancée automatiquement à chaque instanciation.

(vous pourrez par exemple initialiser des variables ou vous connecter à la base de donnée)

puis

sur le même principe, vous pouvez écrire une fonction __destruct qui sera appelée quand l'objet sera détruit (fin de traitement ou fonction unset)

15.2.Héritage

Vous pouvez écrire une classe qui s'appuie sur une classe existante (pour l'enrichir ou restreindre l'usage de certaines méthodes)

Soit la classe suivante :

si vous écrivez la classe ProducteurFR héritant de Producteur

elle hérite aussi des méthodes.

le but du jeu étant d'enrichir éventuellement la méthode,
pour cela nous allons réécrire la méthode, tout en appellant quand même la méthode parente par parent::changePwd()

15.3.Méthodes statiques

Les méthodes et les propriétés sont par défaut non statiques, c.a.d que la valeur est propre à chaque instance

Si vous utilisez le contexte STATIC , l'information est alors commune à toutes les instances,
ce qui peut être pratique pour une classe de connexion à la base de donnée par exemple

Cela permet de réutiliser la même connexion .

vous remarquerez que dans un contexte statique on utilise self plutôt que $this et que l'opérateur est :: et non ->

15.4.Interfaces

Une interface est comme un modèle de classe, cela indique les méthodes à implémenter. Une interface ne peut pas être instanciée

cela permet de renforcer les modèles de programmation mais aussi de faciliter la saisie,
les éditeurs proposant la liste des méthodes à écrire avec ctrl+espace.

19.Introduction à la Programmation Orientée Objet (POO)

La base de la programmation orientée objet est la classe.

La classe est un modèle contenant des variables (publiques ou privées dites propriétés) et des fonctions nommées méthodes.

A partir de cette classe vous allez créer des objets (une instance) chargée en mémoire qui, elle, pouvent contenir des données

Exemple avec une méthode (pour parler de l'objet en cours on utilise this )

chaque élément peut être déclaré :

• Public l'élement est visible y compris de l'extérieur
    pour une variable elle est modifiable, pour une méthode elle peut être appellée.
• Private seul le code propre à cette classe peut utiliser cet élément
• Protected seul le code propre à cette classe et aux classes héritant de cette classe peuvent utiliser cet élément

19.1.Contructeurs

Vous pouvez écrire un fonction nommée __construct qui sera lancée automatiquement à chaque instanciation.

(vous pourrez par exemple initialiser des variables ou vous connecter à la base de donnée)

puis

sur le même principe, vous pouvez écrire une fonction __destruct qui sera appellée quand l'objet sera détruit (fin de traitement ou fonction unset)

19.2.Héritage

Vous pouvez écrire une classe qui s'appuie sur une classe existante (pour l'enrichir ou restreindre l'usage de certaines méthodes)

Soit la classe suivante :

si vous écrivez la classe ProducteurFR héritant de Producteur

elle hérite aussi des méthodes.

le but du jeu étant d'enrichir éventuellement la méthode,
pour cela nous allons réécrire la méthode, tout en appelant quand même la méthode parente par parent::changePwd()

19.3.Méthodes statiques

Les méthodes et les propriétés sont par défaut non statiques, c.a.d que la valeur est propre à chaque instance

Si vous utilisez le contexte STATIC , l'information est alors commune à toutes les instances,
ce qui peut être pratique pour une classe de connexion à la base de donnée par exemple

Cela permet de réutiliser la même connexion .

vous remarquerez que dans un contexte statique on utilise self plutôt que $this et que l'opérateur est :: et non ->

19.4.Interfaces

Une interface est comme un modèle de classe, cela indique les méthodes à implémenter. Une interface ne peut pas être instanciée

cela permet de renforcer les modèles de programmation mais aussi de faciliter la saisie,
les éditeurs proposant la liste des méthodes à écrire avec ctrl+espace.

©AF400