Ceci est la version imprimable de PHP.

Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
Cliquez sur Rafraîchir cette page pour obtenir la dernière version du cours.
Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l’article Versions imprimables.

PHP

Une version à jour et éditable de ce livre est disponible sur la Wikiversité,
une bibliothèque de livres pédagogiques, à l'URL :
http://fr.wikiversity.org/wiki/PHP

Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la Licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections inaltérables, sans texte de première page de couverture et sans Texte de dernière page de couverture. Une copie de cette licence est inclue dans l'annexe nommée « Licence de documentation libre GNU ».

Premier script

**Version imprimable**
Leçon : PHP

Chapitre n^o 1
Retour au	Sommaire
Chap. suiv. :	Syntaxe du langage

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Commentaires

Un commentaire est une portion de code qui n’est pas exécuté par PHP.

PHP supporte deux types de commentaires :

Les commentaires sur une seule ligne : ils sont délimités par // ou # et la fin de la ligne
Les commentaires sur plusieurs lignes, délimités par /* et */

Exemple

/* Script affichant
   le texte "Bonjour" */

echo('Bonjour'); // affichage

# fin du script

PHP ne traitera que la partie echo('Bonjour'); car le reste est commenté.

Les commentaires sont indispensables dans un script. Ils permettent de documenter le code afin d’en améliorer sa lisibilité et d’en faciliter la maintenance. De plus, ils permettent de tester des parties de script en en occultant d'autres.

Le script

Le PHP est conçu pour s'intégrer facilement dans vos pages HTML. Voici un exemple de programme très simple servant à afficher "Bonjour !" sur la page.

Script PHP Basique - Bonjour !
Mon premier script en PHP <?php // La fonction 'echo' permet d'afficher un texte à l'écran echo 'Bonjour !'; ?>

Voici quelques explications sur ce script. Pour définir un script PHP parmi une page HTML, on doit entourer le code par les balises suivantes :

Les balises <?php et ?> encadre toujours un code PHP
<?php //Ici le script php ?>

Il y a aussi des équivalents désuet comme :

Code désuet
<? //Encore un autre script php ?>

Ou alors :

Code désuet
<script language="php"> // script php </script>

Les deux dernières syntaxes sont déconseillées, il est préférable d’utiliser la première syntaxe : en fonction de la configuration du serveur web qui lira votre page PHP, ces balises peuvent ne pas être reconnues, ou être mal interprétées.

Quant à la fonction echo, elle permet d'écrire du texte dans le fichier HTML qui sera envoyé au navigateur. Ce code écrit dans le fichier HTML peut être du texte normal, du code HTML, JavaScript, ou tout autre code compréhensible par un navigateur web.

Il est aussi possible de mélanger plusieurs parties PHP avec plusieurs parties HTML comme l'exemple ci-dessous :

Exemple

<html>
<head>
  <title>Mon second script en PHP</title>
</head>
<body>
<table> 
<tr> <td>
<?php
 //la première case du tableau : un traitement complexe peut y prendre place
?>
</td>
<td>
<?php
 //la seconde case du tableau : un second traitement complexe peut y prendre place !
?>
</td></tr>
</table>
</body>
</html>

PHP

Sommaire

Syntaxe du langage

Syntaxe du langage

**Version imprimable**
Leçon : PHP

Chapitre n^o 2
Chap. préc. :	Premier script
Chap. suiv. :	Structures de contrôle

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Séparateur d'instruction

Un script PHP est une suite d'instructions ordonnant à l'ordinateur d'effectuer certaines opérations. Comme dans la plupart des langages informatiques (C, Java, Perl…), chaque instruction doit être terminée par un point-virgule. Ce dernier permet de délimiter les instructions qui seront exécutées par le serveur PHP.

L'oubli d’un point-virgule déclenchera une erreur ou un fonctionnement incorrect du script. Il est donc indispensable d’être vigilant.

Il est à noter que la balise fermante ?> joue le rôle de point-virgule. Le point virgule de la dernière instruction est, par conséquent, optionnel, mais fortement recommandé. C’est plus clair, et il vaut mieux prendre dès le début l'habitude de terminer ses instructions par un point-virgule.

Affichages

Il y a deux façons d'afficher du texte à partir de PHP, avec les commandes echo et print().

De plus, s'ils renvoient le résultat Array, cela signifie que la variable à afficher est un tableau et qu’il faudrait utiliser print_r() pour montrer son contenu (ou var_dump()).

Versions de PHP

Il existe plusieurs versions du langage, selon les logiciels installés, certaines commandes ne fonctionneront donc pas forcément.

Principe

// En premier  echo
echo 'Voici une ligne de texte en php';  //Affichera Voici une ligne de texte en php

// Puis le print
print ('Voici une seconde ligne en php');   // Affichera la même chose que l'echo

Ces deux codes afficheront exactement la même chose.

Variables

Les variables sont un élément indispensable à tout langage de programmation. C’est grâce à elles que vous pourrez sauvegarder des données entre chaque instruction. En PHP, chaque variable commence par un dollar ($), et les variables d'environnements par $_ (ex : $_SESSION, $_GET, $_POST... voir les chapitres suivants). Comme PHP n’est pas typé (sauf cas très particulier en PHP5), vous pouvez affecter vos variables de la manière qu’il vous plaît avec des chaînes, des entiers… De plus, une variable n'a pas besoin d’être déclarée pour être utilisée : vous pouvez directement l'affecter avec le signe =.

Plus fort, si vous incrémentez une variable qui n'existe pas encore (cf ci-dessous) en faisant $variable++;, alors $variable prendra la valeur 1. PHP l'a implicitement initialisé à 0.

Principe

 // Utilisation des constantes
 define("_constante1", "Chaine2");
 print _constante1;

 // Utilisation des variables
 $var = 64;   // La variable $var vaut 64
 $var = 'Chaine !';   // On passe d’un entier à une chaine sans soucis, la variable $var vaut maintenant Chaine !
 $foo = $var;    // La variable $foo est égal a la valeur de $var, soit $foo = 'Chaine !'

Les variables ne sont pas conservées entre les pages. Une fois votre script terminé, toutes les variables créées seront détruites. Il sera donc nécessaire des les sauvegarder en utilisant, par exemple, le mécanisme des sessions PHP.

Les noms de variables ne peuvent pas contenir n’importe quel caractère. Pour être valides, elles doivent commencer par une lettre (majuscules/minuscules), suivi de lettres capitales ou pas, chiffres ou autres underscores (ex : $MaVariable1, $ma_variable1...).

La portée des constantes leur permet d’être utilisées dans les méthodes de classes, alors que les variables doivent y être déprotégées par le mot global, ex :

 global $var;

Opérateurs

Le langage PHP définit naturellement une liste d'opérateurs, permettant d'effectuer en ensemble d'opération simple. Voici la liste :

Opérateur binaire d'affectation

Comme vu ci-dessus, il s'agit du signe égal : "=", utilisable tant avec les nombre qu'avec les chaînes.

Principe

$var = 5;
$foo = $var;

Opérateurs binaires de calcul

l'addition est réalisée avec le symbole "+".
la soustraction est réalisée avec le symbole "-".
la multiplication est réalisée avec le symbole "*".
la division est réalisée avec le symbole "/".

Exemple

$var = 25;
$foo = 12 + $var / 15 - $var; 
/* $foo vaut maintenant -11.33333… 
   (Voir priorité des opérateurs, plus bas) */

Veuillez noter qu’il existe un raccourci pour ces quatre opérateurs : +=, -=, *=, /=, qui s'utilise lorsque l’on veut effectuer une opération sur une variable. La formule de base est :

var = var opérateur variable|valeur devient var opérateur= variable|valeur.

L'opération réalisée est la même, mais un petit exemple devrait vous éclairer :

Exemple

$var = 2;
$var = $var + 5;    //$var vaudra  2+5, soit 7
$var += 5;          //c'est la même chose !
$var /= 2;          //var vaudra 12/2, soit 6. C’est la même chose que $var = $var / 2

Dates

Pour manipuler des dates, il existe la classe DateTime()^[1], également appelée add_date()^[2] :

<?php
  print 'Nous sommes le ' .  date("l d-m-Y") . '<br />';
  
  $DateFuture1 = new DateTime(date("Y-m-d"));
  $DateFuture1->add(new DateInterval('P1D'));
  print 'Demain, nous serons le ' . $DateFuture1->format('l d-m-Y') . '<br />';

  $DateFuture2 = new DateTime(date("Y-m-d"));
  $DateFuture2->add(new DateInterval('P1M'));
  print 'Dans un mois, nous serons le ' . $DateFuture2->format('l d-m-Y') . '<br />';
  
  $DatePassee1 = new DateTime(date("Y-m-d"));
  $DatePassee1->sub(new DateInterval('P1D'));
  print 'Hier, nous étions le ' . $DatePassee1->format('l d-m-Y') . '<br />';

  $DatePassee2 = new DateTime(date("Y-m-d"));
  $DatePassee2->sub(new DateInterval('P1M'));
  print 'Il y a un mois, nous étions le ' . $DatePassee2->format('l d-m-Y') . '<br />';
?>

Le langage PHP ne peut afficher les noms des jours et des mois qu'en anglais par défaut. Il convient donc de créer des tableaux pour les obtenir en français^[3] :

<?php
 $jours = array('', 'dimanche','lundi','mardi','mercredi','jeudi','vendredi','samedi');
 $mois = array('', 'janvier','février','mars','avril','mai','juin','juillet','août','septembre','octobre','novembre','décembre');
 $datefr = $jours[date('w')].' '.date('d').' '.$mois[date('n')].' '.date('Y');
 echo 'Nous sommes le '. $datefr; exit;
?>

Opérateurs de comparaisons

Ceux-ci fonctionnent de gauche à droite : valeur comparé symbole valeur comparante. Ils retournent un booléen qui vaut vrai si la condition testée est juste, faux sinon.

Voici la liste des opérateurs possibles:

> : est supérieur à
< : est inférieur à
>= : est supérieur ou égal à
<= : est inférieur ou égal à
== : est strictement égal à
=== : est strictement égal à et est de même type (Boolean, Entier, String, Objets…)

Exemple

$var = 25;
echo $var > 26;   //affichera false (faux) car 25 n’est pas supérieur à 26
echo 50 == 21;    //idem
echo $var <= 54;  //affichera true (vrai) car 25 est bien inférieur ou égal à 54

Note: Vous ferez toujours très attention à ne pas confondre les symboles "=" et "==". C’est une erreur courante de débutant.

Concaténation

La concaténation revient à "coller" deux chaînes de caractère entre elles. L'opérateur utilisé est le ".".

Exemple

$foo = 'chaine1' . 'chaine2';         //foo vaudra "chaine1chaine2"
$foo .= 'chaine3';                    //foo vaudra "chaine1chaine2chaine3". On peut utiliser ".=" de la même 
                                      //manière que pour les opérateurs +,-,*,/.

Notez bien qu'en PHP, presque tout peut être concaténer.

En anglais les nombres décimaux sont séparés par des points, ces derniers ne concatènent donc pas les chiffres. Par exemple 1.5 signifie 1,5, et "1"."5" égal 15.

Troncature

Pour tronquer une chaine (le contraire de la concaténation), il existe la fonction substr()^[4]. Le premier paramètre est obligatoire et représente la position de début de la chaine à extraire, le second représente la taille de la chaine s'il est positif, ou la position de fin s'il est négatif.

