PHP : Premier script
PHP/Premier script

Une page de Wikiversité.

PHP/Premier script est une ébauche concernant l'informatique. Vous pouvez aider le projet Wikiversité en l'améliorant.

**Premier script**
Leçon : PHP

Chapitre 1
Retour au	sommaire
Chap. suiv. :	Syntaxe du langage

[modifier] Le script

Le PHP est conçu pour s'intégrer facilement dans vos pages HTML. Voici un exemple d'une 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 :

<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 : Syntaxe du langage
PHP/Syntaxe du langage

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

**Syntaxe du langage**
Leçon : PHP

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

Sommaire

[masquer]

[modifier] 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.

[modifier] 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.

[modifier] Affichages

Il y a deux façons d'afficher du texte à partir de PHP, il s'agit d'un echo et print(). Tous deux s'utilisent de manière différente.

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

[modifier] 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 doit débuter par un dollar $. 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.

//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) ou un underscore (_), suivi de lettres (majuscules/minuscules), chiffres ou autres underscores. Cette utilisation de l'underscore (_) au début est réservé aux variables d'environnements, tel que $_SESSION, $_GET, $_POST (voir les chapitres suivants).

[modifier] 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 :

[modifier] 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.

$var = 5;
$foo = $var;

[modifier] 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 :

$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

[modifier] Opérateurs de comparaisons

Ceux-ci fonctionnent de gauche à droite: valeur comparé symbole valeur comparente. 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 d'utilisation:

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

[modifier] Concaténation

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

Exemple basique:

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

[modifier] 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:

$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 ">" reverra la valeur false car 25 n'est pas supérieur à 26. Cependant, l'opérateur unaire "!" renverra à son tour l'opposé, soit true.

[modifier] 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".

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

[modifier] 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 opérateurs, des plus prioritaires jusqu'au moins prioritaire:

=
++ 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 :

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

[modifier] Lien externe

(fr) Site officiel du PHP

PHP : Structures de contrôle
PHP/Structures de contrôle

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

**Structures de contrôle**
Leçon : PHP

Chapitre 3
Chap. préc. :	Syntaxe du langage
Chap. suiv. :	Syntaxe du langage (avancé)

Sommaire

[masquer]

[modifier] 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 qui condition soit remplie).

[modifier] Structures de contrôle conditionnelles

[modifier] Instruction IF … ELSE …

Syntaxe : 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
}

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

$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é
}

[modifier] Instruction SWITCH

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

Note : 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 :

$ma_variable = 1;
switch ($ma_variable)
{
 case 1:
  // Code si $ma_variable est égale à 1
 
 case 2:
  // Code si $ma_variable est égale à 2 ou 1
 break;
 
 case 3:
  // Code si $ma_variable est égale à 3
 break;
 
 default:
  // Code dans tous les autres cas (equivaut à else)
 break;
}

Ici, seul les instructions situées dans le "case 1" seront prisent en compte. À 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.

[modifier] Opérateur ternaire

Syntaxe : Condition ? ExecuterCode1 : ExecuterCode2;

Note : 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 :

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

Avec les ternaires :

$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 :)

[modifier] Structures de contrôle de boucle

[modifier] Boucle FOR

syntaxe : FOR(ExpressionInitale ; ExpressionConditionnelle ; 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).

ExpressionCondtionnelle sert de test de sortie de boucle : 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.

[modifier] Boucle FOREACH

Syntaxe : 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
}

[modifier] Boucle WHILE

Syntaxe : WHILE ( ExpressionConditionnelle ) { ExecuterCode }

Exemple :

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

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

[modifier] Boucle DO … WHILE

Syntaxe : DO { ExecuterCode } WHILE ( ExpressionConditionnelle )

Exemple :

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

Note : 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.

[modifier] Break et continue

[modifier] 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 !

[modifier] 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,".

PHP : Syntaxe du langage (avancé)
PHP/Syntaxe avancée

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

**Syntaxe du langage (avancé)**
Leçon : PHP

Chapitre 4
Chap. préc. :	Structures de contrôle
Chap. suiv. :	Fonctions

Sommaire

[masquer]

[modifier] 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).

[modifier] Tableau itératifs

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

Exemple d'utilisation simple:

$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 :

$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']).

[modifier] 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 :

$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." ";

La dernière boucle parcours le tableau en affichant d'abord les clés (cle1, cle2, cle3) puis les valeurs (val1, val2…) : cle1 : val1 cle2 : val2 cle3 : val3 .

[modifier] Fonctions usuelles sur les tableaux

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

Son prototype est: entier count(tableau);

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

[modifier] Tableaux multi-dimensionnels

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

$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 cette exemple, une base de données serait sûrement plus adéquate.

[modifier] Les variables super globales

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

[modifier] Variables de serveur : $_SERVER

Elle contient des informations sur le serveur (nom, ip, softs installés…)

Documentation PHP

[modifier] 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.

[modifier] Cookies : $_COOKIE

