PRINCIPE de FONCTIONNEMENT

Lorsqu’une requête HTTP est soumise au serveur Web pour une page dont l’extension est «.php», comme pour un fichier HTML, le serveur commence par rechercher dans son arborescence le fichier d’extension «.php». Il va ensuite passer la main à un sous-processus (une dll bien particulière) qui va interpréter le script PHP et produire dynamiquement du code HTML. Ce code HTML est alors envoyé au travers du réseau au navigateur client. De plus, aucune ligne de code PHP n’apparaît côté client dans la mesure où tout le code a été interprété.

SYNOPSIS

Un script PHP peut comprendre a la fois du code PHP et du code HTML, non interprété. On doit donc encadrer les parties comportant le code PHP entre 2 balises <? et ?>. Le reste de la page n’est pas interprété.

<? echo $titrepage ?>

<? echo  » Hello, World ! « ; ?>
Note: La balise Enfin, pour les programmeurs ASP, sachez que les balises <% et %> sont également reconnues.

AFFICHER DU TEXTE 

Le séparateur d’instructions est le ; Il est obligatoire, sauf si l’instruction est suivie de la balise ?>
La fonction echo affiche un (ou plus) argument. Si l’argument est une chaîne entre simple quotte ‘ il est affiché tel quel.
echo ‘Hello, World’;
Avec le quotte double  » les variables contenues dans cette chaîne sont interprétées.
$nom= « Toto »; echo « Hello, $nom »; // Hello, Toto echo ‘Hello, $nom’; // Hello, $nom
On peut également inclure le résultat d’une fonction directement dans un echo.
echo « Votre Nom en majuscule : « , strtoupper( « Toto » ), « \n »; // la fonction strtoupper mets tous les caractères de la chaîne en majuscule.
Pour afficher le caractère  » , on l’insère à l’aide du caractère d’échappement \
echo  » Escaping de caractères : \ » \n »;
On peut inclure des caractères spéciaux pour contrôler le flux affiché : \n saut de ligne \r fin de ligne \t tabulation
Pour terminer l’exécution du script, on utilise la fonction exit();

Pour commenter le code, on utilise :
Commentaire sur une ligne: // ou # Commentaire sur plusieurs lignes: /* … */
Utilisation en mode ligne de commande : On peut exécuter un script PHP en ligne de commande, ce qui permet des usages hors du simple cadre  »Web ». L’option -q évite l’affichage de la première ligne Content-type: text/html
C:\WEB\PHP\> php -q monscript.PHP

LES VARIABLES 

Visibilité et affectation
PHP n’est pas un langage fortement structuré, il ne contient donc pas de partie déclarative clairement définie. Pour définir une variable, il suffit de l’initialiser.
Les variables sont précédées du signe $, quelque soit leur type. Ainsi pour déclarer une variable var : $var=1;
La variable $var est alors définie et vaut 1. Elle devient immédiatement accessible et ce jusqu’à la fin du script.
Type de variables Les variables PHP sont a typage faible. C’est PHP qui décide de son type lors de l’affectation. Il existe six types de données :
Entier (int, integer) Décimal (real, float, double) Chaîne de caractères (string) Tableau (array) Objet (object) Booléen (boolean, uniquement PHP4)
Il est parfois utile de forcer le type d’une variable. On utilise la fonction settype ou bien les opérateurs de casting (int), (string) settype renvoie vrai si la conversion a fonctionné, faux sinon.
$a= 3.1415; $result= settype( $a, « integer » ); // => $a = 3 , $result = 1
Les opérateurs de conversion sont : (string) conversion en chaîne de caractères (int) conversion en entier, synonyme de (integer) (real) conversion en double, synonyme de (double) et (float) (array) conversion en tableau (object) conversion en objet (bool) conversion en booléen
$var= 1; // $var est de type « integer » et vaut 1. $chn=(string) $var ; // $var est de type « string » et vaut  » 1 « .
On peut également utiliser strval, intval, doubleval qui renvoient la variable convertie en chaîne / entier / réel.
$strPI= « 3.1415 »; $intPI= intval( $strPI ); $PI= doubleval( $strPI ); echo  » $strPI / $intPI / $PI »; // => 3.1415 / 3 / 3.1415
Remarque : Ces fonctions ne fonctionnent pas sur les tableaux.
Règles des conversions implicites :
Si la chaîne de caractères contient un point, un e ou un E ainsi que des caractères numériques, elle est convertie en décimal, Si la chaîne de caractères ne contient que des caractères numériques, elle est convertie en entier, Si la chaîne de caractères est composée de chiffres et de lettres, elle est convertie en entier et vaut 0, Si la chaîne de caractères contient plusieurs mots, seul le premier est pris en compte et est converti selon les règles ci-dessus.
$var1 = 1; // $var1 est de type « integer » et vaut 1. $var2 = 12.0; // $var2 est de type « double » et vaut 12. $var3 = « PHP »; // $var3 est de type « string » et vaut « PHP ». $var4 = false; // $var4 est de type « boolean » et vaut false. $var5 = « 5a »; // $var5 est de type « string » et vaut « 5a ».

