Tutorial php ( ii )

Dernière mise à jour le par pijaku .

Tutorial PHP3 II

Introduction

PHP3 est un langage 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 fonctionnalités 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 à <?. 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 résultat 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 contrôler 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 exécuter 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 première 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 égal
>= 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
! négation

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
-= soustraction puis affectation
*= multiplication puis affectation
/= division puis affectation
%= modulo puis affectation

Exemples :

$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 séquence 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 définir des constantes a l'aide de la fonction define.

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.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 à 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 à is_float. Les fonctions is_long et is_integer sont équivalentes a is_int.

Type de variables

Les variables PHP sont à 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 éléments;
$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

Différentes 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-même 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 élément, 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 contrôles

[UNDER WORK]

Tests

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 même variable, on utilisera plutôt le test swith
Note: Si le corps du test ne comporte qu'une instruction, les accolades {} sont optionnelles, ( 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ée successivement à chaque case. Si il y a égalité, le bloc d'instruction est exécuté.

Il ne faut pas omettre le break en fin de bloc, sans quoi le reste du switch est exécuté.

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 prénoms\"
}

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 élément 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 être 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 );    // => \"paramètre 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'instruction 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ées

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èles, 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 inclut 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'interpré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 appelé 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 appelé 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 méthodes''. 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 tête 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

Lorsque vous écrivez 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éfixez-les avec un préfixe propre à la librairie

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èmentent 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/

Ce document intitulé « Tutorial php ( ii ) » issu de CodeS SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Tutorial php3
Design patterns [1]
Rejoignez-nous