Elle stocke les informations sur les cookies envoyés aux clients.

[modifier] GET variables : $_GET

Elle stocke les valeurs des arguments passés par URL. Ses clés sont donc par conséquent variables.

[modifier] POST variables : $_POST

Elle stocke les valeurs des informations passées par formulaire. Ses clés sont donc par conséquent variables. Voir le cours sur les formulaires.

[modifier] 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.

[modifier] Variables de requête : $_REQUEST

Un tableau associatif constitué du contenu des variables $_GET, $_POST, $_COOKIE.

[modifier] Variables de session : $_SESSION

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

[modifier] Variables globales : $GLOBALS

Elle stocke les variables globales de la page. Ses clés sont donc variables.

PHP : Fonctions
PHP/Fonctions

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

**Fonctions**
Leçon : PHP

Chapitre 5
Chap. préc. :	Syntaxe du langage (avancé)
Chap. suiv. :	Classes

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

Sommaire

[masquer]

[modifier] Déclaration de fonction

[modifier] 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.

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

[modifier] 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 cle 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).

Voici un 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 2 fichiers. L'un pour les variables, l'autre pour les traitements.

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

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

[modifier] Références

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 :

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

[modifier] 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éveler 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 (retourne true ou false).
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.

PHP : Classes
PHP/Classes

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

PHP/Classes est une ébauche concernant l'informatique. Vous pouvez aider le projet Wikiversité en l'améliorant.

**Classes**
Leçon : PHP

Chapitre 6
Chap. préc. :	Fonctions
Chap. suiv. :	Base de données

Sommaire

[masquer]

[modifier] 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.

[modifier] Utilisation des classes (basique)

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:

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:

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-clé new:

$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 ce fait en utilisant ->.

[modifier] Utilisation des attributs

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

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

$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'

[modifier] 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:

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

[modifier] 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.

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'

[modifier] 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 magique.

Syntaxe PHP 4

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

Syntaxe PHP5

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

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

$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

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

Syntaxe PHP5

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

$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

[modifier] 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

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

[modifier] AutoLoad

Pour utiliser une classe il faut l'avoir

Syntaxe PHP5

Fichier autoload.php

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

Fichier index.php

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

[modifier] Utilisation des classes (avancée) en PHP5

PHP : Base de données
PHP/Base de données

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

PHP/Base de données est une ébauche concernant l'informatique. Vous pouvez aider le projet Wikiversité en l'améliorant.

**Base de données**
Leçon : PHP

Chapitre 7
Chap. préc. :	Classes
Chap. suiv. :	Formulaire

Sommaire

[masquer]

[modifier] 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: ODBC, Oracle, MS SQL, FrontBase, Sybase, Informix, PostgresSQL, Berkeley, ...

Nous allons ici traiter plus particulièrement de MySQL. Dans toute la suite, nous utiliserons l'abréviation BDD pour « base de données ».

[modifier] PHP et MySQL

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.

[modifier] 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 » ne sera interprété si son adresse est tapée directement dans un navigateur et vos identifiants apparaitront en clair).

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 :

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

[modifier] Requête SQL

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

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

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

// ... 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;
 
// ... deconnexion

[modifier] 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.

// ... 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éupération d'un tableau associatif
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";
}

[modifier] Compter le nombre de lignes d'un résultat

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

[modifier] Compter le nombre de champs d'un résultat

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

[modifier] Lister les bases de données d'un serveur

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

[modifier] Lister les tables

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

[modifier] Lister les champs

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

[modifier] Lister l'ID de la dernière ligne insérée.

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

PHP : Les formulaires
PHP/Formulaire

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

**Les formulaires**
Leçon : PHP

Chapitre 8
Chap. préc. :	Base de données
Chap. suiv. :	Sessions

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.

Sommaire

[masquer]

[modifier] 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

[modifier] 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.

<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

[modifier] 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écuperer les valeurs d'un formulaire on utilise $valeur=$_POST["nomvariable"];

Si vous désirez récuperer 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écuperer 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é.

<?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) */

[modifier] 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.

<?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 : Les sessions en PHP
PHP/Sessions

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

**Les sessions en PHP**
Leçon : PHP

Chapitre 9
Chap. préc. :	Formulaire
Chap. suiv. :	Fichiers

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

Sommaire

[masquer]

[modifier] 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.

[modifier] 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), mais vaut généralement une trentaine de minutes. Une fois ce délai dépassé, la session est supprimée.

[modifier] 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.

[modifier] 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).

[modifier] Utiliser les sessions

[modifier] 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.

[modifier] 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.

<?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' .

[modifier] 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.

Un 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. */
 
?>

[modifier] 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.

[modifier] 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.

[modifier] Le formulaire

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

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

[modifier] 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.

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

$mdp = 'qwertz';
 
if($mdp == $_POST['mdp']) {
  $_SESSION['admin'] = true;
  header('Location: admin.php'); // Redirection du navigateur
} 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 :