Exemple

$foo = 'chaine1_chaine2_chaine3';
echo substr($foo,8,7);     // Affiche les 7 caractères à partir de 8 inclus, donc jusqu'à 8 + 7 = 15, donc "chaine2".
echo substr($foo,-7);      // Affiche les 6 derniers caractères, donc "chaine3".
echo substr($foo,8,-8);    // Affiche "chaine2".
echo substr($foo,0,strrpos($foo, "_"));  // Affiche le début jusqu'à l'underscore, donc "chaine1".

echo str_replace('_', '', $foo);  // Affiche "chaine1chaine2chaine3".

Opérateurs unaires

Le signe ! correspond à l'inverse (ainsi en valeur booléen, vrai devient faux et vice-versa).

On peut coupler ce symbole à ceux précédent pour inverser le résultat d’une comparaison:

Principe

$var = 25;
echo !($var > 26);   //affichera true (vrai) car 25 n’est pas supérieur à 26. Équivaut à $var <= 26;

Dans le code ci-dessus, l'opérateur ">" renverra la valeur false car 25 n’est pas supérieur à 26. Cependant, l'opérateur unaire "!" renverra à son tour l'opposé, soit true.

Opérateurs d'incrémentations

Apparus en C, ces opérateurs ont été repris en PHP. l'opérateur ++ signifie "ajouter 1" et l'opérateur -- signifie "retrancher 1".

Principe

$var = 5;
$var++;   //$var vaut 6
$var++;   //$var vaut 7
$var--;   //$var revaut 6

CF en fin de chapitre pour la différence entre pre et post-incrementation.

Opérateur de contrôle d'erreur

@ permet d'ignorer certaines erreurs bloquantes^[5]. Par exemple le fichier suivant n'affichera pas ce qui survient si on retire l'arobase, et qui pourrait sembler disgracieux à la vue des utilisateurs : Warning: Division by zero in test.php on line 2.

@$operation = 1/0;
print $operation;
print '<br />Fin';

Priorité entre les opérateurs

Le PHP n'interprète pas une suite d'opérateurs linéairement, de gauche à droite. Il le fait en fonction de la priorité liée à chaque opérateur utilisé (comme en maths où la multiplication prime sur l'addition). Voici la hiérarchie des principaux opérateurs, des plus prioritaires jusqu'au moins prioritaires :

++ et --
!
* et /
+ et -
<, >, <=, >= et <>
==, !=, === et !==
=

Si deux signes de mêmes priorités sont utilisés, alors le PHP les traite de gauche à droite.

On peut cependant modifier la priorité des termes grâce aux parenthèses. Une opération entre parenthèses sera effectuée en priorité, quel que soit son opérateur, et si elles sont imbriquées, on calcule en premier la plus petite.

Exemple d’utilisation des priorités :

Exemple

$var = 2+6*4;     //sera calculé 6*4 en premier, puis 2 seront ajoutés, soit 26
$var = (2+6)*4;   //sera calculé 2+6, puis la multiplication par 4, soit 32
$var = ((2+6)*5)/(3+4);    //seront calculés: 2+6, multiplié par 5, puis 3+4, et enfin la division entre les deux, soit 40/7.

Références

Structures de contrôle

**Version imprimable**
Leçon : PHP

Chapitre n^o 3
Chap. préc. :	Syntaxe du langage
Chap. suiv. :	Tableaux

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Introduction

Qu'est qu'une structure de contrôle ? Pour faire simple, une structure de contrôle est un ensemble d'instructions qui permet de contrôler l'exécution du code. Il en existe essentiellement deux types :

Les structures de contrôle conditionnelles qui permettent d'exécuter certaines parties du code si une condition spécifique est remplie.
Les structures de contrôle de boucle qui permettent d'exécuter en boucle certaines parties du code (généralement jusqu'à ce qu'une condition soit remplie).

Structures de contrôle conditionnelles

Instruction IF … ELSE …

Principe

IF (ConditionEstRemplie) { ExecuterCode1 } ELSE { ExecuterCode2 }

Exemple

$boolean_IsValid = true;
if($boolean_IsValid)
{
 // Code qui sera exécuté
}
else
{
 // Code qui ne sera pas exécuté dans cet exemple
}

Remarque

La commande ELSE peut être remplacée par la commande ELSEIF si une autre condition doit être vérifiée pour exécuter ExecuterCode2.

Exemple

$boolean_IsValid1 = false;
$boolean_IsValid2 = true;
if($boolean_IsValid1)
{
 // Code qui ne sera pas exécuté
}
elseif($boolean_IsValid2)
{
 // Code qui sera exécuté
}
else
{
 // Code qui ne sera pas exécuté
}

Instruction SWITCH

Principe

SWITCH (VariableAContrôler) { CASE Valeur1 : ExecuterCode1; CASE Valeur2 : ExecuterCode2; … ; DEFAULT : ExecuterCodeParDéfaut; }

Remarque

Il est nécessaire d'insérer la commande BREAK pour n'exécuter que le code correspondant au CASE voulu. C'est-à-dire : supposons que VariablaAContrôler ai une valeur de Valeur1, alors ExecuterCode1 sera exécuté, si ExecuterCode1 se termine par la commande BREAK, l'exécution du code s'arrêtera là, sinon ExecuterCode2 sera exécuté, et ainsi de suite jusqu'à ce que la commande BREAK soit rencontrée ou que l’on arrive à la fin du SWITCH.

Exemple

<?php
$ma_variable = 1;
switch ($ma_variable) {
 case 1:
	// Code si $ma_variable est égale à 1
	echo $ma_variable.'<br />';
 
 case 2:
	// Code si $ma_variable est égale à 2 (ou 1 puisque le cas ci-dessus se poursuit en l'absent de "break")
	echo $ma_variable.'<br />';
	break;
 
 case 3:
	// Code si $ma_variable est égale à 3
	echo $ma_variable.'<br />';
	break;
 
 default:
	// Code dans tous les autres cas (equivaut à else)
	echo $ma_variable.'<br />';
	break;
}
?>

Ici, seuls les instructions situées dans le "case 1" seront prisent en compte (le programme renvoie donc 1 1). À noter cependant que l'instruction switch() est (un peu) plus lente que l’utilisation du if, else et elseif. Cependant, elle s'avère très pratique dans les cas de redondance de conditions.

Opérateur ternaire

Principe

Condition ? ExecuterCode1 : ExecuterCode2;

Remarque

Attention ! Ceci n’est pas a proprement parler une structure de contrôle (puisqu’il s'agit d’un opérateur). Il constitue néanmoins une alternative intéressante aux structures conditionnelles standard.

Exemple

$boolean_IsValid = true;
($boolean_IsValid) ? /* Code qui sera exécuté */ : /* Code qui ne sera pas exécuté */ ;

Enfin, un dernier exemple permettant de faire le rapprochement entre les structures ternaires et les instructions if et else. Les codes ci-dessous renvois le même résultat :

Avec if et else :

Exemple

$boolean_IsValid = true;
if ($boolean_IsValid) echo "La variable est vraie !";
else echo "La variable est fausse !";

Avec les ternaires :

Exemple

$boolean_IsValid = true;
echo ($boolean_IsValid) ? "La variable est vraie !" : "La variable est fausse !";

Les deux codes affichent alors "La variable est vraie !". L'intérêt est donc de gagner du temps de codage et de la place :)

On peut aussi utiliser l'opérateur ternaire dans le but d’une affectation d’une variable :

Exemple

$var = 5;
$foo = 21;
$min = ($var < $foo) ? $var : $foo;
/* $min vaut donc le minimum entre $var et $foo */

Structures de contrôle de boucle

Boucle FOR

Principe

FOR(ExpressionInitale ; ExpressionCondtionnelleDePoursuite ; ExpressionFinale) { ExecuterCodeBoucle }

ExpressionInitale s'exécute une seule fois avant de rentrer dans la boucle (sert généralement à initialiser les variables de la boucle).

ExpressionCondtionnelleDePoursuite sert de test d'exécution du corps de la boucle (de poursuite ou non de l'itération) : l’expression est évaluée avant chaque passage dans la boucle, si l’expression n’est pas vérifiée, le code n’est pas exécuté, et l’on sort de la boucle.

ExpressionFinale s'exécute a chaque fin de boucle. (sert généralement à incrémenter automatiquement les variables de la boucle)

Exemple

for($i = 0 ; $i < 5 ; $i++)
{
 // Code a exécuter a chaque passage de la boucle
}

Ici, le code a l'intérieur de la boucle sera exécuté 5 fois.

Boucle FOREACH

Principe

FOREACH ( TableauElements AS ElementCourant ) { ExecuterCodeBoucle }

ou bien : FOREACH ( TableauElements AS CleElement => ElementCourant ) { ExecuterCodeBoucle }

TableauElements constitue un tableau d'éléments à parcourir.

ElementCourant représente l'élément courant du tableau dans la boucle. Au début de chaque passage dans la boucle, un nouvel élément du tableau est automatiquement affecté a ElementCourant. La boucle s'arrêtera d'elle-même lorsque tous les éléments du tableau auront été parcourus.

CleElement représente la clé de l'élément courant dans un tableau associatif.

Exemple

$Tableau_Couleur = array( 'Rouge', 'Vert', 'Jaune' );

foreach($Tableau_Couleur as $Nom_Couleur)
{// $Nom_Couleur sera égale à "Rouge" puis "Vert" puis "Jaune" 
 // Code à exécuter à chaque passage de la boucle
}

foreach($Tableau_Couleur as $Cle_Couleur => $Nom_Couleur)
{// Note : ici $Cle_Couleur sera une valeur numérique
 // Code à exécuter à chaque passage de la boucle
}


$Tableau_Couleur = array( 'Couleur1' => 'Rouge', 'Couleur2' => 'Vert', 'Couleur3' => 'Jaune' );

foreach($Tableau_Couleur as $Cle_Couleur => $Nom_Couleur)
{// Note : ici $Cle_Couleur sera égale à Couleur1 puis Couleur2 puis Couleur3
 // Code à exécuter à chaque passage de la boucle
}

Boucle WHILE

Principe

WHILE ( ExpressionConditionnelle ) { ExecuterCode }

Exemple

$i = 1;
while($i <= 5)
{
 $i++;
}

Ici, le compteur $i s'incrémentera jusqu'à avoir la valeur 5.

Boucle DO … WHILE

Principe

DO { ExecuterCode } WHILE ( ExpressionConditionnelle )

Exemple

$i = 1;
do
{
 $i++;
} while($i <= 5);

Remarque

L'instruction do{ }while ressemble aux précédentes sauf que le code se trouvant à l'intérieur de la boucle sera exécuté au minimum une fois et ce, même si la condition de la boucle est déjà fausse (car la condition est placée après le bloc d'instructions). Cela peut être pratique dans certains cas.

Break et continue

Break

Il arrive souvent qu'on veuille sortir d’une boucle alors même que la condition de la boucle est encore vraie. Pour cela, on va faire appel à l'instruction break. Lorsque cette instruction sera exécutée, la boucle se terminera.

Exemple

$i = 2;
while ($i <= 10)
{
 if ($i == 5) break;
 else $i++;
}
echo $i;

Ici, la boucle démarre avec $i = 2. La boucle du while va recommencer jusqu'à ce que la condition du if soit vérifiée. Celle-ci dit que lorsque $i est égal à 5, il faut sortir de la boucle. Par conséquent, le echo affichera bien 5 !

Continue

L'instruction continue ne permet pas de sortir d’une boucle mais simplement de finir un tour de boucle prématurément (avant la fin du bloc d'instruction). Cela sert moins souvent que break, mais cela peut servir à gérer des exceptions.

Exemple

$mon_panier = array ('fruits' => 'orange', 'legume' => 'epinards', 'plat' => 'roti de veau');
$j_aime = 'epinards';

foreach ($mon_panier as $key => $value)
{
 if ($value == $j_aime) continue;
 echo $value.", ";
}

Ici, on parcourt les valeurs du tableau $mon_panier". Le if du bloc d'instruction est vérifié si la valeur ($value) est égale au contenu de la variable $j_aime (epinards). Lorsque la condition est vérifiée, le continue permet d'ignorer le reste de la boucle et de commencer un nouveau tour. Donc, le echo est ignoré et l’affichage d'"epinards" n’est pas pris en compte.

Le tout affichera "orange, roti de veau, ".

Tableaux

**Version imprimable**
Leçon : PHP

Chapitre n^o 4
Chap. préc. :	Structures de contrôle
Chap. suiv. :	Variables superglobales

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Les tableaux

Un tableau est une collection d'objet. En PHP, ces objets n'ont pas forcément le même type (cohabitation entre des entiers, des chaines…). Chaque objet est identifié par une clé (indice).

Tableau itératifs

Les clés du tableaux sont des nombres. Par défaut, le premier indice est 0.

Exemple

$tab = array('val1', 'val2', 'val3');    // $tab[0] vaut val1 /-/ $tab[1] vaut val2 /-/ etc.

for($i = 0; $i<2; $i++)
  echo $tab[$i];

Ce code affichera : val1val2.

En PHP, on peut aussi directement affecter des indices du tableau, comme suit :

Principe

$tab[0] = 1;
$tab[99] = 3;

Notez que les indices ne sont pas typés (on pourra indifféremment utiliser $tab[1] et $tab['1']).

Tableaux associatifs

Ils fonctionnent de la même manière que les tableaux itératifs, sauf que l'utilisateur en choisit la clé. À chaque clé correspond une valeur (injection).

Voici un exemple de déclaration :

Exemple

$tab = array('cle1' => 'val1', 'cle2' => 'val2', 'cle3' => 'val3');
 
print $tab['cle2'];   //affichera: val2

//parcours du tableau en boucle
foreach($tab as $key=>$value)
 print $key." : ".$value.". ";

Résultat : cle1 : val1. cle2 : val2. cle3 : val3. .

Pour ne garder que les valeurs on peut utiliser impode(), qui convertit un tableau en chaine avec séparateur :

 print implode(". ", $tab).". ";

Résultat : val1. val2. val3. .

Fonctions usuelles sur les tableaux

count : cette fonction renvoie le nombre d'éléments présent dans le tableau.

Principe

$tab = array(1,2,3,4);
print count($tab); //affiche 4

current : affiche la valeur d’un élément de tableau.
key : affiche la clé d’un élément de tableau.

Tableaux multi-dimensionnels

La clé d’un tableau peut pointer sur un second tableau créant ainsi un tableau multi-dimensionnel.

Principe

$indiv[] = array(
    'nom' => 'Hubert', 
    'poste' => 'Gérant', 
    'Email' => 'hubert@test.com', 
    'idBureau' => 1
);

$indiv[] = array(
    'nom' => 'Jean', 
    'poste' => 'Réceptionniste', 
    'Email' => 'reception@test.com', 
    'idBureau' => 1
);

$indiv[] = array(
    'nom' => 'Amélie', 
    'poste' => 'Président', 
    'Email' => 'contact@test2.com', 
    'idBureau' => 2
);

$affBureau=1;

foreach($indiv as $no => $data)
{
    if($data['idBureau']==$affBureau)
    {
	echo $no .'-'. $data['nom'] .' <i>'. $data['poste'] .'</i>: '. $data['Email'] .'<br />';
    }
}

Résultat :

0-Hubert Gérant: hubert@test.com

1-Jean Réceptionniste: reception@test.com

NB : Dans cet exemple, une base de données serait sûrement plus adéquate.

PHP

Structures de contrôle

Variables superglobales

Variables superglobales

**Version imprimable**
Leçon : PHP

Chapitre n^o 5
Chap. préc. :	Tableaux
Chap. suiv. :	Fonctions

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Les variables superglobales

Ces variables sont prédéfinies à PHP et sont destinées à stocker des informations bien spécifiques. Elles se présentent généralement sous la forme d'un tableau associatif à une ou deux dimensions.

Voici une liste non-exhaustive (comprenant les cas d'utilisation les plus courants):

Variables de serveur : $_SERVER

Elle contient des informations sur le serveur (nom, IP, logiciels installés…)

Par exemple pour extraire l'URL de la page courante :

echo 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];

Références

[html] • [licence Copyright] • (fr) • lien vers le document • Source
[html] • [licence Copyright] • (en) • lien vers le document • Documentation PHP

Variables d'environnement : $_ENV

Elle contient des informations sur l'environnement d'exécution du script PHP (c'est-à-dire sur le serveur). Elle est donc directement liée au serveur et à son système.
Prenons comme exemple, le prénom 'Paul':

<?php
echo 'Mon nom d\'utilisateur est ' .$_ENV["USER"] . '!';
?>

En imaginant que l'utilisateur 'Paul' exécute ce script, on aura alors:

Exemple

Mon nom d'utilisateur est Paul !

Cookies : $_COOKIE

Elle stocke les informations sur les cookies envoyés aux clients.
Un petit exemple pour illustrer cela:

<?php
echo 'Bonjour ' . htmlspecialchars($_COOKIE["name"]) . '!';
?>

On suppose que le cookie "name" a été défini précédemment, (on prendra Paul encore une fois)
L'exemple ci-dessus va afficher alors:

Exemple

Bonjour Paul !

GET variables : $_GET

Elle stocke les valeurs des arguments passés par URL. Ses clés sont donc par conséquent variables. Pour illustrer ces propos, imaginons que l'utilisateur ai entrée l'URL suivant: http://example.com/?name=Paul

<?php
echo 'Bonjour ' . htmlspecialchars($_GET["name"]) . '!';
?>

L'exemple ci-dessus va afficher alors:

Exemple

Bonjour Paul !

POST variables : $_POST

Elle stocke les valeurs des informations passées par formulaire avec la méthode="post". Ses clés sont donc par conséquent variables. Voir le cours sur les formulaires.
L'exemple ci-dessous est un formulaire comportant un champ de saisie et un bouton de soumission.
Quand un utilisateur soumet des données en cliquant sur "Soumettre", les données du formulaire sont envoyées dans un fichier spécial dans l'attribut d'action de la balise <form>.
Puis, on peut utiliser $ _POST pour recueillir la valeur du champ de saisie.

Exemple

<html>
<body>

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
  Nom: <input type="text" nom="fnom">
  <input type="soumettre">
</form>

<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
    // collecte la valeur du champ de saisie
    $nom = $_REQUEST['fnom'];
    if (empty($nom)) {
        echo "Le nom est vide";
    } else {
        echo $nom;
    }
}
?>

</body>
</html>

Variables de requête : $_REQUEST

Un tableau associatif constitué du contenu des variables $_GET, $_POST, $_COOKIE.
L'exemple ci-dessous est un formulaire comportant un champ de saisie et un bouton de soumission.
Quand un utilisateur soumet des données en cliquant sur "Soumettre", les données du formulaire sont envoyées dans un fichier spécial dans l'attribut d'action de la balise <form>.
Puis, on peut utiliser $ _REQUEST pour recueillir la valeur du champ de saisie.

Exemple

<html>
<body>

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
  Nom: <input type="text" nom="fnom">
  <input type="soumettre">
</form>

<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
    // collecte la valeur du champ de saisie
    $nom = $_REQUEST['fnom'];
    if (empty($nom)) {
        echo "Le nom est vide";
    } else {
        echo $nom;
    }
}
?>