Références
PHP4 permet d’exploiter les références aux variables, à l’instar du langage C. Une référence à une variable est un accès à la zone mémoire qui contient la valeur de cette variable. Cette référence est désignée par le caractère & placé devant le nom de la variable.
$a = 1 ; // $a a pour valeur 1. $b = &$a ; // $b et $a pointent sur la même zone mémoire. // Ce sont donc deux noms pour la même variable. echo  » $a, $b  » ; // Affiche 1, 1 $a = 2 ; echo  » $a, $b  » ; // Affiche 2, 2
Tests sur les variables La fonction isset permet de tester si une variable est définie. La fonction unset permet de supprimer la variable, et de désallouer la mémoire utilisée. echo isset($a); // => 0 (faux) $a=  » « ; unset($a); // => 1 (vrai) echo isset($a); // => 0 (faux)
La fonction gettype permet de connaître le type de la variable. Elle renvoie une chaîne :  »string » ou  »integer » ou  »double » ou  »array » ou  »object ». $a= 12; echo gettype($a) ; // => « integer » $a= $a / 10; echo gettype($a) ; // => « double » unset($a); echo gettype($a) ; // => « string«
Remarque : Si la variable n’est pas définie, elle renvoie « string ».
Tests sur les variables (suite et fin)
On peut également tester un type particulier a l’aide des fonctions is_array, is_string, is_int, is_float, is_object .
$a= 123; echo is_int($a); // => (vrai) echo is_double($a) // => (faux) echo is_string($a) // => (faux) $a += 0.5; echo is_float($a) // => (vrai)
Remarque : Les fonctions is_double et id_real sont équivalentes à is_float. Les fonctions is_long et is_integer sont équivalentes à is_int.

LES CONSTANTES
PHP permet de définir des constantes a l’aide de la fonction define.
define(« CONSTANTE », « rouge » );
Deux constantes sont prédéfinies par PHP : __FILE__ contient le nom du fichier, et __LINE__ le numéro de la ligne courante.
define( « NEXTPAGE », « script2.PHP » ); echo « Page courante : « , __FILE__ , « Page suivante : « , NEXTPAGE;
pas de $ pour des constantes.