<?php
session_start();
 
$mdp = 'qwertz';
 
if($mdp == $_POST['mdp']) {
  $_SESSION['admin'] = true;
  header('Location: admin.php'); // Redirection du navigateur
} else {
  echo 'Le mot de passe est erroné';
}
 
?>

[modifier] La page d'administration

Cette page doit se nommer admin.php. Si vous décider 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.

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

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

[modifier] Fermer une session

De la même façon que d'autre 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ée.

Une fois le script PHP terminé, les données de la session sont automatiquement sauvegardée pour le prochaine 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 : Les sessions en PHP
PHP/Fichiers

Une page de Wikiversité.

< PHP

Aller à : Navigation, rechercher

PHP/Fichiers est une ébauche concernant l'informatique. Vous pouvez aider le projet Wikiversité en l'améliorant.

**Les sessions en PHP**
Leçon : PHP

Chapitre 10
Chap. préc. :	Sessions

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.

[modifier] Chmod

Avant toute chose, il faut savoir que 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 chmmod 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 '777'.

[modifier] Ouvrir & Fermer un fichier

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

<?php
$mon_fichier  =  fopen ($filename, $mode);
?>

Explication : La fonction fopen à besoin de deux paramètres pour pouvoir s'executer.

$filename, 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.

<?php
$mon_fichier  =  fopen ($filename, $mode);
 
fclose ($mon_fichier);
?>

PHP : Premier script PHP/Premier script

Une page de Wikiversité.

[modifier] Le script

PHP : Syntaxe du langage PHP/Syntaxe du langage

Une page de Wikiversité.

Sommaire

[modifier] Séparateur d'instruction

[modifier] Commentaires

[modifier] Affichages

[modifier] Variables

[modifier] Opérateurs

[modifier] Opérateur binaire d'affectation

[modifier] Opérateurs binaires de calcul

[modifier] Opérateurs de comparaisons

[modifier] Concaténation

[modifier] Opérateurs unaires

[modifier] Opérateurs d'incrémentations

[modifier] Priorité entre les opérateurs

[modifier] Lien externe

PHP : Structures de contrôle PHP/Structures de contrôle

Une page de Wikiversité.

Sommaire

[modifier] Introduction

[modifier] Structures de contrôle conditionnelles

[modifier] Instruction IF … ELSE …

[modifier] Instruction SWITCH

[modifier] Opérateur ternaire

[modifier] Structures de contrôle de boucle

[modifier] Boucle FOR

[modifier] Boucle FOREACH

[modifier] Boucle WHILE

[modifier] Boucle DO … WHILE

[modifier] Break et continue

[modifier] Break

[modifier] Continue

PHP : Syntaxe du langage (avancé) PHP/Syntaxe avancée

Une page de Wikiversité.

Sommaire

[modifier] Les tableaux

[modifier] Tableau itératifs

[modifier] Tableaux associatifs

[modifier] Fonctions usuelles sur les tableaux

[modifier] Tableaux multi-dimensionnels

[modifier] Les variables super globales

[modifier] Variables de serveur : $_SERVER

[modifier] Variables d'environnement : $_ENV

[modifier] Cookies : $_COOKIE

[modifier] GET variables : $_GET

[modifier] POST variables : $_POST

[modifier] Variable de téléchargement : $_FILES

[modifier] Variables de requête : $_REQUEST

[modifier] Variables de session : $_SESSION

[modifier] Variables globales : $GLOBALS

PHP : Fonctions PHP/Fonctions

Une page de Wikiversité.

Sommaire

[modifier] Déclaration de fonction

[modifier] Utilisation

[modifier] Portée des variables

[modifier] Références

[modifier] Les fonctions variables

PHP : Classes PHP/Classes

Une page de Wikiversité.

Sommaire

[modifier] Théorie générale sur la POO

[modifier] Utilisation des classes (basique)

[modifier] Utilisation des attributs

[modifier] Utilisation des méthodes

[modifier] Auto-Référence

[modifier] Constructeur

[modifier] Destructeur

[modifier] AutoLoad

[modifier] Utilisation des classes (avancée) en PHP5

PHP : Base de données PHP/Base de données

Une page de Wikiversité.

Sommaire

[modifier] PHP et les bases de données

[modifier] PHP et MySQL

[modifier] Connexion à MySQL

[modifier] Requête SQL

PHP : Premier script
PHP/Premier script

PHP : Syntaxe du langage
PHP/Syntaxe du langage

PHP : Structures de contrôle
PHP/Structures de contrôle

PHP : Syntaxe du langage (avancé)
PHP/Syntaxe avancée

PHP : Fonctions
PHP/Fonctions

PHP : Classes
PHP/Classes

PHP : Base de données
PHP/Base de données

PHP : Les formulaires
PHP/Formulaire

PHP : Les sessions en PHP
PHP/Sessions

PHP : Les sessions en PHP
PHP/Fichiers