</body>
</html>

Variable de téléchargement : $_FILES

Elle stocke les informations sur un fichier envoyé via HTTP par le client. Voir le cours sur les formulaires.

Variables de session : $_SESSION

Elle contient les valeurs de la session en cours pour le client.

Variables globales : $GLOBALS

Elle stocke les variables globales de la page. Ses clés sont donc des variables.
Ci-dessous, un exemple d'utilisation de la variable $GLOBALS.

Exemple

<?php 
$x = 75; 
$y = 25;
 
function addition() { 
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; 
}
 
addition(); 
echo $z; 
?>

Lorsqu'on exécute ce code, on obtient "100" (=> résultat de la variable 'x' + 'y')

PHP

Tableaux

Fonctions

Fonctions

**Version imprimable**
Leçon : PHP

Chapitre n^o 6
Chap. préc. :	Variables superglobales
Chap. suiv. :	Classes

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Déclaration de fonction

PHP permet bien entendu d'écrire ses propres fonctions. Notez bien que ce cours n'étant pas un cours d'algorithmique, il y sera simplement expliqué comment utiliser les fonctions en PHP.

Utilisation

Pour déclarer une fonction en PHP, il suffit d’utiliser le mot-clef function. Comme le langage n’est pas typé, une fonction peut retourner n’importe quel type de valeur (chaîne, entier…) ou ne rien retourner du tout. Enfin, ses arguments peuvent avoir des valeurs par défaut.

Principe

// foo retourne le résultat de la somme du deuxième paramètre et de 4.
// Si aucun second paramètre n'est donné, la fonction utilisera la valeur 0 par défaut.
function foo($arg1, $arg2 = 0)
{
 print 'Fonction foo(' . $arg1 . ',' . $arg2 . ') donne : ';
 return $arg2+4;
 // tout ce qui suit ne sera jamais exécuté 
}

//appel à la fonction
print foo(1,3);  //affichera: Fonction foo(1,3) donne 7
print foo(5);    //affichera: Fonction foo(5,0) donne 4

Le principe de base est très simple à saisir.

Notez que lorsqu'une fonction arrive à un return, elle l'effectue puis se termine, même s'il y a d'autres instructions après.

Portée des variables

Le problème de portée des variables est assez réduit en PHP. Une fonction n'a accès qu’à ses arguments, ses propres variables et aux variables globales importées statiquement (mot clé global). De ce fait, il y a peu de confusion.

Toujours suivant le même principe, les variables utilisées dans une fonction sont toutes détruites à sa sortie (les variables globales non, bien entendu).

Exemple

$valeur1=10;
$valeur2=20;

function exemple($valeur) {
global $valeur1; // récupération de la valeur globale de $valeur1
$valeur3=5;
$calcul=$valeur1+$valeur2+$valeur3+$valeur; // 10 + 0 + 5 + le paramètre qui sera entre parenthèses. 
//$valeur2 n'ayant pas été définie comme valeur globale, la variable $valeur2 est donc vide.
return $calcul;
}

echo exemple(2); // affiche 17

On peut aussi trouver un peu plus compliqué si vous utilisez deux fichiers. L'un pour les variables, l'autre pour les traitements.

Principe

<?php
//-- fichier 1 : les variables globales (mot clef '''global''')
global $var1 = "Salut";
?>

Principe

<?php
//-- fichier 2 : les traitements
echo "J'utilise ma variable globale : ".$GLOBALS['var1']; //-- Récupération via $GLOBALS
?>

Espaces de noms