LES OPERATEURS 
PHP dispose des opérateurs classiques inspirés des langages C et Perl.
Comparaison
== égalité > inférieur strict < supérieur strict <= inférieur ou égal >= supérieur ou égal != négation
Logiques Les opérateurs logiques sont utilisés dans les tests, par exemple dans un « if ( condition ) »
&& et || ou xor ou exclusif ! négation
Remarque : les opérateurs and, or , not sont également disponibles et font la même chose.
Arithmétiques + addition – soustraction / division * multiplication % modulo ++ incrément — décrément
Affectation = affectation += addition puis affectation -= soustraction puis affectation *= multiplication puis affectation /= division puis affectation %= modulo puis affectation
$n = 0; $n += 2; // $n vaut 2 $n *= 6; // $n vaut 12 $r= $n % 5; // 12 modulo 5 => $r = 2 if( ++$n == 13 ) echo  » pas de chance « ; // pré-incrément le test renvoie vrai
Remarque : l’opérateur / renvoie un entier si les 2 opérandes sont des entiers, sinon il renvoie un flottant.
Binaires
& ET echo 3 & 6 ; // 0011 AND 0110 => 2 | OU echo 3 | 6 ; // 0011 OR 0110 => 7 ^ XOR echo 3 ^ 6 ; // 0011 XOR 0110 => 5 ~ NOT echo ~3; // NOT 3 => -4
Divers L’opérateur de concaténation est utilisable sur les chaînes scalaires.
$chaîne = « Votre nom est » ; $nom = « Toto »; echo $chaîne .  »  » . $nom; // affiche « Votre nom est Toto » L’opérateur ? : ou opérateur de test trinaire. Sa syntaxe est [test logique] ? [expression si vrai] : [expression si faux]
$a= $b =1; ( $a == $b ) ? $c= 10 : $c = 20; // effectue $c = 10; On peut également l’utiliser pour compacter les séquence de test / affectations
$réponse = ( $a == $b ) ? « a égal b » : « a différent de b » ; echo $réponse; // affiche « a égal b » car le test ( $a == $b ) renvoie vrai

LES TABLEAUX 

Déclarations : $fruits= array();
Affectations : $fruits[0]= « pomme »; $fruits[1]= « banane »; $fruits[] .= « orange »; // équivaut a $fruits[2]= « orange » $fruits= array( « pomme », « banane », « orange » );
Fonctions relatives : sizeoff : Renvoie le nombre d’éléments d’un tableau. C’est un équivalent de count. $nbelements= sizeof( $tableau );
is_array : renvoie true si la variable est de type tableau (ou tableau associatif), false sinon.
reset : la fonction reset($tableau) place le pointeur interne sur le premier élément du tableau, chaque variable tableau possède un pointeur interne repérant l’élément courant.
Fonctions relatives (suite):
end : la fonction end($tableau) place le pointeur interne du tableau sur le dernier élément du tableau.
current : renvoie l’élément courant du tableau.
next : déplace le pointeur vers l’élément suivant, et renvoie cet élément. S’il n’existe pas, la fonction renvoie false.
prev : déplace le pointeur vers l’élément précédent, et renvoie cet élément. S’il n’existe pas, la fonction renvoie false.
each : la fonction $a=each($tablo) renvoie l’index et la valeur courante dans un tableau à 2 elements, $a[0] contient l’index, $a[1] la valeur.
list : la fonction list( $scalar1, $scalar2, … ) construit un tableau temporaire à partir des variables scalaires passées en argument.
key : la fonction key($tablo) renvoie l’index de l’élément courant du tableau.
Fonctions relatives (suite et fin):
sort, rsort, usort, uasort : sont différentes fonctions de tri de tableau.
sort trie par valeurs croissantes, rsort par valeurs décroissantes
$tableau_trie = sort( $tableau );
usort et uasort permettent au programmeur d’implémenter lui-même la fonction de tri utilisée. PHP appelle successivement la fonction qui doit retourner -1 / 0 / 1 suivant que le premier élément est inférieur / égal / supérieur au second. Dans l’exemple ci-dessous, on implémente un tri qui ne tient pas compte des majuscules/ minuscules
function compare_maj( $elem1, $elem2 ) { if( strtoupper( $elem1 ) == strtoupper( $elem2 ) ) return 0; return ( strtoupper( $elem1 ) < strtoupper( $elem2 )) ? -1 : 1; } …….. $tableau_trie = usort( $tableau, « compare_maj » );