PHP

Utiliser PHP pour accéder aux Données IBM i (OS/400).

Préambule

Le monde du WEB est basé sur une technologie en couches.

a/ le serveur HTTP (souvent APACHE) est un serveur de fichier, un peu comme FTP, délivrant des fichiers suite à des requêtes clientes.

b/ les fichiers ainsi délivrés peuvent être du texte simple, mais la plupart du temps il s'agit de texte enrichi par un langage : HTML

c/ pour fournir des données dynamiques, on va utiliser un langage s'exécutant sur le serveur (JAVA ou PHP, par exemple)

Le langage PHP est donc un langage, interprété, intégré dans des pages HTML et devant s'exécuter sur le serveur.

•L'interpréteur PHP doit être installé, ainsi que le serveur APACHE.

Sous Windows, utilisez WAMP ou Easy PHP (projets qui vous installerons les deux en même temps)
Sous Linux, les deux produits font partie des distributions standard (sous forme de RPM)
Sous OS/400 , voyez le l'installtion de Zend Core for I5/OS sous PASE.
Voyez enfin les éditeurs disponibles, particulièrement Zend Studio for Eclipse disponible depuis fin 2008

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

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

1.3.Le séparateur d'instructions

Les instructions PHP doivent être terminées par un point-virgule, (comme le 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.4.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

<?php

// Définition d'une constante
define("MESSAGE", "Attention, vous n'avez pas correctement rempli un champ !");

echo MESSAGE; # Instruction d'affichage

/* Ces lignes de code permettent simplement d'écrire dans le document résultant le message suivant :"Attention, vous n'avez pas correctement rempli un champ !" */

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.

Type	Description
entier	représente un entier positif compris entre -2 147 483 647 et 2 147 483 647.
flottant	représente un nombre à virgule flottante compris entre -1.78 10³⁰⁸ et 1.78 10³⁰⁸.
chaîne de caractères	représente une chaîne de caractères.
booléen	représente une valeur booléenne possédant deux valeurs possibles, soit true ou false.

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.

Constante	Valeur	Description
__FILE__		contient le nom du fichier en cours d'exécution.
__LINE__		contient le numéro de la ligne en cours d'exécution.
PHP_VERSION		contient la chaîne de caractères indiquant la version du PHP en cours d'utilisation.
PHP_OS		contient le nom du système d'exploitation en cours d'utilisation sur le serveur.
TRUE		représente la valeur logique TRUE (vrai).
FALSE		représente la valeur logique FALSE (faux).
E_ERROR	1	représente une erreur impossible à corriger. Elle est différente d'une erreur d'analyse.
E_WARNING	2	représente un message d'alerte provoqué par une erreur qui n'interrompt pas le script.
E_PARSE	4	représente une erreur d'analyse dans le domaine syntaxique dont la correction est impossible.
E_NOTICE	8	représente un avertissement ou une erreur n'ayant pas provoqué un arrêt du script.
E_CORE_ERROR	16	représente un avertissement ou une erreur n'ayant pas provoqué un arrêt du script.
E_CORE_WARNING	32	représente un avertissement ou une erreur n'ayant pas provoqué un arrêt du script.
E_COMPILE_ERROR	64	représente une erreur de compilation provoquant l'interruption du script.
E_COMPILE_WARNING	128	représente un message d'avertissement provenant du compilateur sans interrompre le script.
E_USER_ERROR	256	représente une erreur due à l'utilisateur provoquant l'interruption du script.
E_USER_WARNING	512	représente un message d'avertissement dû à l'utilisateur ne provoquant pas l'arrêt du script.
E_USER_NOTICE	1024	représente un message d'avertissement ou une erreur n'ayant pas provoqué l'arrêt du script dû à l'utilisateur.
E_ALL		représente toutes les constantes E_....

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

Variables

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,

c'est à dire que le nom de la variable est lui même dans une 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.

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.
à noter aussi
isset()	Indique si la variable existe (utile pour les champs de formulaires, suivant la méthode get ou post)

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.

Constante	Description
INFO_ALL (dft)	affiche toutes les informations.
INFO_CONFIGURATION	affiche les informations de configuration.
INFO_CREDITS	affiche les informations sur les auteurs du module PHP.
INFO_ENVIRONMENT	affiche les variables d'environnement.
INFO_GENERAL	affiche les informations sur la version de PHP.
INFO_LICENSE	affiche la licence GNU Public
INFO_MODULES	affiche les informations sur les modules associés à PHP.
INFO_VARIABLES	affiche les variables PHP prédéfinies.

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, comme tous les langages en format libre.

Les autres opérateurs d'affectation sont sténographiés pour des exécutions standard, comme montré ci-dessous :

Opérateur	Equivalent	Description
$x = $y		$y est affecté à $x
$x += $y	$x = $x + $y	$y est additionné à $x
$x -= $y	$x = $x - $y	$y est soustrait de $x
$x *= $y	$x = $x * $y	$x est multiplié par $y
$x /= $y	$x = $x / $y	$x est divisé par $y
$x %= $y	$x = $x % $y	le reste de $x/$y est affecté à $x

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.

Opérateur	Description	Exemple
x ++ *	Cet opérateur unaire permet l'incrémentation de la valeur x	i++ //équivaut à i=i+1
x -- *	Cet opérateur unaire permet la décrémentation de la valeur x	i-- //équivaut à i=i-1
* Si l'un de ces opérateurs est placé avant la variable, alors la valeur de la variable sera incrémentée (++) ou décrémentée (--) avant son utilisation.

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

Opérateur	Description	Exemple
x % y	L'opérateur modulo retourne le reste de la division x/y.	20 Mod 3 'retourne 2
x + y	L'opérateur permet d'additionner la valeur x à la valeur y.	5 + 6 'retourne 11
x - y	L'opérateur permet de soustraire la valeur y de la valeur x.	8 – 10 'retourne -2
x * y	L'opérateur permet de multiplier la valeur x par la valeur y.	4 * 9 'retourne 36
x / y	L'opérateur permet de diviser la valeur x par la valeur y en retournant un nombre à virgule flottante.	4 / 16 'retourne 0.25

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.

Opérateur	Description	Exemples
$x == $y	Si la valeur y est égale à x, l'opérateur retourne true. Dans ce cas, si le type de donnée ne correspond pas, alors PHP tentera de convertir les opérandes dans le type approprié afin d'effectuer la comparaison.	if ($choix == 1)
$x != $y	Si la valeur y est différente de x, l'opérateur retourne true	if ($valeur != $prix)
$x <> $y	Si la valeur y est différente de x, l'opérateur retourne true	if ($valeur <> $prix)
$x === $y	Si la valeur de $y est strictement identique (valeur et type) à $x, alors l'opérateur retourne true	if ($parag = $texte)
$x !== $y	Si la valeur de $y est strictement différente à $x, l'opérateur retourne true	if ($ref !== "A000000")
$x > $y	Si la valeur de $y est supérieure à $x, l'opérateur retourne true	if ($montant > 1500)
$x >= $y	Si la valeur de $y est supérieure ou égale à $x, l'opérateur retourne true	if ($hab >= $pop)
$x < $y	Si la valeur de $y est inférieure à $x, l'opérateur retourne true	if ($numero < $page)
$x <= $y	Si la valeur de $y est inférieure ou égale à $x, l'opérateur retourne	if ($fin <= $premier)

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.

Opérateur	Usage	Description	Exemples
and (&&)	$x and $y	L'opérateur renvoie True si les deux opérandes sont vraies; autrement, il retourne False.	($a<10) and ($b>10) 'Si $a et $b sont inférieurs à 10, l'opérateur retourne True
Or ( \|\| )	$x or $y	L'opérateur renvoie True si l'une ou l'autre des opérandes est vraie ou si toutes les deux sont fausses, sinon il retourne False.	($a >= 1) or ($b == "fin") 'Si $a est supérieur ou égal à 1 ou/et si $b est égal à fin alors l'opérateur renvoie true, sinon il retourne false
xor	$x xor $y	L'opérateur renvoie True si les opérandes sont vraies ou fausses, sinon il retourne False.	($a >= 1) xor ($b == "fin") 'Si $a est supérieur ou égal à 1 et si b est égal à fin ou si les deux expressions sont fausses alors l'opérateur renvoie true, sinon il retourne false
!	! $x	L'opérateur renvoie false si son unique opérande peut être convertie en true, sinon il retourne false.	!($a <= 100) 'Si $a est inférieur ou égal à 100 alors l'opérateur retourne false, sinon il renvoie true.

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

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

case 'soirée' : echo "C'est la soirée !";

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

L'instruction exit permet une sortie anticipée du script en cours

dye("message"), sort, mais après avoir affiché un message d'erreur.

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.

Car	Code ASCII	Code hex	Description
\car			échappe un caractère spécifique (par exemple \" )
" "	32	0x20	un espace simple
\t	9	0x09	tabulation horizontale
\n	13	0x0D	nouvelle ligne
\r	10	0x0A	retour à chariot
\0	0	0x00	caractère NUL
\v	11	0x0B	tabulation verticale

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.

(voyez le détail à http://fr.php.net/manual/fr/ref.strings.php )

Quelques exemples

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.
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.
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 = 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.
nombre = strlen(chaîne);
retourne la longueur de la chaîne.

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

(voyez le détail à http://fr.php.net/manual/fr/ref.array.php )

$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.
$première_valeur = array_shift($variable);
supprime la première valeur d'un tableau tout en la retournant.
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.
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.
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.
list($variable , ..., $variableN);
affecte une série de variables en une seule opération.
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 = reset($variable);
déplace le pointeur sur le premier élément d'un tableau et retourne sa valeur.
nombre = sizeof($variable);
retourne le nombre d'éléments d'un tableau.
sort($variable);
trie un tableau dans un ordre croissant.

9.Fonctions Date et Heure

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

(voyez le détail à http://fr.php.net/manual/fr/ref.datetime.php )

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

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

Format	Description
a	représente am (matin) ou pm (après-midi).
A	représente AM (matin) ou PM (après-midi).
B	représente une heure Internet Swatch.
d	représente le jour du mois sur deux chiffres allant de 01 à 31.
D	représente le jour de la semaine en trois lettres et en anglais (Sun, ..., Sat).
F	représente le mois complet en anglais (January, ..., December).
g	représente une heure au format 12 heures allant de 1 à 12.
G	représente une heure au format 24 heures allant de 1 à 24.
h	représente une heure au format 12 heures avec un zéro de complément allant de 00 à 11.
H	représente une heure au format 24 heures allant de 00 à 23.
i	représente les minutes allant de 00 à 59.
I	est égal à 1 si l'heure d'été est activée ou 0 pour l'heure d'hiver.
j	représente le jour du mois allant de 1 à 31.
l	représente le jour de la semaine complet et en anglais (Sunday, ..., Saturday).
L	est égal à 1 si l'année est bissextile, sinon 0.
m	représente un mois allant de 01 à 12.
M	représente un mois en trois lettres et en anglais (Jan, ..., Dec).
n	représente un mois allant de 1 à 12.
O	représente la différence d'heures avec l'heure de Greenwich (+0100).
r	représente un format de date conforme au RFC 822 (Mon, 25 Mar 2002 05:08:26 +0100).
s	représente les secondes allant de 00 à 59.
S	représente le suffixe ordinal d'un nombre en anglais et sur deux lettres th ou nd.
t	représente le nombre de jours dans le mois (28, 29, 30 ou 31).
T	représente le fuseau horaire.
U	représente les secondes depuis une époque.
w	représente le jour de la semaine allant de 0 (Dimanche) à 6 (Samedi).
Y	représente une année sur quatre chiffres (2002).
y	représente une année sur 2 chiffres (02).
z	représente le jour de l'année allant de 0 à 365.
Z	représente le décalage horaire en secondes.

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

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

</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";

La valeur par défaut pour register_global, pour des raisons de sécurité, est fixée à off sur les dernières versions

il faut alors utiliser :

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

Vous pouvez utiliser la fonction isset pour traiter les deux cas de figure :

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

<?php

if ($champ_saisie != 'Texte')
echo 'Vous avez écrit dans le champ de saisie, le texte suivant : '
.$champ_saisie;

11.Accès à la base de données DB2/400

Nous choisirons ici, de parler pour commencer de l'accès ODBC, qui a l'avantage, maintenant d'être universel
(Windows, Linux et OS/400 avec CLI)

lla connexion ODBC se fait avec les attributs suivants :

sur plateforme Intel (Windows/Linux)
$db = odbc_connect($dsn , $user , $passwd)

ou $dsn contient la chaîne de connexion
"DRIVER=iSeries Access ODBC Driver;SYSTEM=AS400;DBQ=BIBLIOTHEQUE"

dans le monde OS400
$db = odbc_connect($rdb , $user, $pwd)

ou $rdb contient le nom de la base locale tel que définit dans WRKRDBDIRE

le nom de la "database" (ou bibliothèque pour nous), doit être fourni ensuite par :
odbc_setoption($db, 1, SQL_ATTR_DBC_DEFAULT_LIB, $bibliotheque)

le deuxième paramètre permet d'indiquer que l'on modifie les paramètres de connexion (1) ou pour une instruction (2)

Vous pouvez donc écrire le code suivant qui s'exécutera sur tous les environnements (Windows, Linux, OS/400 et AIX)

<?PHP

// test de l'OS
$isPase = (PHP_OS == "AIX" || PHP_OS == "OS400");   

// connection                   
if (!$isPase) {
  $dsn = "DRIVER=iSeries Access ODBC Driver;SYSTEM=$system;DBQ=$bib";
  $db = odbc_pconnect($dsn, $user, $pwd);
} else {                                                                         
   $db = odbc_connect($system, $user, $pwd);
   odbc_setoption($db, 1, SQL_ATTR_DBC_DEFAULT_LIB, $bib);                                     
}

?>

cet extrait de code est proposé avec 
des exemples d'accès à DB2/400 en php sous linux, sur la page

http://publib.boulder.ibm.com/infocenter/iseries/v5r4/topic/rzatv/rzatvexodbc.htm

ATTENTION.

Beaucoup de paramètres et de comportements sont dépendant de la convention d'appellation (Sql ou système)

Convention d'appellation SQL

Sur Windows/Linux
vous pouvez fournir une liste de bibliothèques, celle ci sera utilisée pour la recherche des types de données utilisateur (UDT), des fonctions (UDF) et des procédures cataloguées. La première de ces bibliothèques sera considérée comme la bibliothèque par défaut.

Sur I5
vous ne pouvez fournir qu'un seul nom de bibliothèque qui sera la bibliothèque par défaut

La bibliothèque par défaut est automatiquement utilisée lors d'une requête SQL non qualifiée pour l'accès aux tables

Si vous n'indiquez pas de bibliothèque par défaut, c'est le AUTHORIZATION ID qui est utilisé

l'authorization ID est par défaut le nom de l'utilisateur en cours, peut être modifié par SET AUTHORIZATION ID et doit être un nom de profil.
Convention d'appellation système

Vous utilisez *LIBL.

La liste de bibliothèques est celle de l'utilisateur connecté (application de la JOBD incluse) ou par défaut de l'utilisateur du serveur Apache.

Vous pouvez la compléter en passant les ordres suivants :
$addlible = "call qcmdexc ('addlible bdvin9' , 0000000015.00000)";
$result = odbc_exec($db, $addlible);
Dans tous les cas, vous pouvez passer en plus l'ordre SQL SET PATH pour fournir une liste de bibliothèques à utiliser pour vos références à :
•vos UDT (types de données définis par l'utilisateur)
•vos procédures cataloguées
•vos fonctions (UDF), si la liste des paramètres est correcte

Voyez la liste des propriétés pouvant être renseignées dans la chaîne de connexion (Dsn) à l'adresse suivante

http://publib.boulder.ibm.com/infocenter/iseries/v7r1m0/topic/rzaik/connectkeywords.htm

et la liste des options de connexion CLI (odbc_setoption() , quand ODBC est sur l'AS400) à

http://publib.boulder.ibm.com/infocenter/iseries/v7r1m0/index.jsp?topic=%2Fcli%2Frzadpfnsenva.htm

Liste partielle :

Clé signification Choix dft odbc_setoption()

DBQ (voir plus haut) Bibliothèque "QGPL" SQL_ATTR_DBC_DEFAULT_LIB

NAM Convention d'appellation. 0 = "sql" ( schema.table)
1 = "system" ( schema/table) 0 SQL_ATTR_DBC_SYS_NAMING

CMT

Niveau de transaction

0 = Commit immediate (*NONE)
1 = Read committed (*CS)
2 = Read uncommitted (*CHG)
3 = Repeatable read (*ALL)
4 = Serializable (*RR)

SQL_ATTR_COMMIT

Attention les valeurs sont différentes

*NONE	1
*CHG	2
*cs	3
*ALL	4
*RR	5

DFT

Format de la Date

0 = yy/ddd (*JUL)
1 = mm/dd/yy (*MDY)
2 = dd/mm/yy (*DMY)
3 = yy/mm/dd (*YMD)
4 = mm/dd/yyyy (*USA)
5 = yyyy-mm-dd (*ISO)
6 = dd.mm.yyyy (*EUR)
7 = yyyy-mm-dd (*JIS)

SQL_ATTR_DATE_FMT

*ISO	1
*USA	2
*EUR	3
*JIS	4
*MDY	5
*DMY	6
*YMD	7

DSP

Séparateur de la Date

0 = "/"
1 = "-"
2 = "."
3 = ","
4 = " "

SQL_ATTR_DATE_SEP

/	1
-	2
.	3
,	4
espace	5
format du job	7

DEC

Séparateur décimal

0 = "." (point)
1 = "," (virgule)

SQL_ATTR_DECIMAL_SEP

.	3
,	4
format du job	7

TFT

Format des Heures

0 = hh:mm:ss (*HMS)
1 = hh:mm AM/PM (*USA)
2 = hh.mm.ss (*ISO)
3 = hh.mm.ss (*EUR)
4 = hh:mm:ss (*JIS)

SQL_ATTR_TIME_FMT

*ISO	1
*USA	2
*EUR	3
*HMS	9

TSP

Séparateur des Heures

0 = ":"
1 = "."
2 = ","
3 = " "

SQL_ATTR_TIME_SEP

(voir la date)

11.1 Fonctions ODBC importantes

Voyez la liste des fonctions ODBC à http://fr.php.net/manual/fr/ref.uodbc.php .

Extrait :

odbc_connect() Pour les connexions persistantes, reportez-vous à odbc_pconnect().

la documentation dit la chose suivante :

les connexions Persistantes peuvent améliorer grandement les performances ,mais doivent être utilisées avec prudence.

Le principal avantage à utiliser des connexions persistantes est le gain de temps lors de la connexion à la base de données. Quand on utilise odbc_close() , la fonction renvoi TRUE, mais ne fait rien.La connexion reste active et attend la prochaine demande de connexion permanante valide (même host, même profil).

Un des problemes majeur est l'utilisation du commitment control.

Vous ne devez utiliser les connexion persistantes que si vous êtes Hors commitment control (dit aussi “autocommit”).

Utiliser conjointement les connexions persistantes et le contrôle de validation peut engendrer des transactions à l'état instable.

Vous devez aussi considérer que le travail serveur sur le iSeries risque de rester actif en permanence, donc les fichiers toujours ouverts.

odbc_exec() exécute une requête SQL

<?php
$db = odbc_connect($dsn, $user, $pwd);
$resultat = odbc_exec($db, "select * from pays");
//$resultat contient 0 si la requête ne fonctionne pas, -1 dans le cas contraire.
// sur les autres bases, $resultat contient le nombre de lignes, c'est une information toujours pas fournie par DB2/400
?>

odbc_error() code erreur retourné par le driver

odbc_errormsg() texte du message d'erreur

les messages ont le format suivant :

	[vendor][ODBC-component][data-source]

<?php
if ($resultat == 0) {
echo ("<BR><B>Erreur " . odbc_error() . " : " . odbc_errormsg() . "</B>");
} else {
...

odbc_num_fields() indique la nombre de colonnes résultat

odbc_field_name() retourne le nom d'une colonne (dont on fournit le n°)

// entetes
echo '<TABLE border=\"1\">';       // notez les \" pour protéger le ", destiné au html
echo "<TR>";

   // boucle sur les noms de colonnes de la requête ==> ATTENTION on commence à 1
   for ($i = 1 ; $i <= odbc_num_fields($resultat) ; $i++) {
     echo("<TH>".odbc_field_name($resultat,$i)."</TH>");
   }

   echo "</TR>";

odbc_fetch_row() se positionne sur la ligne suivante du curseur et retourne TRUE (l'accès aux données se fait par ensuite par odbc_result)

odbc_result() accède aux données de la ligne en cours (odbc_fetch_row) d'après le nom ou le N° de colonne

$rc = odbc_fetch_row($result);

while($rc != FALSE) {
echo("<TR>");
//
for ($j = 1; $j <= odbc_num_fields($resultat); $j++) {
echo("<TD>" . odbc_result($resultat, $j) . "</TD>");
}
echo("</TR>");
$rc = odbc_fetch_row($resultat);
}

odbc_fetch_into() retourne le nombre de colonnes de la ligne ou false en fin de fichier.
La ligne lue est placée dans un tableau indicé (fourni en paramètre)

// lignes détail
  while(odbc_fetch_into($resultat , $lignetbl) != FALSE) {
   echo("<TR>");
    // boucle sur les valeurs d'une ligne. ==> ATTENTION, dans un tableau on commence à 0
    for ($j = 0 ; $j < odbc_num_fields($resultat) ; $j++) {
      echo("<TD>" . lignetbl[$j] . "</TD>");
    }
    echo("</TR>");
   }
echo "</TABLE>";

odbc_fetch_array() retourne la ligne suivante dans un tableaux associatif (qui est la valeur retournée) ou false en fin de fichier
(la clé du tableau est le nom de la colonne)

$lignetbl=odbc_fetch_array($resultat);
if ($lignetbl != FALSE) {
// tableau associatif, on utilise pas un indice numérique, mais le NOM de la colonne
       echo("<TD>" . $lignetbl["PAYS"] . "</TD>");
       echo("<TD>" . $lignetbl["PAYS_CODE"] . "</TD>");
}

odbc_close() ferme la connexion ODBC au serveur
odbc_commit() commit (confirme) la transaction en cours
odbc_rollback() invalide la transaction en cours

ces deux fonctions n'ont de sens que si vous êtes sous contrôle de validation

Remarques concernant les mises à jour (update) et les insertions (insert)

Si vous travaillez sur des fichiers (Tables) non journalisé, vous devez être hors commitment control (CMT à 0 ou SQL_ATTR_COMMIT à 1) ce qui n'est jamais la valeur par défaut.Si vous travaillez sur des tables journalisées et sous commitment control, pensez à valider (Commit)

Si vous êtes sur une version récente de Linux, elle fonctionne (ainsi que Apache) en UTF-8, (basé sur Unicode) et le driver ODBC de Client Access traduit les données en utilisant la routine iconv(). Cette dernière pose un problème avec nos caractères (Latin-1, soit ISO-8859-1 ou 8859-15 avec l'Euro)

Vous recevez alors le message
[unixODBC][IBM][iSeries Access ODBC Driver][DB2 UDB]SQL0104 - Error message text unavailable. Message can not be translated successfully.

pour résoudre ce problème, passez la locale en Français, par setlocale(LC_ALL, 'fr_FR') lors de la connexion.

Nous vous proposons donc, comme code de connexion universel et implémentant nos règles habituelles de fonctionnement :

<?
$isPase = (PHP_OS == "AIX" || PHP_OS == "OS400");              
$system = "AS400";
$bib = "MABIBPF";
$user = "USER";
$pwd = "PWD";

//connexion, sans commitment control, convention d'appellation système(==> *libl) et date au format DMY
// à adapter en fonction du contexte (fichiers journalisés ou pas, etc ...)
if (!$isPase) {
    // sur PC 
    $dsn = "DRIVER=iSeries Access ODBC Driver;SYSTEM=$system;CMT=0;NAM=1;DFT=2";
    $db = odbc_connect($dsn, $user, $pwd);
    if ($db == 0){
        echo ("<BR><B>Erreur Connexion " . odbc_error() . ": " . odbc_errormsg() . "</B>");
    }
    if (PHP_OS == "Linux") {
        setlocale(LC_ALL, 'fr_FR') ;
    }
} else { 
    // sur I5 
    $db = odbc_connect($system, $user, $pwd);
    odbc_setoption($db, 1, SQL_ATTR_COMMIT, 1); 
    odbc_setoption($db, 1, SQL_ATTR_DBC_SYS_NAMING, 1); 
    odbc_setoption($db, 1, SQL_ATTR_DATE_FMT, 6); 
}

//dans tous les cas
// mise en place *LIBL 

$lg = '00000000' . number_format(strlen($bib) + 9, 5 , ".", "");
$addlible = "call qsys/qcmdexc ('ADDLIBLE " . $bib . "' , $lg)";
$result = odbc_exec($db, $addlible);
if ($result == 0){ 
    echo "Erreur mise en place *LIBL " . $addlible;
    echo ("<BR><B>Erreur " . odbc_error() . ": " . odbc_errormsg() . "</B>");
}
// mise en place des bibliothèques pour les fonctions et les procédures
$setpath = "set path='QSYS,QSYS2,BIBFCT1,BIBFCT2'";
$result = odbc_exec($db, $setpath);
if ($result == 0){ 
    echo "Erreur SETPATH " . $setpath;
    echo ("<BR><B>Erreur " . odbc_error() . ": " . odbc_errormsg() . "</B>"); 
} 
?>

Mise à jour de données contenant une apostrophe (quote) comme dans 'pomme d'api'

• Si vous avez activé l'option magic_quotes_runtime (dans php.ini) l'apostrophe est protégée par un \ ('pomme d\'api') Ca marche avec certaines bases, mais pas avec DB2, sauf à ajouter magic_quotes_sybase qui ajoute ' (donc, double la quote) et non \.

la fonction get_magic_quotes_runtime() permet de connaitre la valeur en cours, set_magic_quotes_runtime() de la modifier.

• Doublez la quote manuellement, par :
```
str_replace("'" , "''" , variableAtraiter);
```
Si vos données sont en Unicode sur le system i

remplacez SetEnv="CCSID=819" par SetEnv="CCSID=1208" dans le fichier fastcgi.conf (ZendServer uniquement)

ajoutez :

odbc_setoption($link, 1, SQL_ATTR_UTF8, 1);

11.2 Fonctions DB2_Connect

Sur Unix/linux et I5/OS, vous pouvez utiliser les routines DB2

Pour se connecter à des bases de données IBM DB2 Universal Database pour linux, UNIX et Windows ou IBM Cloudscape ou Apache Derby (version Open Source), vous devez installer un client IBM DB2 Universal Database sur le serveur qui utilise PHP.

Pour se connecter à des bases de données IBM DB2 Universal Database pour iSeries (ou z/OS), vous devez installer DB2 Connect.

Pour se connecter depuis un serveur I5/iSeries, vous n'avez rien à faire.

Voyez la liste des fonctions à http://fr.php.net/manual/fr/ref.ibm-db2.php

Ces fonctions sont disponibles, tel quel, sous Zend Core for I5/OS ou Zend Server

Extrait :

db2_connect() Pour les connexions persistantes, utilisez db2_pconnect() et reportez vous à odbc_pconnect()

paramètres :

database : nom du I5 ou blanc pour se connecter sur la machine en cours
username : nom d'utilisateur, facultatif.
s'il nest pas indiqué, le PROFIL de référence pour apache (QTMHHTTP ou NOBODY ?) se connecte
password : à renseigner si username l'est.

options
tableau d'options (facultatif) renseigné par $option = array('option1' => VALEUR1, 'option2' => VALEUR2)

CURSOR
DB2_FORWARD_ONLY : lecture avant uniquement, positionnement impossible
DB2_SCROLLABLE : toutes lectures et positionnement possibles
i5_lib
nom de la bibliothèque par défaut, si la convention d'appellation est SQL
i5_naming
DB2_I5_NAMING_OFF la convention d'appellation est SQL
DB2_I5_NAMING_ON la convention d'appellation est celle système
i5_commit
DB2_I5_TXN_NO_COMMIT : *NONE (pas de controle de validation)
DB2_I5_TXN_READ_UNCOMMITTED : *CHG
DB2_I5_TXN_READ_COMMITTED : *CS
DB2_I5_TXN_REPEATABLE_READ : *RR
DB2_I5_TXN_SERIALIZABLE : *ALL
i5_query_optimize
DB2_FIRST_IO optimisation pour la première entrée/sortie
DB2_ALL_IO optimisation globale de la requête
i5_date_fmt
DB2_I5_FMT_ISO : YYMD
DB2_I5_FMT_USA : MDYY
DB2_I5_FMT_EUR : DMYY
DB2_I5_FMT_JIS    : YYMD
DB2_I5_FMT_MDY : MDY
DB2_I5_FMT_DMY : DMY
DB2_I5_FMT_YMD : YMD
DB2_I5_FMT_JUL    : YYddd (N° de jour dans l'année)
DB2_I5_FMT_JOB    : format du travail (JOBD d e l'utilisateur)
i5_date_sep
DB2_I5_SEP_SLASH    /
DB2_I5_SEP_DASH     -
DB2_I5_SEP_PERIOD .
DB2_I5_SEP_COMMA ,
DB2_I5_SEP_BLANK l'espace
DB2_I5_SEP_JOB       le séparateur du travail
i5_time_fmt
DB2_I5_FMT_ISO : HH.MM.SS
DB2_I5_FMT_USA : HH.MM AM
DB2_I5_FMT_EUR : HH.MM.SS
DB2_I5_FMT_JIS : HH:MM:SS
DB2_I5_FMT_HMS : HH:MM:SS
i5_time_sep
DB2_I5_SEP_COLON :
DB2_I5_SEP_PERIOD .
DB2_I5_SEP_COMMA ,
DB2_I5_SEP_BLANK l'espace
DB2_I5_SEP_JOB le séparateur du travail

i5_decimal_sep
DB2_I5_SEP_PERIOD .
DB2_I5_SEP_COMMA ,
DB2_I5_SEP_JOB le séparateur du travail

$option = array("i5_lib"=>"MABIB","i5_naming"=>DB2_I5_NAMING_ON, "i5_commit"=>DB2_I5_TXN_NO_COMMIT);

$db = db2_connect("AS400", "PROFIL", "MOTDEPASSE", $option);

db2_conn_errormsg() texte du message d'erreur, si erreur lors de la connexion
db2_exec() exécute une requête SQL non préparée
db2_prepare() prépare une instruction SQL pour utilisation ultérieure avec db2_execute
la requête peut éventuellement, contenir des marqueurs ( ? ) de paramètre
db2_execute() exécute une requête préparée et transmet un tableau (facultatif) de paramètres

$requete = "CALL BIB.PROC1 (?)";

$result= db2_prepare($db, $requete);
$parm = array('x');

if (db2_execute($result, $parm) ){

.../...

}

db2_bind_parameter() associe une variable PHP à un paramètre de procédure
(la variable doit exister)

$requete = "CALL BIB.PROC2 (? , ?)";

$stmt= db2_prepare($db, $requete);

$info = '*time';
$retour = '';

$rc = db2_bind_param($stmt, 1, 'info', DB2_PARAM_IN);
$rc = db2_bind_param($stmt, 2, 'retour', DB2_PARAM_OUT);

$rc = db2_execute($stmt);
if ($rc == FALSE){
echo ("<BR><B>Erreur " . db2_stmt_error() . ": " . db2_stmt_errormsg() . "</B>");
} else {
echo "Heure : " . $retour;
}

db2_stmt_error() code erreur retourné par le Driver DB2
db2_stmt_errormsg() texte du message d'erreur de la dernière requête

les messages ont le format suivant :

	MONPF de type *FILE dans MABIB non trouvé. SQLCODE=-204
db2_num_fields() indique le nombre de colonnes résultat

db2_field_name() retourne le nom d'une colonne (dont on fournit le n°)

// entetes
echo '<TABLE border="1">';
echo "<TR>";

   // boucle sur les noms de colonnes de la requête ==> ATTENTION on commence à 0 avec db2
   for ($i = 0 ; $i < db2_num_fields($resultat) ; $i++) {
     echo("<TH>".db2_field_name($resultat,$i)."</TH>");
   }

   echo "</TR>";

db2_fetch_row() se positionne sur la ligne suivante du curseur et retourne TRUE (l'accès aux données se fait par ensuite par db2_result)

db2_result() accède aux données de la ligne en cours (db2_fetch_row) d'après le nom ou le N° de colonne (la première porte le n° 0)

vous pouvez indiquer un N° de ligne en 2ème argument, si l'option DB2_SCROLLABLE est active

$rc = db2_fetch_row($result);

while($rc != FALSE) {
echo("<TR>");
//
for ($j = 0; $j < db2_num_fields($result); $j++) {
echo("<TD>" . db2_result($result, $j) . "</TD>");
}
echo("</TR>");
$rc = db2_fetch_row($result);
}

Sur IBM i, il est préférable d'utilisier db2_fetch_array() au lieu de db2_fetch_row()/db2_result().

En général db2_fetch_row()/db2_result() a plus de problèmes avec des types de colonne variés dans la traduction de EBCDIC/ASCII, en incluant de possibles troncatures dans les applications DBCS. db2_result ne fonctionne pas, non plus avec des BLOB. Vous pourriez enfin, aussi trouver de meilleures performances à utiliser db2_fetch_array().

db2_fetch_array() retourne la ligne en cours dans un tableau indicé par N° de colonne (pas commeODBC) ou false en fin de fichier.

vous pouvez indiquer un N° de ligne en 2ème argument, si l'option DB2_SCROLLABLE est active

// lignes détail
$lignetbl = db2_fetch_array($resultat);
while ($lignetbl != FALSE) {
   echo("<TR>");
    // boucle sur les valeurs d'une ligne. ==> ATTENTION, dans un tableau on commence à 0
    for ($j = 0 ; $j < db2_num_fields($resultat) ; $j++) {
      echo("<TD>" . lignetbl[$j] . "</TD>");
    }
    echo("</TR>");
    $lignetbl = db2_fetch_array($resultat);
   }
echo "</TABLE>";

db2_fetch_assoc() retourne la ligne suivante dans un tableaux associatif (qui est la valeur retournée) ou false en fin de fichier
(la clé du tableau est le nom de la colonne)

$lignetbl=db2_fetch_assoc($resultat);
if ($lignetbl != FALSE) {
// tableau associatif, on utilise pas un indice numérique, mais le NOM de la colonne
       echo("<TD>" . $lignetbl["PAYS"] . "</TD>");
       echo("<TD>" . $lignetbl["PAYS_CODE"] . "</TD>");
}

db2_close() ferme la connexion ODBC au serveur

db2_commit() commit (confirme) la transaction en cours

db2_rollback() invalide la transaction en cours

12.Les cookies

Les cookies permettent de sauvegarder sur le poste 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]]]]]);

<?php

setcookie("Session_site", SID, time()+3600*24, "/", ".site.com", 0);

/* envoi d'un cookie non sécurisé contenant, l'identifiant de session du site 'site.com' avec une durée de vie de 24 heures */

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

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 $_COOKIE["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.

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

Les cookies sont transmis dans l'entete HTTP, si vous transmettez des données avant le cookie vous risquez de recevoir:

"Header already sent" ou entêtes déja envoyées .

12.1 Entêtes HTTP pouvent être transmises ,par la fonction header() :

Set-Cookie: nom=valeur
Content-Type: type/sous-type mime
Permet de retourner autre chose que du HTML
Location: http://nouveau-serveur/nouvelle-page
pour rediriger automatiquement le client vers une autre page
WWW-Authenticate: basic realm="nom du serveur"
demande d'authentification, pour le domaine "nom du serveur"

doit être suivi de :

header('HTTP/1.0 401 Unauthorized'); // envoi de l'erreur 401
echo('le texte à afficher en cas d'authentification invalide'); // une ou plusieurs lignes
exit; // impératif !

L'id utilisateur saisi sera stocké $_SERVER['PHP_AUT_USER']
le mot de passe dans $_SERVER['PHP_AUT_PW']

si $_SERVER['PHP_AUT_USER'] est vide, isset() retourne FALSE, il faut demander l'authentification.

12.2 Autres astuces WEB

flush() forcer l'apparition d'une partie de la page avant un traitement long (accès base de données)

putenv('nomvar=valeur') mémoriser une information dans une variable d'environnement

pour retrouver la valeur : $_ENV['nomvar']

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

// Envoi d'un email simple à plusieurs destinataires.

$sujet = "Newsletter n°125";
$message = "Sommaire de la Newsletter..." . "\r\nContenu...\r\nMerci\r\n";

mail("af400@volubis.fr, someone@free.fr, unautre@aol.com", $sujet,$message)

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

13.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, sans transmission de paramètres.

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

Les ID de session (SID) sont mémorisés sur le poste client dans un cookie, SI cela n'est pas possible il faut appeller chaque page avec ?PHPSESSID=$sid

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

13.1.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 par $_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 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_globals est activée, les variables de la session seront disponibles à partir des variables globales correspondantes.

session_register("nom_variable");

...

echo $nom_variable;

13.2.Les fonctions de sessions

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

(voyez la documentation à http://fr.php.net/manual/fr/ref.session.php )

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.

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

<?php

function nom_fonction([$param_1 [= val_déf],..., $param_N [= val_déf]])
{
Bloc d'instructions...
[return valeurs...;]
}

$resultat = nom_fonction([arg_1, ..., arg_N]);

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'

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

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

15.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, peux contenir des données

<?php

class Producteur

{
    public $prcode;
    public $nom;
    public $email;

}

puis

<?php

$prod = new Producteur();

$prod->nom = 'Château l\'Angelus';

$prod->email = 'contact@langelus.com';

echo 'Producteur n° ' . $prod->prcode . $prod->nom;
?>
// notez l'appartenance se faisant par -> (en java, entre autre, on utilise le point)

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

<?php

class Producteur

{
    public $prcode;
    public $nom;
    public $email;

   public function formatNom()
   {
      return ucwords($this->nom);
    }

}

puis

<?php

$prod = new Producteur();

$prod->nom = 'château l\'angelus';

$prod->email = 'contact@langelus.com';

echo 'Producteur ' . $prod->formatNom()
?>

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)

<?php

class Producteur

{
    public $prcode;
    public $nom;
    public $email;

   public function __construct($code, $nom , $mail)
   {
      $this->prcode = $code;
      $this->nom = $nom;
      $this->email = $mail;


    }

}

puis

<?php

$prod = new Producteur(1, 'chateau montus', 'montus@madiran.fr');

echo 'Producteur ' . $prod->nom . ' ' . $prod->email
?>

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 :

<?php
class Producteur
{
  public $prcode;
  public $nom;
  public $email;
  public $pwd;

public function changePwd($newpwd)
{
$this->pwd = $newpwd;
Echo 'mot de passe modifié';
}

}

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

<?php

class ProducteurFR extends Producteur
{
}

$prod = new ProducteurFR();

$prod->changePwd('coucou');

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

<?php
class ProducteurFR extends Producteur
{
public function changePwd($newpwd)
{

   parent::changePwd($newpwd);
   $to = "cmasse@volubis.fr";
   $subject = "mot de passe";
   $body = "mot de passe modifié";

$headers = 'From: infos@@volubis.fr' . "\r\n". 'X-Mailer: PHP/' . phpversion();

if (mail($to, $subject, $body, $headers)) {
          echo("<p>Mail envoyé!</p>");
        } else {
          echo("<p>prb lors de l'envoi de mail.</p>");
       }
}
}

$prod = new ProducteurFR();

$prod->changePwd('coucou');

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

<?php
class DB
{
private static $conn = null;

public static function getInstance()
{
   if (self::$conn === null)
    {
       self::$conn =   db2_connect("AS400", "PROFIL", "MOTDEPASSE");
     }
     return self::$conn;
  }
}

function f1()

{

conn = DB::getInstance();

}

function f2()

{

conn = DB::getInstance();

}

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

<?php
interface achatVin_modele
{
public function verifCepage();
public function calculPrix();

}

class function achatVin implements achetVin_modele

{

}

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.

15.5.Exceptions

Un exception est une manière élégante de gerrer les erreurs en séparant la gestion des erreurs des valeurs retour

$headers = 'From: infos@@volubis.fr' . "\r\n". 'X-Mailer: PHP/' . phpversion();

if (mail($to, $subject, $body, $headers)) {
          echo("<p>Mail envoyé!</p>");
        } else {
          throw new Exception('Erreur lors de l\'envoi de mail');
}
}

une exception peut ensuite être interceptée par le couple d'instructions try/catch (un peu comme MONITOR/ENDMON en RPG)

<?php

$prod = new ProducteurFR();

try{

$prod->changePwd('coucou');

} catch (Exception $e) {

echo $e->getmessage();

}

la classe Execption posséde les méthodes suivantes :

getMessage() : retourne le message d'erreur
getCode() : retourne le code erreur (optionnel)
getFile() : retourne le nom du fichier ayant généré l'exception
getLine() : retourne le N° de la ligne en erreur
getTrace() : reotune tous les points précédents sous forme d'un tableau
getTraceAsString() : retourne tous les points précédents, mais sous forme d'une chaine

16.PDOs

PHP 5.1

il s'agit d'un objet, masquant la complexité et les disparités des différents drivers.

il offre le grand avantage de proposer un accès transparent aux base de données y compris l'appel aux procédures cataloguées.

Création d'une nouvelle instance de l'objet PDO (cela créé la connexion)

<?php try { // connexion via le driver DB2_CONNECT // ibm:AS400 aurait utilisé DB2 connect // on peut fournir un tableau d'options propres au driver $db = new PDO('ibm:AS400', 'user', 'pwd' ); echo "Connecté !" } catch (Exception $e) { echo "Erreur : " . $e->getMessage(); }

?>

Exécution d' une requête et affichage du résultat

$req = $db->prepare("select
          * from fichier ");

        

        if ($req->execute())
        {

        while (($row = $req->fetch())
        !== false) {

        print_r($row);

        }

        }

Deuxième exemple plus détaillé

<?php

 // Ouverture d'une connection PDO
 $bdd = new PDO('ibm:AS400', "user", "pwd");

 // Requete
 $query= "select vin_code, vin_nom from bdvinA.vins order by vin_nom fetch first 10 rows only";
           
 $request = $bdd->query($query);
           
?>

<p>Résultat : </p>
<table border ="1">
<tr>
<th>ID</th>
<th><b>Nom du vin</th>
</tr>
<?php

 while ($ligne = $request->fetch()) {
           echo("<TR>");
           echo("<TD>" . $ligne['VIN_CODE'] . "</TD>");
           echo("<TD>" . $ligne['VIN_NOM'] . "</TD>");
           echo("</TR>");
   
 }

$request->closeCursor();
?>

Paramètres de la méthode fetch
- PDO::FETCH_ASSOC, retourne un tableau associatif indicé par les noms de colonne
- PDO::FETCH_NUM, retourne un tableau indicé dont le premier poste est d'indice 0
- PDO::FETCH_BOTH (dft) retourne un tableau accessible par nom de colonne ou par indice

Gestion d'une transaction (commit/rollback)

try {

             // connexion via DB2
          Connect

   $db = new PDO('ibm:AS400', 'user', 'pwd',

array(PDO_ATTR_PERSISTENT => true));

   $db->setAttribute(PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION);

    $db->beginTransaction();
    $db->exec("insert into BDVIN1.appellations values (998 , 'Priorat')");
    $db->exec("insert into BDVIN1.appellations values (999 , 'DAO Penedes')");
    $db->commit();

} catch (Exception $e) {
   $db->rollBack();
   echo "Erreur : " . $e->getMessage();
}

Appel à une procédure cataloguée (le paramètre a été déclaré en sortie, c.a.d retourné par la procédure)

$req
            = $db->prepare("CALL BDVIN1.procedure1(?)");

        $req->bindParam(1,
        $retour, PDO_PARAM_STR, 4000); // N° , $variable, type, lg 

        

        // exécution

        $req->execute();

        

        print "valeur retourn&eacute;e
        $retour\n";

Voyez la liste des méthodes à http://php.net/manual/fr/book.pdo.php

et cette page IBM expliquant comment utiliser PDO avec DB2

PHP

Utiliser PHP pour accéder aux Données IBM i (OS/400).

Préambule

1.Introduction au langage

1.1.Syntaxe de base du langage PHP

1.2.Insertion des scripts

1.3.Le séparateur d'instructions

1.4.Les commentaires

2.Les fichiers externes

3.Types de données

Description

4.Variables et constantes

4.1.Les constantes prédéfinies

Description

Variables

4.2.La portée des variables

4.3.Les variables dynamiques

4.4.Le transtypage

4.5.Les variables prédéfinies

Description

4.6.Les fonctions de variables

5.Les Opérateurs

5.1.Les Opérateurs d'affectation

Equivalent

Description

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

Exemple

5.3.Les opérateurs arithmétiques

Exemple

5.4.Les opérateurs de comparaisons

Exemples

5.5.Les opérateurs logiques

5.6.Les opérateurs de concaténations

6.Instructions de contrôle

6.1.Structure IF

6.2.Switch

6.3.L'instruction ternaire

6.4.Les boucles

6.4.1.Les boucles For et Foreach

6.4.2.Les boucles while et do...while

6.4.3.Les instructions break et continue

6.4.4.Sortie anticipé du script

6.4.5.Récapitulatif

7.Chaînes de caractères

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

8.Tableaux

8.1.Les tableaux associatifs

8.2.Les tableaux multidimensionnels

8.3.Le parcours des tableaux

8.4.Les fonctions de tableaux

9.Fonctions Date et Heure

9.1.Les formats de date et d'heure

Format

Description

10.Les formulaires

11.Accès à la base de données DB2/400

11.1 Fonctions ODBC importantes

Remarques concernant les mises à jour (update) et les insertions (insert)

11.2 Fonctions DB2_Connect

12.Les cookies

12.3.Envoi de courrier

13.Sessions

13.1.Le traitement des variables de session

13.2.Les fonctions de sessions

14.Fonctions utilisateurs

14.1.Arguments de fonction

14.2.Variables des fonctions

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

15.1.Constructeurs

15.2.Héritage

15.3.Méthodes statiques

15.4.Interfaces

15.5.Exceptions

16.PDOs

©AF400