Principes du PHP5
PHP5 est LE script serveur utlime qui vous permettra de rendre votre site
dynamique. Il s'insère à l'intérieur de pages WEB aussi
simplement qu'un script client comme JavaScript. On l'identifie par l'emploi
des balises <?php et ?> au sein même du code HTML.
Cependant, il s'agit bien d'un script serveur avec les conséquences que
cela implique, à savoir que le code proprement dit n'est pas visible
par le client (sauf quand le serveur plante, attention donc à ne pas
placer de mots de passe en clair dans le code si possible)
Le script est donc "éffacé" par le serveur avant que la page ne soit transmise au client. Cependant, la force de PHP5 est de permettre l'insertion de code HTML généré dynamiquement en lieu et place du script. Prenons un exemple illustrant la simplicité de la chose:
<html>
<body>
<?php
echo "Ceci est une page générée dynamiquement";
?>
</body>
</html>Le code ci-dessus apparaîtra au niveau du client sous la forme:
<html>
<body>
Ceci est une page générée dynamiquement
</body>
</html>On voit donc qu'il y a une certaine similitude dans l'interaction avec le code
HTML entre PHP5 (via la commande echo) et Javascript (méthode
document.write)
Description succinte du langage
La syntaxe du langage est classique. Les instructions sont séparées
par des ; et les commentaires suivent la même syntaxe que ceux
de C, c'est à dire qu'ils sont soit délimités par /*
et */, soit par // et la fin de la ligne.
Il est possible d'inclure et d'évaluer un fichier à n'importe
quel endroit du script à l'aide de la directive include dont l'argument
peut être une variable, et dont l'exécution est conditionnable
par une instruction de contrôle de flux. Les structures de contrôles
classiques sont présentes if else elseif, while, for
Variables et types de données
Les types de données supportés sont les entiers, les réels,
les chaines et les tableaux. Toutes les noms de variables sont précédés
d'un $ quel que soit le type des variables accédées.
Les chaînes de caractères sont soit définies entre "
soit entre '. L'utilisation du marqueur " autorise PHP à
remplacer les variables à l'intérieur de la chaîne, ainsi
que les caractères spéciaux \n \r \t \\
\$ \". Dans unes expression arithmétique, les chaînes
de caractères sont automatiquement traduites en entiers ou réels,
même si elles contiennent des caractères alphanumériques
par ailleurs. Ainsi "PHP5"+8 est l'entier 12.
Les tableaux sont de dimensions quelconques et peuvent être utilisés
en liste ou même en hash-table de manière totalement transparente.
L'accès en lecture à un élément s'opère à
l'aide de [...].
Voici les différentes fonctionnalités offertes:
| TABLE | |
| Définition d'un élément | $table[n]="n-ieme element" |
| Définition des éléments | $table=array(val1, ...); |
| LISTE | |
| Ajout d'un élément | $table[]="tete de liste" |
| HASH-TABLE | |
| Définition d'un élément | $table[cle]=valeur |
| Définition des éléments | $table=array(cle1=>val1, ...) |
Fonctions, procédures et objets
Les fonctions, procédures et classes se déclarent de manière similaire au C, selon le schéma suivant:
class objet {
var $propriete de l'objet;
...
function methode de l'objet ($v1, ...)
{
...
return $resultat;
};
... }L'accès aux propriétés de l'objet par les méthodes
de l'objet se réalise par l'emploi de $this->propriete de l'objet.
Pour instancier un objet, il faut utiliser $variable = new objet; et
l'accès aux méthodes ou aux propriétés suit la syntaxe
d'accès $variable->méthode ou proriete
Les paramètres transmis à une fonction peuvent être passés
par référence, il suffit pour cela de les précéder
d'un &. Du point de vue de la fonction, les variables sont toujours
locales et décrites par leur nom précédé d'un $.
Il est aussi possible d'assigner des valeurs par défaut aux arguments
en les faisant suivre de = "valeur par défaut".
La portée des variables dépend du contexte, et elles sont implicitement
locales. Cependant, il est toujours possible à l'intérieur d'une
fonction d'accéder à des variables globales, en le précisant
explicitement. En effet, elles apparaîssent au travers de la hash-table
$GLOBALS. Par exemple, l'addition des variables globales a et b, à
l'intérieur d'une fonction, se réalise de la manière suivante:
$somme=$GLOBALS["a"]+$GLOBALS["b"];Enfin, il est possible de déclarer des variables semi-globales à
l'intérieur des fonctions à l'aide du mot clé static
placé devant la première affectation de la variable. Ces variables
ont la particularité de conserver leur contenu entre deux appels successifs.
PHP5 et le traitement des données
Gestion des fichiers sur le serveur
| Créer un répertoire | mkdir($path, 0700) |
| Supprimer un répertoire | rmdir($dossier) |
| Isoler le nom du fichier | $file=basename($path) |
| Vérifier l'existence d'un fichier | file_exists($fichier) |
| Lire un fichier dans un tableau | $lignes=file($fichier) |
| Copier un fichier | copy($source,$destination) |
| Renommer un fichier | rename($old,$new) |
| Supprimer un fichier | delete($fichier) |
| Date de dernière modification | filemtime($fichier) |
Utilisation des fichiers à distance
Il est possible de charger une page HTML via HTTP ou d'enregistrer un fichier par FTP à l'aide de PHP. Cela permet d'aller chercher des informations sur une page distante, en temps réel, puis de les mettre en page à votre convenance et/ou de les stocker dans une base de données.
Il est possible d'extraire le titre d'une page distante à l'aide du script suivant
<?php
$file=fopen("http://www.page distante.fr", "r");
if (!$file) { echo"<p>Page non accessible</p>"; exit; }
while (!feof($file))
{
$line=fgets($file, 1024);
if (eregi("<title>(.*)</title>", $line, $out))
{
$title=$out[1];
break;
}
}
fclose($file);
?>Le code suivant permet d'écrire dans un fichier sur un seveur FTP distant:
<?php
$file=fopen("ftp://ftp.serveur ftp", "w");
if (!$file) { echo"<p>Serveur non accessible</p>"; exit; }
fputs($file, "Ecriture à distance");
fclose($file);
?>Accès aux bases de données
PHP5 permet d'accèder facilement à un grand nombre de bases de données. Pour de plus amples informations sur l'exploitation des bases de données MySQL et PostgreSQL, reportez-vous aux sections correspondantes de ce site. Pour les autres bases de données, référez-vous à la documentation exhaustive à télécharger ci-dessous.
PHP et les expressions régulières
A l'instar de PERL, il est possible de réaliser en PHP des traitements assez poussés sur du texte à l'aide d'expressions régulières. Voyons tout d'abord les fonctions offertes par PHP dans le domaine de la recherche et du remplacement.
| Recherche unique | preg_match($pattern, $subject, [$matches]) |
| Recherche itérée | preg_match_all($pattern, $subject, $matches, [PREG_SET_ORDER]) |
| Remplacement | preg_replace($pattern, $replacement, $subject) |
| Eclatement d'une chaine | preg_split($pattern, $subject, [$limit]) |
Recherche
- $pattern est une expression régulière
- $subject est la chaîne sur laquelle porte la recherche
- $matches est le tableau contenant les résultats de la recherche
Fonctionnement de $matches pour la recherche unique:
- $matches[0] contient le texte qui satisfait le masque complet
- $matches[1] le texte qui satisfait la première parenthèse...
Fonctionnement de $matches pour la recherche itérée:
- $matches[n][0] contient le n-ième texte qui satisfait le masque complet
- $matches[n][1] le n-ième texte qui satisfait la première parenthèse...
Remplacement
- $pattern est une expression régulière ou une table d'expressions régulières
- $replacement est une chaîne ou une table de chaînes
qui peut contenir des références aux résultats de la
recherche relatifs à chaques parenthèses et qui s'écrivent
\\1 \\2... - l'option /e placée en fin de $pattern force preg_replace à traiter $replacement comme du code PHP
Les expressions régulières sont encadrées par deux symboles / et
suivies éventuellement d'options (e par exemple dans le cas du
remplacement). Voici un apperçu de la syntaxe et de la sémantique
des expressions régulières.
| SYMBOLES DE BASE | |
| ^ | Début de chaîne |
| $ | Fin de chaîne |
| . | N'importe quel caractère sauf le saut de ligne |
| ...|... | OU logique entre deux chaînes de même taille |
| [^...] | Négation |
| (...) | Sous masque |
| QUANTIFICATEURS | |
| ? | Zéro ou une fois |
| * | Zéro, une ou plusieurs fois |
| + | Une ou plusieurs fois |
| {M, N} | Au moins M fois, au plus N |
| {N} | Exactement N fois |
| CARACTERES SPECIAUX | |
| \d | Chiffre |
| \s | Espace |
Pour plus de détails sur les expressions régulières, consulter la documentation sur PERL, les syntaxes étant très similaires.
Interactions avec HTML
La première chose que l'on demande à un script serveur est de permettre la gestion du résultat d'un formulaire.
Formulaires
Tout d'abord, il y a deux manières d'envoyer un formulaire HTML au script PHP, la méthode GET et la méthode POST. La différence essentielle réside dans le fait que les données du formulaire apparaissent en clair dans l'URL lors de l'utilisation de GET, alors qu'elles sont masquées par le navigateur en mode POST.
Un formulaire HTML doit ressembler à cela, dans le cas de la méthode POST:
<form action="script.php" method=POST>
Texte: <input type="text" name="nom"><br>
<input type="submit">
<form>Lorsque le formulaire est envoyé, le script script.php est exécuté. Celui-ci a alors accès à la valeur du champ "Texte" à l'aide de la variable $nom initialisée à la valeur inscrite dans le formulaire. Les champs name sont donc très importants puisqu'ils déterminent les noms de variables générés par PHP.
Cookies
Les cookies HTTP sont gérés de manière transparente par
la fonction SetCookie(). Cependant, il faut veiller à appeler
cette fonction avant que le moindre affichage ne soit envoyé au navigateur,
car les cookies font partie intégrante du "header" HTTP.
Assigner une valeur à un cookie:
SetCookie("Cookie", "valeur", time()+temps d'expiration);Assigner plusieurs valeurs à un cookie:
SetCookie("Cookie[]", "valeur1", time()+temps d'expiration);
SetCookie("Cookie[]", "valeur2", time()+temps d'expiration);Relire un cookie, après avoir exécuté les SetCookie
echo $Cookie;
echo $HTTP_COOKIE_VARS["Cookie"]Création d'une image GIF
Il est possible de créer des images GIF à la volée et même de les sauver, à l'aide de la librairie GD. La marche à suivre pour générer automatiquement des boutons est la suivante:
<?php
Header("Content-type: image/gif");
$titre=implode($argv, " ");
$im=imagecreatefromgif("fond_bouton.gif");
$font=ImageLoadFont("police.ttf");
$couleur=ImageColorAllocate($im, rouge, vert, bleu);
ImageString($im,$font,x,y,$titre,$couleur);
ImageGif($im, "nom du fichier.gif");
ImageDestroy($im);
?>Le fichier sera appelé par un tag <img src="bouton.php?titre">
UpLoad de fichiers sur le serveur par la méthode POST
Il s'agit d'une fonctionnalité très importante de PHP. Voici tout d'abord le code du formulaire de chargement de fichiers
<form enctype="multipart/form-data" action"upload.php"
method=POST>
<input type="hidden" name="MAX_FILE_SIZE" value="1000">
Envoyer le fichier: <input name="userfile" type="file">
<input type="submit">
</form>L'option MAX_FILE_SIZE cachée doit précéder le nom du fichier à charger et représente la taille maximale du fichier à charger (en octets).
Lorsque le formulaire est envoyé, le fichier est automatiquement uploadé, dans un dossier temporaire et avec un nom temporaire. Le script PHP doit donc renommer ou déplacer le fichier, sans quoi il sera effacé après l'exécution du script. Pour ce faire, on dispose des variables suivantes:
| $userfile | Nom temporaire du fichier sur le serveur |
| $userfile_name | Nom original du fichier sur le client |
| $userfile_size | Taille envoyée en octets |
| $userfile_type | Type mime (ex: "image/gif") |
Remarque il est possible de charger plusieurs fichiers, il suffit pour cela de remplacer userfile par userfile[] dans le formulaire. Les variables PHP décrites ci-dessus deviennent alors des tables desquelles il est possible de récupérer les fichiers un à un.
Espace "téléchargement"Documentation |
||
|
Serveur
Windows |
Add-on UltraEdit |
|
