Valeur par défaut des arguments
Vous pouvez définir comme en C++ des valeurs par défaut pour les arguments de type scalaire : function makecoffee ($type = "cappucino") {
return "Making a cup of $type.\n";
}
echo makecoffee ();
echo makecoffee ("espresso");
L'affiche de la fonction ci-dessus est : Making a cup of cappucino.
Making a cup of espresso.
La valeur par défaut d'un argument doit obligatoirement être une constante, et ni une variable ou un membre d'une classe.
En PHP 4.0, il est aussi possible de spécifier qu'un argument n'est pas affecté, (unset) comme argument par défaut. Cela signifie que l'argument ne sera pas affecté, si aucune valeur n'est passée comme argument.
Il est à noter que vous utilisez les arguments par défaut, la valeur par défaut doit se trouver du côté droit du signe '='; sinon, cela ne fonctionnera pas. Considérons le code suivant :
function makeyogurt ($type = "acidophilus", $flavour) { return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt ("raspberry"); // ne fonctionne pas correctement.
L'affiche du code ci-dessus est le suivant :
Warning: Missing argument 2 in call to makeyogurt() in
/usr/local/etc/httpd/htdocs/php3test/functest.html on line 41 Making a bowl of raspberry .
Maintenant comparons l'exemple suivant avec l'exemple suivant :
function makeyogurt ($flavour, $type = "acidophilus") { return "Making a bowl of $type $flavour.\n";
}
echo makeyogurt ("raspberry"); // fonctionne correctement.
L'affichage de cette exemple est le suivant :
Making a bowl of acidophilus raspberry.
old_function
L'instruction old_function vous permet de déclarer une fonction en utilisant une syntaxe du type PHP/FI2 (au détail prè que vous devez remplacer l'instruction 'function' par 'old_function'.
C'est une fonctionnalité relativement peu utile et elle ne devrait être utilisée que dans le cadre de conversion de PHP/FI2 vers PHP3
Mise en garde
Les fonctions déclarées comme old_function ne peuvent pas être appelée à partir du code interne du PHP. Cela signifie, par exemple, que vous ne pouvez pas les utiliser avec des fonctions comme usort(), array_walk(), ou register_shutdown_function(). Vous pouvez contourner ce problème en écrivant un wrapper pour appeler les old_function.
Chapitre 13. Classes et objets
Classe
Une classe est une collection de variables et de fonctions qui concernent ces variables. Une classe est définie en utilisant la syntaxe suivante :
L'exemple ci-dessus définit la classe Cart qui est composée d'un tableau associatif des articles du panier et de deux fonctions pour ajouter ou enlever des éléments au panier.
Les classes sont un type de variable. Pour créer une variable du type désiré, vous devez utiliser l'opérateur new.
$cart = new Cart;
$cart->add_item("10", 1);
L'instruction ci-dessus crée l'objet $cart de la class Cart. La fonction add_idem() est appelée afin de rajouter un article numéro 10 dans la panier.
Une classe peut être une extension d'une autre classe. Les classes "extended" ou "derived" héritent de toutes les variables et de toutes les fonctions de la classe père plus toutes les définitions que vous rajoutez à cette classe. Cela se fait avec le mot clef
"extends".
class Named_Cart extends Cart { var $owner;
L'exemple ci-desssus définit la classe Named_Cart qui possède les même variables que la classe Cart et la variable $owner en plus, ainsi que la fonction set_owner(). Vous créez un panier nominatif de la même manière que précédemment, et vous pouvez alors affecter un nom au panier ou en connaître le nom. Vous pouvez de toutes les façons utiliser les même fonctions que sur un panier classique.
$ncart = new Named_Cart; // Création d'un panier nominatif $ncart->set_owner ("kris"); // affectation du nom du panier print $ncart->owner; // affichage du nom du panier
$ncart->add_item ("10", 1); // (héritage des fonctions de la classe père)
Dans les fonctions d'une classe, la variable $this est égale à l'objet de la classe. Vous pouvez utilisez la forme
"$this->quelquechose" pour accéder aux fonctions ou aux variables de l'objet courant.
Le "constructeur" est la fonction qui est appelée automatiquement par la classe lorsque vous créez une nouvelle instance d'un objet. La fonction "constructeur" a le même nom que la classe.
class Auto_Cart extends Cart { function Auto_Cart () {
$this->add_item ("10", 1);
} }
L'exemple ci-dessus définit la classe Auto_Cart qui hérite de la classe Cart et définit le "construteur" de la classe. Ce dernier initialise le panier avec 1 article de type numéro 10 dès que l'instruction "new" est appelée. La fonction "constructeur" peut aussi prendre des paramètres optionnels ou non, ce qui la rends beaucoup plus puissante.
class Constructor_Cart {
function Constructor_Cart ($item = "10", $num = 1) { $this->add_item ($item, $num);
} }
// Shop the same old boring stuff.
$default_cart = new Constructor_Cart;
// Shop for real...
$different_cart = new Constructor_Cart ("20", 17);
Attention
Pour les classes qui utilisent l'héritage, le constructeur de la classe père n'est pas automatiquement appelé lorsque le constructeur de la classe dérivée est appelé.
III. Caractéristiques
Chapitre 14. Gestion des erreurs
Il y a 4 types d'erreurs et d'alerte PHP :
1 -- Erreur de fonction
2 -- Alerte normale
4 -- Erreur d'analyse
8 -- Notes (alertes qui peuvent être ignorées mais qui peuvent avoir des conséquences sur le code)
Les 4 numéros attachés à un type d'erreur ont été ajoutés pour définir un niveau d'erreur. Par défaut, le niveau d'erreur accepté est de 7, c'est à dire 1 + 2 + 4, ou n'importe quoi, sauf les notes. Ce niveau peut être changé, dans le fichier php3.ini avec la directive error_reporting. Il peut aussi être modifié dans le fichier de configuration Apache httpd.conf avec la directive
php3_error_reporting ou bien encore, lors de l'exécution, en définissant la fonction error_reporting().
Toutes les expressions PHP peuvent être appelées avec le préfixe "@", ce qui permet d'ignorer le rapport d'erreur pour cette fonction particulière. Si une erreur survient dans une telle expression, et que l'option track_errors est activée, vous pouvez retrouver le message d'erreur dans la variable globale php_errormsg.
Chapitre 15. Création d'images GIF
PHP n'est pas limité à la création de fichier HTML. Il peut aussi servir à créer des images GIF à la volée, aussi bien pour les émettre que pour les sauver. Il faut alors compiler PHP avec la librairie GD :
Exemple 15-1. Création d'une GIF avec PHP
<?php
Header("Content-type: image/gif");
$string=implode($argv," ");
$im = imagecreatefromgif("images/button1.gif");
$orange = ImageColorAllocate($im, 220, 210, 60);
$px = (imagesx($im)-7.5*strlen($string))/2;
ImageString($im,3,$px,9,$string,$orange);
ImageGif($im);
ImageDestroy($im);
?>
Cet exemple sera appelé depuis une page HTML avec un tag tel que: <img src="button.php3?text">. Le script ci-dessus récupère le texte de la chaîne $string et l'ajoute sur l'image de fond "images/button1.gif". Le résultat est alors envoyé au client. C'est un moyen très pratique d'éviter d'avoir à redessiner des boutons à chaque fois que le texte du bouton change. Avec ce script, il est généré dynamiquement.
Chapitre 16. Authentification HTTP avec PHP
Les fonctions d'authentification HTTP de PHP ne sont disponibles que si PHP est exécuté comme module Apache, et non pas sous la forme d'un CGI. Sous cette forme, il est possible d'utiliser la fonction Header() pour demander une authentification
("Authentication Required" ) au client, générant ainsi l'apparition d'une fenêtre de demande d'utilisateur et de mot de passe. Une fois que les champs ont été remplis, l'URL sera de nouveau appelée, avec les variables, $PHP_AUTH_USER, $PHP_AUTH_PW et $PHP_AUTH_TYPE contenant respectivement le nom d'utilisateur, le mot de passe et le type d'authentification. Actuellement, seule l'authentification "Basic" est supportée. Reportez vous à la fonction Header() pour plus d'informations.
Voici un exemple de script qui force l'authentification du client pour accéder à une page :
Un exemple de morceau de script qui forcera l'authentification du client pour une page ressemblera à cela:
Exemple 16-1. HTTP authentification
<?php
if(!isset($PHP_AUTH_USER)) {
Header("WWW-Authenticate: Basic realm=\"My Realm\"");
Header("HTTP/1.0 401 Unauthorized");
echo "Texte à envoyer au client en cas d'annulation \n";
exit;
} else {
echo "Bonjour $PHP_AUTH_USER.<P>";
echo "Votre mot de passe est $PHP_AUTH_PW.<P>";
}
?>
A la place d'afficher simplement les variables globales $PHP_AUTH_USER et $PHP_AUTH_PW, vous préférerez sûrement vérifier la validité du nom d'utilisateur et du mot de passe. Par exemple, en envoyant ces informations à une base de données, ou en recherchant dans un fichier dbm.
Méfiez vous des navigateurs buggés, tels que Internet Explorer. Ils semblent très suceptibles concernant l'ordre des entêtes.
Envoyer l'entête d'authentification (WWW-Authenticate) avant le code de HTTP/1.0 401 semble lui convenir jusqu'à présent.
Pour éviter que quelqu'un écrive un script qui révèle les mots de passe d'une page, à la quelle on a accédé par une authentification traditionnelle, les variables globales PHP_AUTH ne seront pas assignées si l'authentification externe a été activée pour cette page.
Dans ce cas, la variabme $REMOTE_USER peut être utilisée pour identifier l'utilisateur à l'extérieur.
Notez cependant que les manipulations ci-dessus n'empêchent pas quiconque qui possède une page non authentifiée de voler les mots de passes des pages protégées, sur le même serveur.
Netscape et Internet Explorer effaceront les informations d'authentification seront effacées du cache dès que le client recevra une réponse du serveur de type 401. Cela permet de considérer que l'utilisateur s'est déconnecté, ce qui le forcera à ré-entrer ses nom d'utilisateur et mot de passe Certains utilisent cette fonctionnalité pour considérer que la session est terminée, ou bien ils fournissent un bouton de déconnexion.
Exemple 16-2. Authentification HTTP avec nom d'utilisateur/mot de passe forcé
<?php
function authenticate() {
Header( "WWW-authenticate: basic realm='Test Authentication System'");
Header( "HTTP/1.0 401 non autorisé");
echo "Vous devez entrer un nom d'utilisateur et un mot de passe valide. \n";
exit;
}
if(!isset($PHP_AUTH_USER) || ($SeenBefore == 1 && !strcmp($OldAuth,
$PHP_AUTH_USER)) ) { authenticate();
} else {
echo "Bienvenue: $PHP_AUTH_USER<BR>";
echo "Vieux: $OldAuth";
echo "<FORM ACTION=\"$PHP_SELF\" METHOD=POST>\n";
echo "<INPUT TYPE=HIDDEN NAME=\"DejaVu\" VALUE=\"1\">\n";
echo "<INPUT TYPE=HIDDEN NAME=\"VieilAuthentification\"
VALUE=\"$PHP_AUTH_USER\">\n";
echo "<INPUT TYPE=Submit VALUE=\"Re Authentification\">\n";
echo "</FORM>\n";
}
?>
Ce comportement n'est pas nécessaire par le standard d'authentification HTTP Basic. Les tests avec Lynx ont montré qu'ils n'effacent pas les informations de sessions lors de la réception d'un message de type 401, ce qui fait que passer ces informations entre le serveur et le client, donnera l'accès à la ressource.
Notez aussi que tout ceci ne fonctionne pas sous Microsoft's IIS et que les limitations de PHP en version CGI sont dues aux limitations de IIS.
Chapitre 17. Cookies
PHP supporte les cookies de manière transparente. Les cookies sont un méchanisme d'enregistrement d'informations sur le client, et de lecture de ces informations. Ce système permet d'authentifier et de suivre les visiteurs. Vous pouvez envoyer un cookie avec la commande setcookie(). Les Cookies font parties de l'entête HTTP, ce qui impose que setcookie() soit appelé avant tout affichage sur le client. Ce sont les mêmes limitations que pour header().
Tous les cookies qui sont envoyés au client seront automatiquement retournés au script PHP, et transformés en variable,
exactement comme pour GET et POST. Si vous souhaitez affecter plusieurs valeurs à un seul cookie, ajoutez [] au nom du cookie.
Pour plus details, reportez vous à la fonction setcookie().