Depuis PHP 5.3.0, des espaces de noms peuvent être définis pour cloisonner certains objets, à l'aide du mot clé namespace utilisé en début de fichier^[1]. Exemple de définition :

<?php
 namespace Projet1;
...

Soit un fichier TestNS.php suivant :

<?php
 namespace Projet1\SousProjet2;

 function Fonction1() {
  echo "Fonction exécutée.\n";
  echo __NAMESPACE__;
 }
?>

Le fichier doit être encodé en ANSI (pas en Unicode sous peine d’être obligé de coller le mot "namespace" à "?php").

Exemple d’utilisation :

<?php
 require 'TestNS.php';
 Projet1\SousProjet2\Fonction1();
?>

Remarque

Par convention, l'arborescence du système de fichiers correspond à celle des espaces de noms. Dans l'exemple ci-dessus, il faudrait donc placer le fichier dans Projet1\SousProjet2\TestNS.php et faire plutôt require 'Projet1\SousProjet2\TestNS.php';

Références de variables

Les références sont utiles lorsque l’on souhaite retourner plusieurs valeurs dans une fonction. On utilise alors le passage d'argument par référence, qui fait que quand une fonction modifie un argument, la valeur de la variable du programme principale change aussi.

Pour utiliser un argument en tant que référence, il suffit d'y mettre le symbole & devant, dans la déclaration de la fonction.

Un exemple concret devrait vous faire comprendre :

Exemple

function foo(&$arg1, &$arg2, $arg3)
{
 $arg1 = 4;
 $arg2 = 6;
 $arg3 = 8;
}

foo($var1, $var2, $var3);
print $var1;  //affichera 4
print $var2;  //affichera 6
print $var3;  //affichera NULL car $arg3 n’est pas une référence (pas de &)

Les fonctions variables

On appelle "fonction variable" une fonction dont on ne peut prédire le nombre d'arguments. Ce genre de fonction pourra se révéler pratique pour exécuter certains codes répétitifs ou le programmeur n'a pas envie de recopier le nom de la fonction pour n valeurs.

Pour cela, il faut retenir deux fonctions importantes :

func_num_args : permet de compter le nombre d'arguments.
func_get_args : permet de récupérer la valeur d’un argument (retourne un tableau de valeur).

Ces deux fonctions ne peuvent s'utiliser qu’à l'intérieur d’une fonction; dans le cas contraire un message d'erreur s'affichera.

Exemple

function afficher_variables ()
{
 $nb_args = func_num_args();
 $list_args = func_get_args();
 
 for ($i = 0; $i < $nb_args; $i++)
 {
  echo $list_args[$i].' ';
 }
}
$var1 = 'programmeur';
afficher_variables('Je suis', $var1, ', c\'est utile', ', c\'est intéressant.'); // Et on peut en rajouter autant que nécessaire.

Le code se comprend de lui-même. Il affichera : Je suis programmeur, c’est utile, c’est intéressant.

Références

↑ http://php.net/manual/fr/language.namespaces.rationale.php

PHP

Variables superglobales

Classes

Classes

**Version imprimable**
Leçon : PHP

Chapitre n^o 7
Chap. préc. :	Fonctions
Chap. suiv. :	Base de données

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Théorie générale sur la POO

