Tutorial PHP3
Introduction
PHP3 est un language interprété orienté Web. Syntaxiquement, c'est un mélange de C et de Perl. Les scripts PHP3 sont lus et interprétés par le moteur PHP3.
Il comporte au total plus de 500 fonctions. Il est fournit avec des librairies offrant des fonctionalitées diverses : accès aux bases de données, fonctions d'images, sockets, protocoles internet divers...
Synopsis
Un script PHP3 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é.
Note: La balise <?php est équivalente a <?. On peut également utiliser les balises <script language="php"> et </script> Enfin, pour les programmeurs ASP, sachez que les balises <% et %> sont également reconnues.
Le séparateur d'instructions est le ;. Il est obligatoire, sauf si l'instruction est suivie de la balise ?>
Premiers pas
Afficher du texte
La fonction echo affiche un (ou plus) argument. Si l'argument est une chaine entre simple quote ' il est affiché tel quel.
echo 'Hello, World';
Avec le quote double " les variables contenues dans cette chaine sont interprétées.
$nom= "Toto";
echo "Hello, $nom"; // Hello, Toto
echo 'Hello, $nom'; // Hello, $nom
On peut également inclure le resultat d'une fonction directement dans un echo.
echo "Votre Nom en majuscule : ", strtoupper( "Toto" ), "\n";
Pour afficher le caractère ``, on l'escape à l'aide du caractère d'échappement \
echo " Escaping de caractères : \" \n";
On peut inclure des caractères spéciaux pour controler le flux affiché:
\n saut de ligne
\r end of line
\t tabulation
Terminer l'execution du script
on utilise exit();
Commenter le code
Commentaire sur une ligne: // ou #
Commentaire sur plusieurs lignes: /* ... */
Utilisation en ligne de commande
On peut executer un script PHP3 en ligne de commande, ce qui permet des usages hors du simple cadre ``Web''. l'option -q évite l'affichage de la premiere ligne Content-type: text/html
D:\WEB\PHP\> php -q monscript.php3
Opérateurs
PHP dispose des opérateurs classiques du C ainsi que d'autres inspirés du Perl.
Comparaison
== égalité
> inférieur strict
< supérieur strict
<= inférieur ou egal
>= supérieur ou egal
! négation
Logiques
Les opérateurs logiques sont utilisés dans les tests, par ex. dans un if( condition )
&& et
|| ou
xor ou exclusif
! negation
Note: les opérateurs and, or , not sont également disponibles et font la même chose.
Arithmétiques
+ addition
- soustraction
/ division
* multiplication
% modulo
++ increment
-- decrement
l'opérateur / renvoie un entier si les 2 opérandes sont des entiers, sinon il renvoie un flottant.
Affectation
= affectation
+= addition puis affectation
-= sosutraction 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 "unlucky"; // pre-increment le test renvoie vrai
Divers
L'opérateur de concatenation . est utilisable sur les scalaires chaines.
$chaine= "Votre nom est" ;
$nom= "Toto";
echo $chaine . " " . $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 sequence de test / affectations
$reponse = ( $a == $b ) ? "a égal b" : "a different de b" ;
echo $reponse; // affiche "a égal b" car le test ( $a == $b ) renvoie vrai
Binaires
& ET
| OU
^ XOR
~ NOT
echo 3 & 6 ; // 0011 AND 0110 => 2
echo 3 | 6 ; // 0011 OR 0110 => 7
echo 3 ^ 6 ; // 0011 XOR 0110 => 5
echo ~3; // NOT 3 => -4
Constantes
PHP permet de definir des constantes a l'aide de la fonction define.
Deux constantes sont predéfinies par PHP : __FILE__ contient le nom du fichier et __LINE__ le numéro de la ligne courante.
define( "NEXTPAGE", "script2.php3" );
echo "Page courante : ", __FILE__ , "Page suivante : ", NEXTPAGE; // pas de $ pour des constantes
Variables
Les variables sont précédées du signe $, quelque soit leur type. Leur déclaration est optionelle.
On dispose de 3 types de variables: scalaire, tableau et tableau associatif. Il n'y a pas de type pointeur.
Tests sur 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 connaitre le type de la variable. Elle renvoie une chaine : ``string'' ou ``integer'' ou ``double'' ou ``array'' ou ``object''. Note : Si la variable n'est pas définie, elle renvoie "string"
$a= 12;
echo gettype($a) ; // => "integer"
$a= $a / 10;
echo gettype($a) ; // => "double"
unset($a);
echo gettype($a) ; // => "string"
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)
Note: Les fonctions is_double et id_real sont équivalentes a is_float. Les fonctions is_long et is_integer sont équivalentes a is_int.
Type de variables
Les variables PHP sont a typage faible. C'est PHP qui décide de son type lors de l'affectation.
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 chaine
(int) conversion en entier. synonyme: (integer)
(real) conversion en double. synonymes: (double),(float)
(array) conversion en tableau
(object) conversion en objet
On peut également utiliser strval, intval, doubleval qui renvoient la variable convertie en chaine / entier / réel. Ces fonctions ne fonctionnent pas sur les tableaux.
$strPI= "3.1415";
$intPI= intval( $strPI );
$PI= doubleval( $strPI );
echo " $strPI / $intPI / $PI"; // => 3.1415 / 3 / 3.1415
variables scalaires
Les variables scalaires sont de 3 types : chaines, entiers, reels.
Affectation
$nom= "toto";
$age= 23;
Tableaux
Déclaration
$fruits= array();
Affectation
$fruits[0]= "pomme";
$fruits[1]= "banane";
$fruits[] .= "orange"; // equivaut a $fruits[2]= "orange"
$fruits= array( "pomme", "banane", "orange" );
Fonctions relatives
sizeof
Renvoie le nombre d'éléments d'un tableau. équivalent de count
$sz= sizeof( $tablo );
is_array
Renvoie true si la variable est de type tableau (ou tableau associatif), false sinon.
reset
reset($tablo) 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.
end
end($tablo) 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. renvoie false si il n'existe pas
prev
déplace le pointeur vers l'élément précédent, et renvoie cet élément. renvoie false si il n'existe pas
each
$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
list( $scalar1, $scalr2, ... ) construit un tableau temporaire à partir des variables scalaires passées en argument.
key
key($tablo) renvoie l'index de l'élément courant du tableau.
sort, rsort, usort, uasort
Differentes fonctions de tri de tableau.
sort trie par valeurs croissantes, rsort par valeurs décroissantes
$tablo_trie = sort( $tablo );
usort et uasort permettent au programmeur d'implémenter lui-meme la fonction de tri utilisée. PHP appelle successivement La fonction 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;
}
$tablo_trie = usort( $tablo, "compare_maj" );
Tableau associatif
Un tableau associatif est un tableau dont l'index est une chaine de caractère au lieu d'un nombre. On parle aussi de ``hash array'' ou ``hash''. Il se déclare comme un tableau traditionnel, la distinction se fait lors de l'affectation.
Déclaration
$calories= array(); // comme un tableau
Affectation
Affectons un nombre de calories moyen aux fruits.
$calories["pommes"]= 300;
$calories["banane"]= 130;
$calories["litchie"]= 30; // c'est tout petit un litchie
Fonctions relatives
isset
Pour tester l'existence d'un element, on utilise la fonction isset()
if( isset( $calories["pommes"] ) ) {
echo "une pomme contient ", $calories["pommes"] , " calories\n";
}else{
echo "pas de calories definies pour la pomme\n";
}
asort, arsort, ksort, aksort
Ces fonctions de tri conservent la relation entre l'index et la valeur, généralement le cas dans un tableau associatif.
asort trie par valeurs croissantes, arsort par valeurs décroissantes
ksort trie par index (key) croissantes
Structures de controles
Tests
[UNDER WORK]
if
Syntaxes
Test if ``basique''
if( [condition] ) {
...
}
Test if-else :
if( [condition] ) {
...
} else {
...
}
Test if-elseif :
if( [condition] ) {
...
} elseif( [condition] ) {
...
}
Dans le cas de plusieurs tests successif portant sur une meme variable, on utilisera plutot le test swith Note: Si le corps du test ne comporte qu'une instruction, les acollades {} sont optionnels, ( contrairement au Perl).
switch
Le switch n'a pas d'équivalent en Perl. il est l'équivalent du SELECT CASE en Basic. Il permet de confronter une variable à plusieurs valeurs prédéfinies. Il permet un code plus compact et lisible qu'un test if-elseif-elseif...
Syntaxe
switch( [variable] ) {
case [valeur1] :
[bloc d'instructions]
break;
case [valeur2] :
[bloc d'instructions]
break;
...
default:
[bloc d'instructions]
}
La valeur de [variable] est comparé successivement à chaque case. Si il y a égalité, le bloc d'instruction est executé.
Il ne faut pas omettre le break en fin de bloc, sans quoi le reste du switch est éxecuté.
Enfin, le handler default permet de définir des instructions à effectuer par défaut, c'est à dire si aucun case n'a ``fonctionné''.
switch( $prenom ) {
case "bob" :
case "toto" :
case "julien" :
echo "bonjour ", $prenom , " ! vous etes un garçon";
break;
case "anne":
case "béatrice" :
case "patricia" :
echo "bonjour ", $prenom , " ! vous etes une fille";
default:
echo "Bonjour $prenom ! Désolé je ne connais pas beaucoup de prenoms"
}
Boucles
En PHP3, on dispose des structures de boucle similaires au C.
L'instruction break permet de sortir d'une boucle à tout moment.
L'instruction continue permet de revenir au début de la boucle.
for( $i=0; $i < sizeof($tablo ); $i++ ) {
if( $tablo($i] == 'suivant' ) {
continue;
}
if( $tablo($i] == 'fin' ) {
break;
}
echo $tablo[$i], "\n";
}
boucle for
for( [initialisations] ; [test sortie] ; [faire a chaque fois] )
// parcours complet du tablo
for( $i=0; $i < sizeof($tablo); $i++ ) {
echo "tablo($i)= $tablo[$i] \n";
}
boucle while
// parcours du tableau jusqu'au premier element vide
$i=0;
while( isset( $tablo[$i]) ) {
echo "tablo[ $i ] = $tablo[$i] \n";
...
$i++;
}
boucle do .. while
La condition de sortie est située en fin de boucle. Ainsi la boucle est parcourue une fois au minimum.
$fp= fopen( "monfichier.txt" );
do{
$ligne = fgets( $fp, 1024 );
...
} while( ! feof($fp) );
Fonctions
Il n'y a pas de distinction fonctions / procédures en PHP.
Les fonctions PHP prennent de 0 à n paramètres. Ces paramètres peuvent etre de type quelconque.
Note: Il faut implémenter la fonction en amont de son utilisation, contrairement au C. Dans le cas contraire, PHP sort une erreur du type Call to unsupported or undefined function (fonction) in (file) on line (number)
On ne peut pas déclarer le prototype d'une fonction comme par ex. en Pascal.
Voyons une fonction listant le contenu d'un tableau associatif :
function lister_hash( $hash )
{
if( ! is_array( $hash ) ) {
echo "parametre hash non correct";
return;
}
for( reset($hash ); list( $key, $value )= each( $hash ); ) {
echo "$key: $value \n";
}
}
$hash= array( 'nom' => "West", 'prenom' => "Leo" );
lister_hash( $hash ); // => nom:West prenom:Leo
$nom= "Toto";
lister_hash( $nom ); // => "parametre hash non correct"
Par défaut, les variables globales ne sont pas connues à l'intérieur du corps d'une fonction. On peut cependant y accéder à l'aide du mot-clé global.
$debug_mode= 1; // variable globale
function mafonc()
{
global $debug_mode;
if( $debug_mode )
echo "[DEBUG] in function mafonc()";
...
}
Une autre solution est d'utiliser le tableau associatif $GLOBALS, qui contient toutes les variables globales déclarées à un instant T : $GLOBALS['debug_mode'] équivaut à $debug_mode.
Les fonctions peuvent ou non renvoyer un résultat. on utilise l'intruction return. La variable retournée peut etre de type quelconque. Elle est transmise par copie.
paramètres optionnels
Les paramètres optionnels sont autorisés : il suffit de leur affecter une valeur par défaut.
function myfunc( $param1 = "inconnu", $param2="" ) {
echo "param1=$param1 param2=$param2\n";
}
myfunc( "toto", "titi" ); // => "param1=toto param2=titi"
myfunc( "toto" ); // => "param1=toto param2="
myfunc(); // => "param1=inconnu param2="
passage de paramètres par adresse
Par défaut, les paramètres sont transmis par copie, c'est à dire que la fonction possède une copie locale de la variable envoyée. On peut cependant passer un paramètre par adresse en le précédant de &. Cela permet de modifier ce paramètre dans la fonction.
function refparam( $param ) {
$param .= "...modifié"; // . => concatenation de chaine
}
$variable= "le parametre";
refparam( &$variable );
echo $variable; // => "le parametre...modifié"
Fonctionnalités avancée
Expressions régulières
ereg
resultat = ereg( modele , variable, memoires )
ereg permet de comparer une variable à un modèle. Pour plus d'informations sur les modèle, consulter la doc Perl par exemple.
modele est le modèle testé
variable est la variable à tester.
Le tableau memoires contient les variables mise en mémoire dans le modèle, la première étant $memoires[1]. $memoires[0] contient la variable complète
resultat vaut vrai si la variable correspond au modèle.
$filename= "fichier.txt";
$ok= ereg( "\.(.*)^" , $filename, $result );
if( $ok ) {
$ext= $result[1];
echo "l'extension du fichier $filename est $ext\n";
} else {
echo "je n'ai pas trouvé d'extension au fichier $filename\n";
}
Programmation modulaire
La programmation modulaire permet de la réutilisation de code, via l'écriture de librairies.
PHP permet cette modularité via la programmation de librairies classiques et de classes.
Librairies
Les librairies sont des fichiers PHP traditionnels. Leur extension est .inc par convention, mais rien n'empêche d'utiliser .php3. On peut également inclure un fichier HTML ou d'autre type, cependant les éventuels tags PHP ne seront pas interprétés. On inclus un fichier en utilisant include ou require.
Il existe une différence importante entre les deux :
Un fichier inclus par I<include> est inclu dynamiquement, lors de l'execution du code.
Un fichier inclus par I<require> est inclu avant l'interpétation du code. Il est équivalent à la directive #include du C
On peut comprendre la différence sur l'exemple ci-dessous:
if( $user == "Administrateur" ) {
include 'admin_fonctions.inc';
}
if( $user == "Administrateur" ) {
require 'admin_fonctions.inc';
}
Avec include, le résultat est celui escompté, tandis qu'avec require, le fichier malib.inc est inclu quelque soit le résultat du test if.
Programmation Orientée Objet
PHP3 dispose des concepts de POO (Programmation Orientée Objet)
$this-> est l'opérateur de self-reference. On peut utiliser un espace pour plus de lisibilité
$this->nb_roues = 4;
$this -> nb_roues = 4;
Les méthodes se déclarent comme des fonctions.
Constructeur
Le constructeur se déclare comme une méthode. Il doit porter le nom de la classe comme en C++ . Il est appellé automatiquement lors de l'instanciation de la classe.
class Vehicule
{
var $nb_roues;
function Vehicule( $nb_roues )
{
$this-> nb_roues= $nb_roues;
}
function NbRoues()
{
return $this-> nb_roues;
}
...
}
$moto= new Vehicule( 2 );
Héritage
L'héritage simple est possible en utilisant extends.
Note: le constructeur de la classe mére n'est pas appellé automatiquement. Il convient donc de le faire si nécessaire
class Automobile extends Vehicule
{
var $marque= "";
function Automobile( $marque, $nb_roues )
{
$this-> Vehicule( $nb_roues ); // appel constructeur classe parente
$this-> marque= $marque; // set de la marque
}
}
Limitations
Il n'y a pas notion de destructeur d'objet en PHP3.
L'héritage multiple n'existe pas
Il n'y a pas de méthodes et attributs privés. Tout est public et accessible de l'extérieur.
Un objet instancié n'est pas une référence ( un pointeur) mais une variable, sorte de ``tableau associatif muni de methodes''. On peut s'en rendre compte sur une copie d'objet :
$auto= new Vehicule( 4 );
$moto= $auto;
$moto-> nb_roues= 2;
echo $auto-> nb_roues; // 2 et non 4 => $auto et $moto sont deux objets distincts
Debugger un script PHP3
PHP ne possède pas -au moins pour l'instant- d'environnement de développement comparable à ceux du C, Vb et autres. Il faut donc en passer par les bonnes vieilles méthodes de grand-père ;) Voici quelques conseils à ce sujet.
Utiliser une fonction de Debugging
Vous pouvez creer une fonction Dbg( $msg ) qui affiche un message de debugage conditionnel. En tete de fichier, definissez la variable $DEBUG à 1 ou 0 pour activer ou non ces messages.
$DEBUG = 1; // Mode debug activé
function Dbg( $msg ) {
if( $DEBUG ) echo $msg, "
\n";
}
Dbg( "ligne ", __LINE__ , " var vaut $var" );
Obtenir l'environnement du script
La fonction phpinfo() affiche la configuration courante, les variables d'environnement, et plus.
Variables de configuration
La variable de configuration memory_limit permet de fixer la taille limite en octets utilisée par un processus PHP.
Si track_errors est actif, la variable globale $php_errormsg stocke le dernier message d'erreur apparu.
Si track_vars est actif, les variables CGI sont stockées resp. dans les tableaux associatifs $HTTP_GET_VARS, $HTTP_POST_VARS, $HTTP_COOKIE_VARS suivant qu'elles proviennent d'un formulaire en methode GET , POST , dans de cookies.
Conseils de programmation
Pollution de l'espace global
Lorque vous ecrivez une librairie destinée à être réutilisée, evitez au maximum de déclarer des variables globales. Si c'est qaund même nécessaire, préfixer-les avec un préfixe propre à la librairie
Exemple
Dans cette librairie html.inc, on prefixe les variables par HTML_
[EN CONSTRUCTION]
Annexes
Différences entre PHP et ASP
PHP ne possède pas en standard l'équivalent des Sessions ASP. Cependant, il existe des librairies PHP3 qui implémente la Session.
L'éventail de fonctions PHP est nettement supérieur.( plus de 500 fonctions ).
PHP implémente la programmation orientée objet.
PHP reconnait les balises ASP <% et %> ainsi que <%= (permettant l'afichage de variables ). Il suffit pour cela de modifier la configuration: asp_tags = On
PHP gère en standard -et simplement- le File Upload
En plus d'ODBC, PHP gère en accès natifs de nombreux SGBD:
Oracle, Sybase, Informix, mySQL, Adabas, Empress, FilePro, InterBase, mSQL, PostgreSQL, Solid, SQLServer, Unix Dbm.
Liens utiles
Note : la plupart de ces sites sont en anglais
Site officiel PHP3
http://fr.php.net/
Introduction a PHP
http://www.devshed.com/Server_Side/PHP/Introduction/
Tutorials
http://clauer.citeweb.net/php3tut/php3_tut.html [fr]
Installation sur Windows
http://lwest.free.fr/doc/php/configuration_NT_fr.html [fr]
http://www.umesd.k12.or.us/php/win32install.html
http://lwest.free.fr/doc/php/configuration_odbc.html
Librairies
http://px.sklar.com/
http://phplib.shonline.de/