Tutorial PHP3

Sommaire

    1. Sommaire
    2. Introduction
      1. Synopsis
      2. Premiers pas
        1. Afficher du texte
        2. Terminer l'execution du script
        3. Commenter le code
        4. Utilisation en ligne de commande
    3. Opérateurs
      1. Comparaison
      2. Logiques
      3. Arithmétiques
      4. Affectation
      5. Divers
      6. Binaires
    4. Constantes
    5. Variables
      1. Tests sur variables
      2. Type de variables
        1. variables scalaires
          1. Affectation
        2. Tableaux
          1. Déclaration
          2. Affectation
          3. Fonctions relatives
        3. Tableau associatif
          1. Déclaration
          2. Affectation
          3. Fonctions relatives
    6. Structures de controles
      1. Tests
        1. if
        2. switch
      2. Boucles
        1. boucle for
        2. boucle while
        3. boucle do .. while
    7. Fonctions
      1. paramètres optionnels
      2. passage de paramètres par adresse
    8. Fonctionnalités avancée
      1. Expressions régulières
        1. ereg
    9. Programmation modulaire
      1. Librairies
      2. Programmation Orientée Objet
        1. Constructeur
        2. Héritage
        3. Limitations
    10. Debugger un script PHP3
        1. Utiliser une fonction de Debugging
        2. Obtenir l'environnement du script
        3. Variables de configuration
    11. Sécurité et PHP3
    12. Conseils de programmation
        1. Pollution de l'espace global
          1. Exemple
    13. Annexes
      1. Différences entre PHP et ASP
      2. Liens utiles
      3. Index

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

<html> <head> <title> <? $pagetitle= "Mon premier script PHP3"; echo $pagetitle; ?> </title> </head> <body> <h1><? echo $pagetitle ?></h1> <? echo " <b> Hello, World ! </b>"; ?> </html>

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

Sommaire

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

Sommaire

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

Sommaire

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

Sommaire

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

Sommaire

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

Sommaire

Fonctionnalités avancée

[UNDER CONSTRUCTION]

Expressions régulières

[UNDER WORK]

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

Sommaire

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

Sommaire

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, "<br>\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.

Sommaire

Sécurité et PHP3

[EN CONSTRUCTION]

Sommaire

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_

<? $HTML_DIRECTORY = "/user/lib/php/"; $HTML_CSSFILE = "mystylesheet.css"; ...

[EN CONSTRUCTION]

Sommaire

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

PHP implémente les expressions régulières

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/

Index


" [1]
# [1]
$GLOBALS [1]
$HTTP_COOKIE_VARS [1]
$HTTP_GET_VARS [1]
$HTTP_POST_VARS [1]
$php_errormsg [1]
$this-> [1]
& [1]
</script> [1]
<? [1] [2]
<?php [1]
<script language="php"> [1]
' [1]
) [1]
-q [1]
. [1]
.inc [1]
/ [1]
/* ... */ [1]
// [1]
; [1] [2] [3]
? : [1]
?> [1] [2]
Objet [1]
POO [1]
Syntaxe [1]
Syntaxes [1]
\ [1]
__FILE__ [1]
__LINE__ [1]
aksort [1]
and [1]
arsort [1]
asort [1]
asp_tags = On [1]
break [1] [2]
case [1] [2]
classe [1]
constructeur [1]
continue [1]
copie [1]
current [1]
default [1]
define [1]
destructeur [1]
doubleval [1]
each [1]
echo [1]
end [1]
ereg [1]
extends [1]
fonctions [1]
for( [1]
gettype [1]
global [1]
héritage [1]
id_real [1]
include [1]
intval [1]
is_array [1] [2]
is_double [1]
is_float [1] [2]
is_int [1] [2]
is_integer [1]
is_long [1]
is_object [1]
is_string [1]
isset [1] [2]
key [1]
ksort [1]
list [1]
memory_limit [1]
modèle [1]
next [1]
not [1]
or [1]
phpinfo() [1]
prev [1]
procédures [1]
require [1]
reset [1]
return [1]
rsort [1]
settype [1]
sizeof [1]
sort [1]
strval [1]
switch [1]
track_errors [1]
track_vars [1]
uasort [1]
unset [1]
usort [1]
valeur par défaut [1]