La programmation orientée objet est un style de programmation qui associe à des éléments réels (un panier d'achat, par exemple), une série de variables et de fonctions.

Dans le domaine de la POO, la fonction d’un objet est appelée méthode et une variable attribut.

Pour que PHP puisse comprendre de quoi nous parlons, il est nécessaire de lui expliquer ce que représente l'objet, nous créons donc une classe d'objet.

Utilisation des classes

En PHP, la création d’une classe se fait en utilisant le mot-clé class suivit du nom de la classe puis d’un bloc d'instruction présentant les attributs et les méthodes de l'objet.

La déclaration d’une classe en PHP ressemble à ça :

Principe

class MaClasse {
    var $un_attribut;

    function une_methode() {
        return true;
    }
}

Les attributs sont assimilables à des variables local (un peu comme celles créées dans les fonctions, mais qui ne sont pas détruite tant que l’objet existe).

Il est possible d'attribuer des valeurs par défaut aux attributs en utilisant la syntaxe suivante :

Principe

class MaClasse {
    var $un_attribut = 'La valeur par default'; 
    /* À chaque création d’un objet de classe MaClasse, il sera automatiquement 
       doté d’un attribut $un_attribut contenant la chaine de caractères 
       'La valeur par default' */

    function une_methode() {
        return true;
    }
}

Une fois la classe définie, on peut l’utiliser. On va pour cela créer un objet de type MaClasse en utilisant le mot réservé new :

Principe

$mon_objet = new MaClasse;

La variable $mon_objet est désormais un objet de classe/type MaClasse (également appelé instance de MaClasse) et possède les attributs et méthodes définis plus haut. L'accès à ces informations s'effectue en utilisant ->.

Utilisation des attributs

Pour accéder à l'attribut $un_attribut, on écrit :

Principe

$mon_objet->un_attribut;

Attention! Pour accéder à un attribut, il ne faut pas utiliser le dollar $! Autrement, vous accédez à l'attribut portant le même nom que le contenu de la variable $un_attribut

Exemple

$mon_objet = new MaClasse;

$mon_objet->un_attribut; // Accède à l'attribut "un_attribut"

$un_attribut = 'attribut2';
$mon_objet->$un_attribut; // Accède à l'attribut "attribut2", puisque la variable $un_attribut vaut attribut2.

L'espace de nom d’un objet est totalement séparé du reste du script. Deux variables, une dans l'espace de nom global (le script normal) peut porter le même nom que l'attribut d’un objet sans pour autant pointé vers le même contenu.

Il n’est pas obligatoire d'écrire les attributs dans la classe. Il est possible d'accéder à tout moment, à n’importe quel attribut de l'objet, pour autant que son nom soit un nom de variable valide.

Chaque objet possède ses propres attributs.

Principe

$objet1 = new MaClasse;
$objet2 = new MaClasse; // Deux objet de type MaClasse

$objet1->nom = 'Dupont'; // L'attribut nom de l’objet 1 vaut Dupont
$objet2->nom = 'Smith'; // L'attribut nom de l’objet 2 vaut Smith

echo $objet1->nom; // Affichera bien 'Dupont' et pas 'Smith'

Utilisation des méthodes

L'utilisation des méthodes est plus ou moins similaire à l’utilisation des attributs.

Par exemple, pour accéder à la méthode une_methode() définie plus haut, on va utiliser :

Principe

$mon_objet = new MaClasse;

$mon_objet->une_methode();

Les méthodes fonctionnent exactement comme les fonctions classiques de PHP.

De la même façon que les attributs, les méthodes possèdent un espace de nom séparé ; il est donc possible d'appeler une méthode str_replace(), même si cette fonction est définie par PHP.

Auto-Référence

Lors de la création de méthode d'objet, il peut être nécessaire d'accéder aux attributs de ce même objet, pour les modifier par exemple.

Vous pouvez alors utiliser l’objet magique $this représentant l’objet lui-même.

Principe

class MonClient {
    var $nom = 'Dupont'; 

    function smithize() {
        $this->nom = 'Smith'; // Change l'attribut $nom de l'objet
    }
}

$client = new MonClient;
echo $client->nom; // Affiche 'Dupont'

$client->smithize();
echo $client->nom; // Affiche 'Smith'

Constructeur

La programmation orientée objets basique en PHP permet l’utilisation des constructeurs. Il s'agit d’une méthode particulière destinée à initialiser l'objet.

Dans une classe, il ne peut y avoir qu'un seul constructeur.

En PHP4, afin qu'elle soit reconnue comme telle, elle doit porter le même nom que la classe (attention aux majuscules). En PHP5, le constructeur fait appel à une méthode au nom prédéfini, "__construct".

Syntaxe PHP 4

Principe

class MonClient {
    var $nom; 

    function MonClient($nom) {
        $this->nom = $nom;
    }
}

Syntaxe PHP5

Principe

class MonClient {
    public $nom; 

    function __construct($nom) {
        $this->nom = $nom;
    }
}

Dans ce cas, lors de la création de l’objet (l'instanciation), on précise le nom du client comme si l’on appelait la fonction.

Principe

$client = new MonClient('Dupont');
echo $client->nom; // Affiche Dupont

Pour rendre optionnelles les parenthèses, tous les paramètres de la méthode doivent être optionnels :

Syntaxe PHP4

Principe

class MonClient {
    var $nom; 

    function MonClient($nom = '') {
        $this->nom = $nom;
    }
}

Syntaxe PHP5

Principe

class MonClient {
    public $nom; 

    function __construct($nom = '') {
        $this->nom = $nom;
    }
}

Principe

$client = new MonClient('Dupont');
echo $client->nom; // Affiche Dupont

$client = new MonClient; // Ne produit pas d'erreur
echo $client->nom; // N'affiche rien, l'attribut $nom vaut une chaine de caractères vide

Destructeur

La destruction d’une instance se fait automatiquement à la fin d'exécution d’un script mais peut être décorée :)

Syntaxe PHP5

Principe

class MonClient {
    public $nom; 

    function __destruct() {
        $this->save();
        echo 'Mon client est mort mais sauvegardé';
    }
}

AutoLoad

Pour utiliser une classe il faut l'avoir

Syntaxe PHP5

Fichier autoload.php

Principe

function __autoload($class_name) {
    require_once('./lib/'.$class_name.'.php');
}

Fichier index.php

Principe

require_once('./autoload.php');
new Client();//Lors de cette instanciation, autoload fera un require_once automatique :)

Surcharge

On appelle surcharge l'écrasement d’une méthode de la classe par une autre.

Ainsi dans l'exemple ci-dessus, la fonction "nom" est modifiée dans une deuxième classe :

class MonClient {
    public $nom; 
 
    function __construct($nom) {
        $this->nom = $nom;
    }
} 

$client = new MonClient('Dupont');
echo $client->nom."\n"; // Affiche Dupont

class LeClient {
    public $nom;

    function __construct($nom) {
        $this->nom = strtoupper($nom);
    }
}

$client = new LeClient('Dupont');
echo $client->nom; // Affiche DUPONT

Classes abstraites

Une classe abstraite est destinée à regrouper des éléments communs à ses classes filles. Elle ne doit donc jamais être déclarée comme "private" pour l'héritage (elle est "public" ou "protected"). Certaines de ses méthodes peuvent être abstraites aussi^[1].

abstract class personne
{
    public function nom($nom = "Dupont", $prenom = "Jean") {
        $this->nom() = $nom;
        $this->prénom() = $prenom;
   }
}

class MonClient extends personne 
{
    $Client = new personne;
... // Ce qui distingue un client d’une autre personne
}

class Salarier extends personne
{
    $Salarier = new personne;
... // Ce qui distingue un salarié d’une autre personne
}

Interface

Les interfaces rassemblent les méthodes publiques qui doivent être utilisées dans des classes. Donc s'il en manque une dans ces dernières, un message d'erreur apparait donc.

interface achat
{
    public function afficher($article);
    public function payer($article);
}

class ecommerce implements achat
{
    public function afficher ($article) // Obligatoire
    {
    ...
    }
    public function payer ($article) // Obligatoire
    {
    ...
    }
}

PHP

Fonctions

Base de données

Références

↑ php.net

Base de données

**Version imprimable**
Leçon : PHP

Chapitre n^o 8
Chap. préc. :	Classes
Chap. suiv. :	Formulaire

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

PHP et les bases de données

Un des grands points forts de PHP est la simplicité avec laquelle il permet d'accéder à de multiples sortes de bases de données. Le couple le plus connu est certainement PHP/MySQL, cependant il existe des extensions pour plus d'une cinquantaine d’autre base de données tel que : Oracle, Microsoft SQL Server, FrontBase, Sybase, Informix, PostgreSQL, Berkeley, en ODBC ou autre.

Nous allons ici traiter plus particulièrement de MySQL. Dans toute la suite, nous utiliserons l'abréviation BDD pour « base de données ». MySQL (My Structured Query Language) est un type de BDD très répandu sur Internet car très simple d’utilisation et compatible avec la grande majorité des scripts PHP disponibles en téléchargement libre sur le Net (OsCommerce, phpBB, Joomla...). Elle répond au langage SQL (Structured Query Language).

Il existe des interfaces graphiques permettant la gestion en ligne d'une BDD MySQL comme le plus connu phpMyAdmin ou encore Eskuel. Ces interfaces permettent à l'utilisateur de la BDD de voir et de modifier celle-ci comme il le souhaite (création de tables, modification et suppression des données...) sans avoir à connaitre le langage SQL permettant de manipuler la base.

Connexion à MySQL

Pour des raisons de sécurité il est fortement conseillé de créer un fichier externe et d'y déposer vos identifiants de connexion à votre BDD (fourni par votre hébergeur dans la plupart des cas).

Évitez aussi de nommer ce fichier d'une manière trop attirante (pas de « identifiants_bdd.php »...).

Il est aussi conseillé de donner une extension « .php » à ces fichiers afin que leur contenu ne soit pas affiché en cas de mauvaise manipulation (par exemple un fichier « bdd.ini » serait lu et affiché si son adresse est tapée directement dans un navigateur et vos identifiants et mots de passe apparaitraient en clair).

Fichier config.php

$sql_host = 'localhost';
$sql_user = 'login';
$sql_password = 'password';
$sql_database = 'my_db';

Il faut ensuite inclure cette page dans toutes les pages où vous aurez besoin de vous connecter à votre BDD. Pour vous connecter, il vous suffira alors de procéder ainsi :

Script de connexion

include ('./config.php');

$connect = mysql_connect($sql_host, $sql_user, $sql_password) or die ("Impossible de se connecter à MySQL");
mysql_select_db($sql_database, $connect) or die ("Impossible de sélectionner la base ".$sql_database);

// ... votre script

mysql_close($connect);

mysqli

Classe alternative développée pour les dernières fonctionnalités de MySQL :

$mysqli = new mysqli('localhost', 'login', 'mpassword', 'my_db');

Connexion à MS-SQL

Pilote 1.1 SQL Server pour PHP

Ce pilote peut s'utiliser avec les version de SQL server > 2005.

Principe

^[1]

$serverName = "(local)";
$connectionInfo = array("login" => $uid, "password" => $pwd, "Database"=>"my_db");
$connect = sqlsrv_connect($serverName, $connectionInfo);

// ... votre script

sqlsrv_close($connect);

Alternative

Principe

^[2]

$serverName = "(local)";
$connect = mssql_connect($serverName, "login", "password");
mssql_select_db("my_db", $connect)

// ... votre script

sqlsrv_close($connect);
?>

Requête SQL avec MySQL

Une fois la connexion à votre BDD ouverte, vous pouvez travailler dessus et lancer les requêtes que vous souhaitez. En anglais, requête se dit query, nous allons utiliser la fonction mysql_query de php.

Principe

// ... connexion

$sql = "DELETE FROM ma_table WHERE colonne = '1' LIMIT 0,30";
if (!mysql_query($sql, $connect))
{
  die (mysql_error());
}

// ... déconnexion

Requête SQL avec MS-SQL

Principe

// ... connexion

$sql = "DELETE FROM ma_table WHERE colonne = '1' LIMIT 0,30";
if (!sqlsrv_query($connect, $sql))
{
  die (sqlsrv_errors());
}

// ... déconnexion

Récupération des données d'une BDD MySQL

Principe

// ... connexion

$sql = "SELECT ville, pays, code_postal FROM table_clients WHERE code_postal = '78000' AND client_id = '44' LIMIT 1";
if (!$result = mysql_query($sql, $connect))
{
  die (mysql_error());
}
$client_data = mysql_fetch_array($result);
extract($client_data);

echo $ville;
echo $pays;
echo $code_postal;

// ... déconnexion

mysql_fetch_array() renvoie généralement un tableau associatif mélangé à une liste numérotée, ses valeurs sont donc en double. Pour n'avoir que la liste, utiliser mysql_fetch_row().

Récupération des données d'une BDD MS-SQL

Principe

// ... connexion

$sql = "SELECT ville, pays, code_postal FROM table_clients WHERE code_postal = '78000' AND client_id = '44' LIMIT 1";
if (!$result = sqlsrv_query($connect, $sql))
{
  die (sqlsrv_errors());
}
$client_data = sqlsrv_fetch_array($result);
extract($client_data);

echo $ville;
echo $pays;
echo $code_postal;

// ... déconnexion

Autres opérations MySQL

De l'utilité des tableaux associatifs

La ressource pointant sur les résultats d'une requête nous permet d'accéder de manière très simple à ces données en utilisant la syntaxe des tableaux indexés.

Principe

// ... connexion

//-- récupération de 2 champs : 'maladie' et 'ville'
$sql = "SELECT SUM(cas_Paludisme) as 'maladie', ville 
        FROM tbl_enquete, tbl_ville 
        WHERE tbl_enquete.ID_ville = tbl_ville.ID_ville 
        GROUP BY ville";

if (!$resultat = mysql_query($sql, $connect))
{
  die (mysql_error());
}

//--- lecture des données pointées (version 1)
//--- L'option MYSQL_FETCH_ASSOC permet la récupération d'un tableau associatif, sans ses clés numériques (en doublon). C’est équivalent à mysqli_fetch_assoc()
while($ligne_table = mysql_fetch_array($resultat, MYSQL_FETCH_ASSOC))
{
   //-- syntaxe du tableau associatif
   echo $ligne_table['ville']." a ".$ligne_table['maladie']." cas <br />\n";
}

//--- lecture des données pointées (version 2)
while($ligne_table = mysql_fetch_array($resultat, MYSQL_FETCH_ASSOC))
{
   echo "Nombre de cas et localisation : ";
   //-- lecture d'un tableau associatif
   foreach ($ligne_table as $clef=>$valeur)
   {
      echo $valeur." ";
   }
   echo "<br />\n";
}

Compter le nombre de lignes d'un résultat

Principe

$resultat = mysql_num_rows("Requête SQL")

Compter le nombre de champs d'un résultat

Principe

$resultat = mysql_num_fields("Requête SQL")

Lister les bases de données d'un serveur

Principe

$resultat = mysql_list_dbs($connect)
while ($ligne = mysql_fetch_array($resultat)) {
printf("%s<br />",$ligne["BDD"]); }

Lister les tables

Principe

$resultat = mysql_list_tables("BDD", $connect)
while ($ligne = mysql_fetch_array($resultat)) {
printf("%s<br />",$ligne["tables"]); }

Lister les champs

Principe

$resultat = mysql_list_fields("BDD", "Table", $connect)
while ($ligne = mysql_fetch_array($resultat)) {
printf("%s<br />",$ligne["champs"]); }

Lister l'ID de la dernière ligne insérée

Principe

$resultat = mysql_query("INSERT INTO table VALUES(...)");
$id = mysql_insert_id();

Avec une variable

$ma_variable = "test";
$requete = "select * from ma_table where and ma_colonne like '%$ma_variable%'";

Pour saisir la variable directement depuis la page web, on fait appel à des formulaires.

Références

Voir aussi

Sur les autres projets Wikimedia :

« Programmation PHP/Bases de données » sur Wikibooks

http://php.net/manual/fr/book.mysqli.php

PHP

Classes

Formulaire

Formulaire

**Version imprimable**
Leçon : PHP

Chapitre n^o 9
Chap. préc. :	Base de données
Chap. suiv. :	Sessions

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Le PHP est un langage de traitement. Une page en php pourra analyser et effectuer des opérations suite à un formulaire. Ce formulaire devra être écrit en HTML, dans une page .html (.htm) ou .php. Pour notre exemple, nous allons créer une page avec laquelle un utilisateur pourra se connecter à une zone administrateur.

Présentation

Notre formulaire (form.html) comprendra 2 éléments :

le champ du mot de passe ("password")
un bouton pour soumettre le formulaire

La page de traitement, en php (traitement.php) :

vérification si le mot de passe est correct
envoi d'un cookie. ceci sera la preuve que l'ordinateur distant est autorisé à accéder aux pages

Une page de la zone administration (admin.php) :

vérification si l'utilisateur est autorisé à consulter les pages

Le formulaire

Le code source présenté ici est uniquement le formulaire. Pour un affichage agréable de la page il est nécessaire de l'"habiller". Voir comment créer une page en HTML. Ce script ne sera pas expliqué. Pour le comprendre vous devez avoir les bases du formulaire en HTML.

Principe

<form action="traitement.php" method="post">
<input type="password" size="20" name="mdp">
<input type="submit" value="OK">
</form>

En gros, ce formulaire enverra sur la page traitement.php la valeur de l'entrée mdp

Le traitement

Pour comprendre la suite, vous devez avoir en tête la chose suivante sur les variables. Le champ dont le nom est mdp (name=mdp) envoie sur la page de traitement la variable $mdp avec pour valeur l'entrée renseignée.

Pour récupérer les valeurs d'un formulaire on utilise $valeur=$_POST["nomvariable"];

Si vous désirez récupérer les valeurs passée via une URL, par exemple http://www.domaine.com/index.php?mdp=valeur, on utilise $valeur=$_GET["mdp"];

Il est possible de récupérer directement la valeur d'un formulaire via le nom du champ (dans notre exemple $mdp contiendrait la valeur saisie du formulaire) mais il est fortement conseillé d’utiliser $_POST pour des raisons de sécurité et de compatibilité.

Principe

<?php //traitement.php

$motdepasse = 'qwerty'; 
/* voici le mot de passe à envoyer si l’on veut être 
  connecté */

if (empty($_POST["mdp"]) OR $_POST["mdp"] != $motdepasse) { 
  /* si la valeur envoyée est vide ou différente de la valeur 
     demandée */
  exit; 
  /* interruption du script (voir php/interrompre_un_script) */
}

setcookie("wiki",$_POST["mdp"],time()+3600);
/* le serveur envoie un cookie à l'utilisateur pour 
   permettre l'accès aux pages administration */

header("Location: admin.php"); 
/* la page redirige l'utilisateur vers la page de la 
   zone d'administration (cette fonction doit être 
   utilisée avant tout code HTML) */

La zone administration

La zone administration va vérifier si l'utilisateur est autorisé à consulter ces pages. Il va comparer le mot de passe entré dans le cookie avec le mot de passe réel.

Principe

<?php // admin.php

$motdepasse = 'qwerty'; 
/* le (vrai) mot de passe */

$mdp = $_COOKIE["wiki"];
/* le mot de passe enregistré sur le cookie.
   L'accès aux cookies se fait au travers du
   tableau super-global $_COOKIE. Il fonctionne
   comme $_POST ou $_GET. */

if ($mdp != $motdepasse) { 
  /* si le mot de passe n’est pas correct */

   exit('Haha ! Tu voulais voir l\'admin sans mot de passe ?!');
   /* interruption du script avec un joli message ^^ 
      notez le backslash devant l'apostrophe qui permet 
      de ne pas interrompre la chaine de caractères */
}

echo "affichage de admin.php"; 
/* la page peut s'afficher correctement. Si le script
   arrive ici, c’est que le mot de passe est correct,
   autrement le script aurait été arrêté (appel à exit
   plus haut. */

PHP

Base de données

Sessions

Sessions

**Version imprimable**
Leçon : PHP

Chapitre n^o 10
Chap. préc. :	Formulaire
Chap. suiv. :	Cookies

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Sur les autres projets Wikimedia :

Comme vous le savez, à la fin d'un script PHP, toutes les variables créées sont détruites et il est impossible d'y accéder depuis un autre script. Alors comment faire pour passer des données entre les pages ?

La réponse : les sessions.

C'est en effet la solution la plus simple pour un webmaster afin de garder des informations sur son visiteur.

Un cookie et une session, quelles différences

Une session est plus ou moins similaire aux cookies HTTP. Les données d'une session sont cependant stockées sur le serveur et non chez le client, ce qui l'empêche de pouvoir les modifier manuellement, comme il peut le faire pour un cookie.

La durée de vie d'une session

Une session est, comme son nom l'indique, une session de navigation. Elle commence donc lors de l'accès à une page les utilisant et se termine à la fermeture du navigateur du client.

Une fois la session terminée, elle est détruite ainsi que toutes les données qu'elle contient. Elle doit donc ne contenir que des données temporaires.

Cependant, la session possède aussi un délai d'expiration. Celui-ci peut être modifié dans la configuration du serveur (directive session.gc_maxlifetime de php.ini), mais vaut généralement une trentaine de minutes. Une fois ce délai dépassé, la session est supprimée.

Comment ça marche ?

Lors de l'accès à une page nécessitant une session, PHP va vérifier si une a déjà été ouverte et la réutiliser ou en créer une nouvelle. Il va donc lui attribuer un identifiant unique et se débrouiller pour que la prochaine page consultée puisse le connaître.

Pour cela, il exploite deux fonctionnalités. Premièrement, si l’utilisation de cookie est possible (le client ne les a pas désactivés), PHP crée un cookie contenant l'identifiant de session. Deuxièmement, si les cookies ne sont pas disponibles, il va réécrire les URL de la page pour inclure cet identifiant dans le lien.

Dans les deux cas, le script ayant besoin d'accéder aux données de la session recevra l'identifiant et sera capable de charger les données qu'elle contient.

Est-ce que c’est sécurisé

Une session est toujours plus sécurisée qu'un cookie puisque le client ne peut pas la modifier manuellement. Un risque subsiste tout de même si l'identifiant de session peut être découvert.

Par exemple, les cookies transitent sur le réseau en clair. Si quelqu’un est capable d'intercepter les communications entre le client et le serveur, il est capable de voir le cookie et de découvrir l'identifiant de session. Il n'aura alors plus qu’à créer un faux cookie et PHP le prendra pour le pauvre internaute s'étant fait voler son cookie. Pour éviter cela, on peut utiliser une connexion cryptée ou configurer le serveur de façon à ce qu’il rende la lecture de ce cookie impossible par JavaScript (Http Only).

Utiliser les sessions

Initialiser une session

Pour pouvoir utiliser la fonctionnalité de session de PHP, il faut lancer le moteur de session en utilisant la fonction session_start().

Cette fonction doit être en mesure d'envoyer des headers HTTP, aucune donnée ne doit donc avoir été transmise au navigateur. Vous pouvez soit placer ce code au tout début de votre script, soit utiliser les fonctions de bufférisation de sortie.

Une session portant un nom personnalisé

Une session porte par défaut le nom "PHPSESSID", c’est lui qui sera utilisé comme nom de cookie ou comme paramètre GET dans les liens... pas très esthétique. Il peut donc vous venir l'envie de changer ce nom.

Pour cela, la fonction session_name() entre en scène.

Principe

<?php
session_name('nom_de_session');
session_start();

?>

Ce code va donc charger une session avec l'identifiant provenant du cookie ou du paramètre GET portant le nom nom_de_session.

Noter la position de l'instruction 'session_start()'. Elle doit se trouver AVANT n’importe quel traitement de votre page '.php' .

Changer manuellement l'identifiant de la session

PHP détecte automatiquement l'identifiant à utiliser, cependant, vous pourrez avoir besoin de le changer manuellement, si vous voulez développer un système alternatif pour passer l'identifiant de session entre les pages. Vous pouvez par exemple vous baser sur le hachage (md5() ou sha1()) de l'adresse IP du client pour déterminer l'identifiant de la session. Attention aux proxys et aux internautes dont l'IP change à chaque requête.

Pour définir manuellement l'identifiant de session, la fonction session_id(). Elle prend un paramètre optionnel, qui est le nouvel identifiant de session. Dans tous les cas, la fonction retourne l'identifiant courant de la session.

Exemple

<?php

$identifiant = sha1($_SERVER['REMOTE_ADDR']);
/* Premièrement, nous récupérons l'adresse IP du client,
   puis nous utilisons une fonction de hachage pour
   générer un code valide. En effet, l'identifiant d'une
   session ne peut contenir que des lettres (majuscules
   ou minuscules) et des chiffres. */

$ancien_identifiant = session_id($identifiant);
/* Ensuite, nous modifions manuellement l'identifiant de 
   session en utilisant session_id() et en lui donnant 
   l'identifiant généré plus haut. Comme toujours, la
   fonction retourne l'ancien identifiant, on le place
   dans une variable, au cas où on aurait besoin de le
   réutiliser. */

session_start();
/* On démarre la session, PHP va utiliser le nouvel
   identifiant qu'on lui aura fournis. */

?>

Dans l'exemple ci-dessus, deux ordinateurs accédant au site par la même adresse IP publique, auront accès à la dernière session ouverte (donc pas forcément la leur).

Lire et écrire des données dans la session

Les données de la session sont très facilement accessibles au travers d'un simple tableau PHP. Depuis PHP 4.1.0, vous pouvez utiliser le tableau super-global $_SESSION. Dans les versions plus anciennes, il s'appelait $HTTP_SESSION_VARS et nécessitait le mot clé global pour y accéder depuis une fonction.

Ces tableaux n'existent qu'une fois la session chargée. Tout ce qui est stocké à l'intérieur est sauvegardé et accessible depuis toutes les pages PHP utilisant les sessions.

Exercice : Une zone d'administration protégée par mot de passe

Dans cet exercice, nous allons fabriquer pas-à-pas une zone d'administration pour votre site web, protégée par un mot de passe. Nous nous occuperons de la partie identification uniquement.

Dans le chapitre précédent, vous avez également créé le même type de script, mais en utilisant un cookie. Nous allons donc adapter le code en utilisant des sessions à la place.

Le formulaire

Voici le code du formulaire en HTML, il va afficher une boîte de texte et un bouton "Connexion".

Principe

<form action="verification.php" method="post">
<input type="password" name="mdp" />
<input type="submit" value="Connexion" />
</form>

La page de vérification

Le formulaire ci-dessus pointe vers une page nommée verfication.php. Cette page va vérifier que le mot de passe est juste et, si c’est le cas, placer un élément dans le tableau de la session pour que la page suivante puisse vérifier que vous êtes bien autorisé à voir la page.

Premièrement, nous devons initialiser la session. Nous laissons PHP choisir le nom.

Principe

<?php
session_start();

L'appel à la fonction session_start() a fabriqué le tableau $_SESSION. Pour l'instant celui-ci est vide.

Il faut maintenant vérifier que le mot de passe fourni est le bon. Nous créons ensuite une entrée dans le tableau de la session contenant true (vrai) si le code est le bon. Nous pouvons alors rediriger le navigateur de l'internaute ou afficher un message d'erreur.

Principe

$mdp = 'qwertz';

if($mdp == $_POST['mdp']) {
  $_SESSION['admin'] = true;
  require_once('admin.php');
} else {
  echo 'Le mot de passe est erroné';
}

?>

Si vous ne comprenez pas la ligne if($mdp == $_POST['mdp']) {, vous devriez lire (ou relire) le chapitre sur les formulaires.

Pour résumé, le code suivant suffit à l'identification du visiteur :

Principe

<?php
session_start();

$mdp = 'qwertz';

if($mdp == $_POST['mdp']) {
  $_SESSION['admin'] = true;
  require_once('admin.php');
} else {
  echo 'Le mot de passe est erroné';
}

?>

La page d'administration

Cette page doit se nommer admin.php. Si vous décidez d’utiliser un autre nom, il faudra modifier le script d'identification pour qu’il pointe sur la bonne page.

Comme dans l'autre page, nous devons commencer par initier une session.

Principe

<?php
session_start();

Nous avons alors accès au tableau $_SESSION.

Si le visiteur a fourni le bon mot de passe, il existe un élément dans le tableau nommé 'admin' et valant true. Dans le cas contraire, cet élément n'existe pas. Il suffit donc de vérifier sa présence pour savoir si le visiteur est réellement l'administrateur du site. Pour cela, nous utilisons la fonction isset() qui vérifie si la variable (ou l'élément du tableau) existe.

Principe

<?php
session_start();

if(isset($_SESSION['admin']) && $_SESSION['admin']) {
  // Code à exécuter si le visiteur est administrateur.
} else {
  // Code à exécuter si le visiteur n’est pas administrateur.
}

La suite du script n'est plus le sujet de cet exercice, le but est en effet atteint. Vérifier l'identité du visiteur pour lui permettre d'accéder à un espace privé.

Fermer une session

De la même façon que d’autres fonctionnalités de PHP, comme les connexions aux bases de données ou un pointeur de fichier, les sessions n'ont pas besoin d’être fermées.

Une fois le script PHP terminé, les données de la session sont automatiquement sauvegardées pour le prochain script.

Cependant, durant toute l'exécution du script, le fichier de la session est verrouillé et aucun autre script ne peut y toucher. Ils doivent donc attendre que le premier arrive à la fin.

Vous pouvez fermer plus rapidement une session en utilisant la fonction session_write_close().

Si vous voulez également détruire la session, vous pouvez utiliser la fonction session_destroy() couplée à la fonction session_unset().

PHP

Formulaire

Cookies

Cookies

**Version imprimable**
Leçon : PHP

Chapitre n^o 11
Chap. préc. :	Sessions
Chap. suiv. :	Fichiers

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Introduction

Base de données des cookies Firefox, lue avec SQLite.

Cookie ajouté à Firefox après commande PHP setcookie('wiki', 'user');.

Les cookies sont téléchargés du serveur HTTP sur le PC client, stockés dans le répertoire du navigateur de l’utilisateur courant. Par exemple dans Windows 7^[1] :

Firefox : C:\Users\%USERNAME%\AppData\Roaming\Mozilla\Firefox\Profiles\xxxxxxxx.default\cookies.sqlite (lisible par exemple avec https://addons.mozilla.org/en-US/firefox/addon/sqlite-manager/).
Chrome C:\Users\%USERNAME%\AppData\Local\Google\Chrome\User Data\Safe Browsing Cookies.
Internet Explorer : C:\Users\%USERNAME%\AppData\Roaming\Microsoft\Windows\Cookies.

Ces cookies sont limités à 20 par domaine dans la configuration par défaut de PHP.

Ne pas mettre d'informations privées (mots de passe du serveur...) dans ces variables car elles sont stockées dans un fichier non protégé, sur le disque dur de l'utilisateur.

D'une manière générale, les cookies prennent la forme suivante :

Set-Cookie: nom=nouvelle_valeur; expires=date; path=/; domain=.exemple.org

Le chemin (path) permet de ne les rendre opérants que dans certaines parties d'un site.
Le domaine fonctionne même avec d'autres serveurs (voir pixel espion).

Syntaxe

<?php
  setcookie('cookie1', 'valeur1');
  echo $_COOKIE["cookie1"];
?>

Exemples

<?php
  if (isset($_COOKIE["cookie1"])) {
    echo 'Authentifié';
  } else {
    echo 'Non authentifié';
  }
?>

Références

↑ https://openclassrooms.com/forum/sujet/ou-sont-stockes-les-cookies-87753

PHP

Sessions

Fichiers

Fichiers

**Version imprimable**
Leçon : PHP

Chapitre n^o 12
Chap. préc. :	Cookies
Chap. suiv. :	Mails

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

Parfois l’utilisation de fichier peut être très utile dans certains script, par exemple pour un système de cache ou autre.
Dans ce cours nous allons voir comme interagir avec un fichier.

Droits des fichiers

Windows

Sous Windows il suffit de se rendre dans l'onglet sécurité des propriétés d'un fichier, pour cocher les cases autorisant le programme à le lire et/ou le modifier.

Unix

chmod est le système de droit d'accès a un fichier Unix. Il s'agit d'un nombre à 3 chiffres que l’on attribut à un fichier (ex. : 755). Il détermine le droit d'accès au fichier en question, qui peut le modifier.
Selon sa valeur le système d'exploitation (OS) autorise ou non la modification du fichier. Sous GNU/Linux, l'utilisateur 'root', (superutilisateur), a tous les droits, c'est-à-dire qu’il peut modifier tous les fichiers.

Lorsque qu'un fichier est créé manuellement, le chmod du fichier en question est 755, avec un tel chmod nous ne pouvons pas modifier le fichier avec un script PHP. Pour pouvoir le modifier, il suffit juste de changer le chmod du fichier, en lui donnant la valeur 766. Sous Windows, cette notion est masquée et il suffit d’être administrateur de la machine (utilisateur par défaut) pour pouvoir modifier un fichier.

Ouvrir et fermer un fichier

Créer un fichier avec un attribut chmod de 766. Ensuite il faut ouvrir le fichier en question avant de lire/écrire. Pour cela la fonction fopen est là :

Principe

<?php
$ObjetFichier  =  fopen ($NomFichier, $mode);
?>

Explication : La fonction fopen à besoin de deux paramètres pour pouvoir s'exécuter :

$NomFichier, il s'agit du chemin du fichier
$mode, il s'agit du mode de l'ouverture

La fonction fopen utilise le premier paramètre, pour déterminer le chemin du fichier a ouvrir/créer.

Voici les différents modes d'ouvertures pour la fonction fopen :

Mode	Description
r	Ouvre en lecture seule, et place le pointeur de fichier au début du fichier.
r+	Ouvre en lecture et écriture, et place le pointeur de fichier au début du fichier.
w	Ouvre en écriture seule, et place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n'existe pas, on tente de le créer.
w+	Ouvre en lecture et écriture, et place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n'existe pas, on tente de le créer.
a	Ouvre en écriture seule, et place le pointeur de fichier à la fin du fichier. Si le fichier n'existe pas, on tente de le créer.
a+	Ouvre en lecture et écriture, et place le pointeur de fichier à la fin du fichier. Si le fichier n'existe pas, on tente de le créer.
x	Créé et ouvre le fichier en lecture seule ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en générant une erreur de niveau E_WARNING. Si le fichier n'existe pas, fopen() tente de le créer. Ce mode est l'équivalent des options O_EXCL\|O_CREAT pour l'appel système open(2) sous-jacente. Cette option est supportée à partir de PHP 4.3.2 et fonctionne uniquement avec des fichiers locaux.
x+	Crée et ouvre le fichier en lecture et écriture ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en \|générant une erreur de niveau E_WARNING. Si le fichier n'existe pas, fopen() tente de le créer.

Pour le fermer maintenant, il y a la fonction fclose.

Principe

<?php
$ObjetFichier  =  fopen ($NomFichier, $mode);

fclose ($ObjetFichier);
?>

Copier un fichier

if (!copy($AncienFichier, $NouveauFichier)) {
    echo 'La copie a échoué.';
}

Pour les images il existe aussi imagecopyresampled^[1].

Supprimer un fichier

if (!unlink($Fichier)) {
    echo 'La suppression a échoué.';
}

Interagir avec le fichier

Lecture

Une fois ouvert, il existe plusieurs manière de lire le contenu d'un fichier : caractère par caractère, ligne par ligne, jusqu'à une certaine taille, ou tout entier.

La méthode la plus simple est de lire ligne par ligne avec la fonction fgets, dont la définition est la suivante :

Principe

<?php
$ligne =  fgets ($ObjetFichier);
?>

La variable $ObjetFichier doit être le résultat de l'ouverture d'un fichier avec fopen. Pour lire un fichier en entier, il suffit d’utiliser fgets en boucle ; la condition de sortie de la boucle serait alors l'arrivée à la fin de fichier, évènement notifié par la fonction feof.

Exemple de parcours d'un fichier ligne par ligne

<?php
$NomFichier = "chemin_ou_nom_de_fichier";
$ObjetFichier = fopen($NomFichier, "r"); //ouverture en lecture

if ($ObjetFichier) {
    //on lit le fichier tant que la fin n’est pas atteinte
    while (!feof($ObjetFichier)) {
        $ligne = fgets($ObjetFichier);
        echo $ligne;
    }
    fclose($ObjetFichier);
}
else
    echo "Erreur : impossible d'ouvrir le fichier.";
?>

La fonction équivalente pour lire caractère par caractère se nomme fgetc :

Principe

<?php
$caractere = fgetc ($ObjetFichier);
?>

Notez que cette fonction retourne FALSE arrivée à la fin du fichier. Lors d'un parcours, il faut donc tester impérativement la valeur avant de l’utiliser, avec un test logique de la forme « $caractere !== FALSE ».

Pour lire le fichier en entier, utiliser file() :

Principe

<?php
$fichier = file($ObjetFichier); // ou : file("http://MonSite/" . $ObjetFichier);
?>

Ainsi, $fichier[0] correspond à la première ligne, $fichier[1] à la seconde, etc.

Écriture

Une fois le fichier ouvert, l'écriture se fait via la fonction fwrite.

Principe

<?php
fwrite ($ObjetFichier, $chaine);
?>

Explication :

$ObjetFichier : variable pointant vers un fichier ouvert avec fopen
$chaine : la chaîne à écrire dans le fichier
retour : le nombre de caractère écrits, ou FALSE si erreur

L'utilisation est alors la même que pour la lecture : ouvrir le fichier, écrire et fermer.

Exemple d'écriture

<?php
$NomFichier = "chemin_ou_nom_de_fichier";
$chaine = "Je suis une chaine écrite par PHP !\n"
$ObjetFichier = fopen($NomFichier, "w"); //ouverture en lecture

if ($ObjetFichier) {
    if(fwrite($ObjetFichier, $chaine) === FALSE) {
       echo "Erreur : impossible d'écrire dans le fichier.";
    }
    fclose($ObjetFichier);
}
else {
    echo "Erreur : impossible d'ouvrir le fichier.";
}
?>

Attention : Si vous ouvrez le fichier avec l'option w ou w+, le contenu du fichier sera effacé s'il existait. Pour écrire à la fin, il faut ouvrir avec les options a ou a+ (voir ci-dessus). Enfin, si vous pouvez avec l'option r+, le contenu sera écrasé, puisque le pointeur de fichier sera placé au début.

Se déplacer

Parfois, il peut être nécessaire de se déplacer dans le fichier, par exemple pour revenir au début. Pour cela, il faut utiliser la fonction fseek comme suit :

Principe

<?php
fseek ($ObjetFichier, $position);
?>

Explication :

$ObjetFichier : variable pointant vers un fichier ouvert avec fopen
$position : la position à laquelle on veut se déplacer. Pour revenir au début, $position doit valoir zéro.

Fichiers uploadés

Copier-coller ces lignes dans un fichier vierge upload.php pour qu’il affiche le nom des fichiers qu'on upload avec :

<?php
echo '
<form method="POST" action="upload.php" enctype="multipart/form-data">
     <input type="file" name="fichier">
     <input type="submit" name="envoyer" value="Uploader">
</form>';
if (isset($_FILES['fichier']))
{
  echo $_FILES['fichier']['name'];
}
?>

Fichiers distants

HTTP

Pour lire un fichier en HTTP (par exemple cette page web) :

<?php
$page = file_get_contents("http://fr.wikiversity.org/wiki/PHP/Fichiers/");
echo $page;
?>

ou^[2]

<?php
$url = 'http://fr.wikiversity.org/wiki/PHP/Fichiers/';
echo htmlspecialchars(implode('', file($url)));
?>

FTP

Déposer un fichier (sans vérifier s'il en écrase un)^[3] :

<?php
copy('fichier_local.txt', 'ftp://login:password@server/repertoire/fichier_distant.txt');
?>

Souvent le répertoire porte le nom de l'utilisateur, et on écrase le fichier s'il existe :

<?php
$serveur = 'serveur1';
$login = 'utilisateur1';
$password = 'mdp1';
$fichier = 'fichier1';
copy($fichier, 'ftp://'.$login.':'.$password.'@'.$serveur.'/'.$login.'/'.$fichier, stream_context_create(array('ftp' => array('overwrite'=>True))));
?>

Fonctions propres au FTP, pour lire un serveur distant, y télécharger et déposer des fichiers^[4] :

$cnx = ftp_connect($serveur);
$login_result = ftp_login($cnx, $login, $password);

// Liste des noms des dossiers et fichiers du dossier distant (dans le désordre)
$DossierDistant = ftp_nlist($cnx, ".");
var_dump($DossierDistant);

// Liste des éléments du dossier distant avec leurs inodes
$DossierDistant2 = ftp_rawlist($cnx, ".");
var_dump($DossierDistant2);

// Téléchargement du dernier fichier distant
sort($DossierDistant);
$distant = $DossierDistant[sizeof($DossierDistant)-1];
$local = 'FichierLocal.txt';
if (!ftp_get($cnx, $local, $distant, FTP_BINARY)) {
    echo "Erreur ftp_get\n";
} else {
    ftp_delete($cnx, $distant);
}

// Téléversement d'un fichier local
$local = 'FichierLocal2.txt';
if (!ftp_put($cnx, $distant, $local, FTP_ASCII)) {
    echo "Erreur ftp_put\n";
}

Extraction regex

Pour filtrer le contenu d'un fichier, par exemple récupérer tout ce qui se trouve entre parenthèses dans un tableau, en expressions rationnelles :

$regex = "/\(([^)]*)\)/";
preg_match_all($regex, file_get_contents($NomFichier), $matches);
print_r($matches);

Voir aussi Programmation PHP/Expression Régulière sur Wikilivres .

Références

http://phpcodeur.net/articles/php/upload

PHP

Cookies

Mails

Mails

**Version imprimable**
Leçon : PHP

Chapitre n^o 13
Chap. préc. :	Fichiers
Chap. suiv. :	Exceptions

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

`Mail()`

Le code suivant se connecte à localhost:25 pour envoyer un mail^[1] :

<?php
     $to      = 'Destinataire@gmail.com';
     $subject = 'Sujet du mail';
     $message = 'Contenu du message';
     $headers = 'From: Expediteur@gmail.com' . "\r\n" .
       'Reply-To: Expediteur@gmail.com' . "\r\n" .
       'X-Mailer: PHP/' . phpversion();
     mail($to, $subject, $message, $headers);
?>

Si la machine hébergeant le script n’est pas pourvue d'un serveur SMTP, le freeware portable Simple Mail Server^[2] peut jouer ce rôle rapidement sans installation.

PEAR

Pour paramétrer un SMTP distant éventuellement SSL, télécharger les classes mails du framework PEAR Mail^[3], Net SMTP^[4] et Net Socket^[5] qu’elles utilisent.

Pour ajouter un fichier joint télécharger Mail Mime^[6].

PHPMailer

Télécharger PHPMailer^[7] pour bénéficier des classes de ce framework.

Problèmes connus

La connexion a échoué
- Vérifier le serveur HTTP qui interprète le .php.
SMTP Error: Could not connect to SMTP host
- Changer de SMTP, ex : http://www.commentcamarche.net/faq/893-parametres-de-serveurs-pop-imap-et-smtp-des-principaux-fai
SMTP server error: ERR Email ID not found
- Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?
Si les mails partent sans arriver :
- Vérifier que l'IP de l'expéditeur n’est pas blacklistée : http://whatismyipaddress.com/blacklist-check
- Définir un reverse DNS si absent
- Veiller à ce que le mail ne soit pas présumé spam, en évitant les sujets vides par exemple, ou les pièces jointes exécutables non compressées (.exe, .cmd, .vbs...).

Utilisation de Mail () plus complexe...

Exemple

<?php
$mail = 'test@test.fr'; // Déclaration de l'adresse de destination.
if (!preg_match("#^[a-z0-9._-]+@(hotmail|live|msn).[a-z]{2,4}$#", $mail)) // On filtre les serveurs qui rencontrent des bogues.
{
	$passage_ligne = "\r\n";
}
else
{
	$passage_ligne = "\n";
}
//=====Déclaration des messages au format texte et au format HTML.
$message_txt = "Bonjour, voici un e-mail envoyé par un script PHP.";
$message_html = "<html><head></head><body><b>Bonjour</b>, voici un e-mail envoyé par un <i>script PHP</i>.</body></html>";
//==========
 
//=====Création de la boundary
$boundary = "-----=".md5(rand());
//==========
 
//=====Définition du sujet.
$sujet = "Hey mon ami !";
//=========
 
//=====Création du header de l'e-mail.
$header = "From: \"WeaponsB\"<test@test.fr>".$passage_ligne;
$header.= "Reply-to: \"WeaponsB\" <test@test.fr>".$passage_ligne;
$header.= "MIME-Version: 1.0".$passage_ligne;
$header.= "Content-Type: multipart/alternative;".$passage_ligne." boundary=\"$boundary\"".$passage_ligne;
//==========
 
//=====Création du message.
$message = $passage_ligne."--".$boundary.$passage_ligne;
//=====Ajout du message au format texte.
$message.= "Content-Type: text/plain; charset=\"ISO-8859-1\"".$passage_ligne;
$message.= "Content-Transfer-Encoding: 8bit".$passage_ligne;
$message.= $passage_ligne.$message_txt.$passage_ligne;
//==========
$message.= $passage_ligne."--".$boundary.$passage_ligne;
//=====Ajout du message au format HTML
$message.= "Content-Type: text/html; charset=\"ISO-8859-1\"".$passage_ligne;
$message.= "Content-Transfer-Encoding: 8bit".$passage_ligne;
$message.= $passage_ligne.$message_html.$passage_ligne;
//==========
$message.= $passage_ligne."--".$boundary."--".$passage_ligne;
$message.= $passage_ligne."--".$boundary."--".$passage_ligne;
//==========
 
//=====Envoi de l'e-mail.
mail($mail,$sujet,$message,$header);
//==========
?>

Explication:

Ouverture boundary.(sert à séparer les différentes parties de notre e-mail)
Déclaration de type (exemple texte, par défaut les clients mail tentent de convertir l'HTML en texte).
Texte.
Ouverture boundary.
Déclaration de type (exemple HTML,par défaut les clients mail tentent de convertir l'HTML en texte)).
HTML.
Fermeture boundary.
Fermeture boundary.

Avec la mise en place de pièce jointe

Exemple

<?php
$mail = 'test@test.fr'; // Déclaration de l'adresse de destination.
if (!preg_match("#^[a-z0-9._-]+@(hotmail|live|msn).[a-z]{2,4}$#", $mail)) // On filtre les serveurs qui présentent des bogues.
{
	$passage_ligne = "\r\n";
}
else
{
	$passage_ligne = "\n";
}
//=====Déclaration des messages au format texte et au format HTML.
$message_txt = "Bonjour, voici un e-mail envoyé par un script PHP.";
$message_html = "<html><head></head><body><b>Bonjour</b>, voici un e-mail envoyé par un <i>script PHP</i>.</body></html>";
//==========
 
//=====Lecture et mise en forme de la pièce jointe.
$fichier = fopen("background.jpg", "r");
$attachement = fread($fichier, filesize("background.jpg"));
$attachement = chunk_split(base64_encode($attachement));
fclose($fichier);
//==========
 
//=====Création de la boundary.
$boundary = "-----=".md5(rand());
$boundary_alt = "-----=".md5(rand());
//==========
 
//=====Définition du sujet.
$sujet = "Fichier important";
//=========
 
//=====Création du header de l'e-mail.
$header = "From: \"WeaponsB\"<test@test.fr>".$passage_ligne;
$header.= "Reply-to: \"WeaponsB\" <weaponsb@mail.fr>".$passage_ligne;
$header.= "MIME-Version: 1.0".$passage_ligne;
$header.= "Content-Type: multipart/mixed;".$passage_ligne." boundary=\"$boundary\"".$passage_ligne;
//==========
 
//=====Création du message.
$message = $passage_ligne."--".$boundary.$passage_ligne;
$message.= "Content-Type: multipart/alternative;".$passage_ligne." boundary=\"$boundary_alt\"".$passage_ligne;
$message.= $passage_ligne."--".$boundary_alt.$passage_ligne;
//=====Ajout du message au format texte.
$message.= "Content-Type: text/plain; charset=\"ISO-8859-1\"".$passage_ligne;
$message.= "Content-Transfer-Encoding: 8bit".$passage_ligne;
$message.= $passage_ligne.$message_txt.$passage_ligne;
//==========
 
$message.= $passage_ligne."--".$boundary_alt.$passage_ligne;
 
//=====Ajout du message au format HTML.
$message.= "Content-Type: text/html; charset=\"ISO-8859-1\"".$passage_ligne;
$message.= "Content-Transfer-Encoding: 8bit".$passage_ligne;
$message.= $passage_ligne.$message_html.$passage_ligne;
//==========
 
//=====On ferme la boundary alternative.
$message.= $passage_ligne."--".$boundary_alt."--".$passage_ligne;
//==========
 
 
 
$message.= $passage_ligne."--".$boundary.$passage_ligne;
 
//=====Ajout de la pièce jointe.
$message.= "Content-Type: image/jpeg; name=\"background.jpg\"".$passage_ligne;
$message.= "Content-Transfer-Encoding: base64".$passage_ligne;
$message.= "Content-Disposition: attachment; filename=\"background.jpg\"".$passage_ligne;
$message.= $passage_ligne.$attachement.$passage_ligne.$passage_ligne;
$message.= $passage_ligne."--".$boundary."--".$passage_ligne; 
//========== 
//=====Envoi de l'e-mail.
mail($mail,$sujet,$message,$header);
 
//==========
?>

Explication:

Ouverture boundary.
Déclaration du nouveau content-type et de la seconde boundary.
Ouverture boundary_2.
Déclaration de type (exemple texte).

Texte.

Ouverture boundary_2.
Déclaration de type (exemple HTML).

HTML.

Fermeture boundary_2.
Ouverture boundary.
Déclaration de la pièce jointe 1.
Ouverture boundary.
Déclaration de la pièce jointe 2.
Ouverture boundary.
Déclaration de la pièce jointe [...].
Ouverture boundary.
Déclaration de la pièce jointe n.
Fermeture boundary.

Références

PHP

Fichiers

Exceptions

Exceptions

**Version imprimable**
Leçon : PHP

Chapitre n^o 14
Chap. préc. :	Mails

En raison de limitations techniques, la typographie souhaitable du titre, « PHP : Version imprimable
PHP/Version imprimable », n'a pu être restituée correctement ci-dessus.

try ... catch

Tout comme en Java, la levée d'exception est assurée un bloc try ... catch :

try {
    echo '1 / 2 = ' 1/2;
    echo '3 / 0 = ' 3/0;    // instruction qui déclenchera l'exception
    echo '2 / 1 = ' 2/1;    // cette instruction ne sera pas exécutée à cause de la précédente
} catch (Exception $e) {
    echo $e->getMessage();  // afficher le message lié à l'exception
} finally {
    echo 'Fin du try';      // action facultative à la fin
}

Il n'est donc pas nécessaire de prévoir ce qui peut interrompre le programme pour s'en prémunir et poursuivre l'exécution en fonction.

throw

Pour déclencher une interruption du programme lors d'une exception, on utilise le mot "throw" :

if (!3/0) {
    throw new Exception('Division par zéro.');
}

PHP

Mails

GFDL

Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections inaltérables, sans texte de première page de couverture et sans texte de dernière page de couverture.

[1] ttp://php.net/manual/fr/datetime.add.php

[2] ttp://www.php.net/manual/fr/function.date-add.php

[3] ttp://www.commentcamarche.net/forum/affich-781989-php-comment-mettre-la-date-en-francais

[4] ttp://php.net/manual/fr/function.substr.php

[5] ttp://php.net/manual/fr/language.operators.errorcontrol.php

[6] ttp://php.net/manual/fr/language.namespaces.rationale.php

[7] .net

[8] ttp://msdn.microsoft.com/fr-fr/library/cc296152%28v=sql.90%29.aspx

[9] ttp://www.php.net/manual/fr/function.mssql-select-db.php

[10] ttps://openclassrooms.com/forum/sujet/ou-sont-stockes-les-cookies-87753

[11] ttp://php.net//manual/fr/function.imagecopyresampled.php

[12] veloppez.net

[13] ttp://php.net/manual/fr/book.ftp.php

[14] ttp://php.net/manual/fr/function.ftp-nlist.php

[15] ttp://php.net/manual/fr/function.mail.php

[16] ttps://sourceforge.net/projects/simplemailsvr/

[17] ttp://pear.php.net/package/Mail/download

[18] ttp://pear.php.net/package/Net_SMTP/download

[19] ttp://pear.php.net/package/Net_Socket/download

[20] ttp://pear.php.net/package/Mail_Mime/download

[21] ttp://sourceforge.net/projects/phpmailer/

[1]

[2]

[3]

[4]

[5]

[1]

[1]

[1]

[2]

[1]

[1]

[2]

[3]

[4]

[1]

[2]

[3]

[4]

[5]

[6]

[7]