Note de Cours PHP

Enseignant : Hachicha hassan

Filière : IG4
 Partie I
I. Présentation de PHP

II. Variables et type de données

III. Les opérateurs

IV. Les instructions de contrôles

V. Les fonctions
I. Présentation de PHP

 PHP est un langage de scripts côté serveur.

 PHP est un langage open source et multi plate-formes (Windows, Linux…).

 Le code PHP a la même syntaxe et la même structure que le langage C.

 Les instructions sont mélangées au code HTML dans de simple fichiers

texte.
Caractéristiques du langage PHP

 PHP ("PHP : Hypertext Preprocessor") est un langage de scripts exécuté

sur le serveur .

 C'est le serveur Web qui effectue tout le travail de traitement du script et

de transmission au navigateur du HTML standard résultant.

 Les lignes d'instruction des scripts peuvent êtres placées au milieu du

code HTML.

 Les fichiers PHP sont avec une extension '.php' (ou .php3, .php4).
Fonctionnement du langage
PHP avec le serveur APACHE
Caractéristiques du langage PHP (suite)

 PHP permet la collecte de données par l'intermédiaire :

 Par l’intermédiaire des formulaires,

 Par la connexion à des bases de données,

 Par envoi et lecture de cookies,

 Par accès au système de fichiers du serveur, etc.

 PHP donne accès à un grand nombre de bases de données (IBM DB2,

Ingres, InterBase, MS-SQL, MySQL, ODBC, Oracle, PostgreSQL , Sybase, etc).

Caractéristiques du langage PHP (suite)

 Pour que le serveur puisse différencier le code HTML du code PHP,

celui-ci doit être marqué avec <? ?>

 Les instructions se terminent obligatoirement par un point virgule

 Les noms d'instruction et les mots clé, les noms de fonctions (standards ou

utilisateur) et les noms de classes peuvent être écrits indifféremment en

majuscules ou en minuscules.

Les 3 lignes suivantes sont équivalentes :

echo "bonjour";
ECHO "bonjour";
EcHo "bonjour";
Caractéristiques du langage PHP (suite)
 Les noms de variables sont sensibles aux majuscules et aux minuscules.

$Var, $var et $VAR sont 3 variables différentes.

Les commentaires peuvent être mis dans le code. Trois syntaxes sont

disponibles :

- # marque le début d'un commentaire qui s'arrête à la fin de la ligne

- // marque le début d'un commentaire qui s'arrête à la fin de la ligne

- /* et */ marquent le début et la fin de commentaires qui peuvent

s'étendre sur plusieurs lignes.

Caractéristiques du langage PHP (suite)

 Les noms (de variables, de fonctions, de classes, de constantes) doivent

commencer par un caractère alphabétique ou le caractère _ (underscore).

Les caractères suivants peuvent être alphabétiques ou numériques.

Exemple
L'exemple suivant affiche la date et l'heure du serveur. Il utilise la fonction

date() pour cacluler la date et l'heure, et la fonction echo pour afficher le

résultat.
 Le code pourrait être écrit de la façon suivante
I. Variables et types de données
 Dans PHP, les variables peuvent provenir de plusieurs sources :

 Définies par le développeur

 Définies automatiquement par PHP en fonction du contexte d'utilisation.

 Le nom des variables doit être préfixé avec $

 Le nom des variables doit commencer par une lettre ou le caractère _

(underscore). Les caractères suivants peuvent être des lettres, des nombres, le

caractère _.

 Les variables n'ont pas besoin d'être déclarées. La première fois où une

valeur est assignée à une variable, la variable est créée.

Exemple
<?
$x = 'François';
echo '<p>La variable x est égale à ', $x;
echo '<br>Elle est du type ', gettype($x);

$x = 12345;
echo '<p>La variable x est égale à ', $x;
echo '<br>Elle est maintenant du type ', gettype($x);

$x = 12345.678 * 10 + 15;
echo '<p>La variable x est égale à ', $x;
echo '<br>Elle est maintenant du type ', gettype($x);
?>
Portée d’une variable

 La portée d'une variable (scope) dépend de l'endroit où la variable est définie.

 Quand une variable est définie dans une fonction, sa portée est locale à la

fonction.

 Quand une variable est définie en dehors d'une fonction, sa portée est globale

à l'ensemble des lignes de script en dehors des fonctions.

Variables prédéfinis

 PHP défini automatiquement un certain nombre de variables,

généralement stockées dans des tableaux associatifs.

Le tableau $GLOBALS
 Variables prédéfinies provenant d'une URL
Exemple :lapage.php?Nom=piat&Prenom=françois

 Toutes les fois qu'un paramètre est trouvé dans l'URL de la page, PHP va

le stocker dans un tableau associatif global appelé $HTTP_GET_VARS.

 A partir de PHP 4.1, ces variables sont également stockées dans le

tableau de superglobales $_GET

 Variables prédéfinies provenant d'un formulaire

PHP génère automatiquement un tableau associatif global appelé

$HTTP_POST_VARS et contenant les zones du formulaire.

 A partir de PHP 4.1, ces variables sont également stockées dans le tableau

de superglobales $_POST.
 Variables prédéfinies provenant d'un cookie

Le code suivant pose un cookie appelé Nom et ayant la valeur piat :

setcookie('Nom','piat')

 PHP génère automatiquement un tableau associatif global appelé

$HTTP_COOKIE_VARS et contenant les cookies.

 Ces variables sont également stockées dans le tableau de superglobales $_COOKIE

 Variables prédéfinies provenant de l'environnement ou du serveur

 PHP génère automatiquement deux tableaux associatifs globaux appelés

$HTTP_ENV_VARS et $HTTP_SERVER_VARS.

 Ces variables sont également stockées dans les tableaux de

superglobales $_ENV et $_SERVER.

Gestion de la mémoire

 PHP utilise le comptage de référence et la méthode "copy-on-write" pour

gérer la mémoire. La méthode "copy-on-write" économise la mémoire en cas

de copie de variables, et le comptage de référence permet de libérer la

mémoire dès qu'une variable n'est plus utilisée.

 La fonction isset() permet de savoir si une variable est définie (si une valeur lui

est affectée).
Exemple
<html>
<head><title>variables définies ou non</title></head>
<body>
<?php
TestVariable($x); // la variable x n'est pas définie
$x = 100; // assignation d'un valeur
TestVariable($x);

$x = ''; // assignation d'une chaîne vide

TestVariable($x);

$x = NULL; // assignation de la valeur null

TestVariable($x);

unset($x); // suppression de la variable

TestVariable($x);
Exemple Suite
fonction TestVariable($LaVar) {
if (isset($LaVar)) {
echo '<p>La variable a la valeur ', $LaVar;
} else {
echo '<p>La variable n\'est pas définie';
}
}?>
</body>
</html>
Evaluation d’une variable

 Les valeurs saisies par un utilisateur dans un formulaire sont toujours considérées

comme des chaînes de caractères.

 Même si l'utilisateur saisi 0 (zéro), cette valeur sera traitée comme une chaîne de

caractères pour l'évaluation.

 Un tableau ou une variable texte venant d'un formulaire à travers des cases à

cocher ou des boutons radio pourra être indéfini (unset) si l'utilisateur n'a pas coché

les cases.

 Une zone texte (<input type="text"> ou <textarea>) ne sera jamais indéfinie. Si

l'utilisateur n'y saisit rien, la variable contiendra une chaîne vide ('').

 Les valeurs TRUE, FALSE et NULL ne peuvent pas venir de la saisie d'un utilisateur.
 La variables générées par un script peuvent prendre toutes les valeurs énoncées.

 Nous utiliserons les opérateurs et fonctions suivantes pour tester la valeur des variables :

 if (! $Var) $Var n'est pas

 if (empty($Var)) $Var est vide
 if ($Var == '') $Var est vide
 if ($Var === '') $Var est de type chaîne et vide
 if (isset($Var)) $Var contient une valeur
 if (strlen($Var) == 0) la longueur de $Var est de 0
 if (is_string($Var)) $Var est une chaîne
Les constantes

Une constante représente une valeur simple,

identifiée par un nom. Seuls les types de
données scalaires (booléen, entier, double et
chaîne de caractères) peuvent être placés dans
une constante.

Les constantes sont accessibles de manière

globale.
Une constante est définie avec la fonction
Vous pouvez définir une constante en utilisant
la fonction define() :
define('NOM_CONSTANTE', valeur);
Une fois qu'une constante est définie, elle ne
peut plus être modifiée, ou détruite.

Pour accéder à la valeur d'une constante, on

spécifie simplement son nom, qui NE DOIT PAS
être préfixé par le caractère $ comme pour le
variables.
Les opérateurs

Les opérateurs arithmétiques +, -, /, *, %

Concaténation de chaînes
La concaténation de chaînes se fait avec
l'opérateur . (point). Si nécessaire, les
opérandes sont convertis automatiquement en
chaînes.
Les chaînes peuvent être entourées de guillemets simples ou doubles. PHP
traîtera différemment les chaînes suivant le type des guillemets :
- si la chaîne est entourée de guillemets simples, elle est évaluée tel que.
- si la chaîne est entourée de guillemets doubles, les variables éventuelles
contenues dans la chaîne seront remplacées par leur valeur.
Exemple : concaténation de chaînes

<html>
<head><title>Concaténation de chaînes</title></head>
<body>
<?php
$x = 'François';
$y = 'Piat';

$z = $x . ' ' . $y;

echo $z;

$z = "Mon nom est $y";

echo '<p>' . $z;

echo "<p>Mon nom est $y, $x $y"; // guillemets doubles

echo '<p>Mon nom est $y, $x $y'; // guillemets simples

?>
</body>
</html>
Incrément et décrément

Les opérateurs d'autoincrément et

d'autodécrément ne sont applicables qu'à des
variables, numériques ou alphanumériques

Opérat Résultat sur Valeur

Syntaxe  
eur la variable retournée
++ $x ++ post incrément $x = $x + 1 $x
  ++ $x pré incrément $x = $x + 1 $x + 1
-- $x -- post décrément $x = $x - 1 $x
  -- $x pré décrément $x = $x - 1 $x - 1

Opérateurs de comparaison

==
!=
>=, <=, >,<
Opérateurs logiques

AND ou &&
OR ou ||
!
XOR

Opérateurs d'assignement

Ces opérateurs assignent une valeur, ou modifient la valeur d'une

variable. L'assignement peut être simple ou avec opération.
=, +=, -=, *=, %=, .=, /=
Autres opérateurs
Lorsque cet opérateur est ajouté en préfixe d'une expression PHP, les
@ messages d'erreur qui peuvent être générés par cette expression ne
seront pas affichés.
Exécution de la chaîne comprise entre les guillemets obliques, comme
`..`
une commande système.
Opérateur de test conditionnel.
?: 
Syntaxe : (test) ? valeur_si_vrai : valeur_si_faux
//Exemple: Affichage paire/impaire avec operateur conditionnel
$x = ($Seconde % 2 == 0) ? 'paire' : 'impaire';
echo '<p>', $x;
Les instructions de contrôle

Instruction conditionnelle if

if (condition) {
    instruction
    [instruction
    instruction]
}

if (condition) {
   instruction
    [instruction
    instruction]
} else {
   instruction
    [instruction
    instruction]
}  
if (condition1) {
   instruction
    [instruction
    instruction]
} elseif (condition2) {
   instruction
    [instruction
    instruction]
} elseif (condition3) {
   instruction
    [instruction
    instruction]
} else {
   instruction
    [instruction
    instruction]
}  
Instructions conditionnelle Switch
switch (expression){
   case label1 :
      instruction
      break
   case label2 :
      instruction
      break
   ...
   default : instruction
} 

Instructions de boucles while

while (condition) {
   instructions
} 
Instructions de boucle do…while
PHP supporte aussi les boucles do ... while avec la syntaxe :
do
{
    instructions
} while (condition);

Instructions de boucle for

for (init compteur; condition d'exécution; incrément compteur)
{
   instructions;
} 
Boucle foreach
L'instruction foreach permet de boucler dans les éléments d'un tableau.

foreach ($Tableau as $Valeur) {

  instructions
} 

foreach ($Tableau as $Cle => $Valeur) {

  instructions
} 

Exemple
<?
echo '<b>Tableau index numérique</b>';
$Tableau = array('Pierre', 'Paul', 'Jacques', 'François');

foreach ($Tableau as $Valeur) {

echo '<br>', $Valeur;
}
foreach ($Tableau as $Cle => $Valeur) {
echo '<br>L\'élément ', $Cle, ' contient ', $Valeur;
}?>
Fin de script exit et die
exit met immédiatement fin au script PHP courant et provoque l'envoi de la page
telle qu'elle est au navigateur

die est un alias de exit et peut être utilisée à sa place avec les même règles.

Exemple:
Mysql_select_db(‘gestcomm’) or die (‘Impossible de se connecter à la BD’);
Les fonctions

PHP possède de nombreuses fonctions intégrées permettant d'effectuer des

traitements variés
Déclarer et appeler une fonction
function Nom_fonction ([param1 [,param2 ...., paramn]])
 Le nom d'une fonction doit commencer par une lettre ou le caractère _
(underscore)
 Les fonctions peuvent être déclarée n'importe où dans la page, avant
ou après leur appel.
Renvoi de valeur

Généralement les fonctions retournent une valeur. Pour cela, nous emploierons le

mot-clé return, suivi de la valeur à renvoyer

Portée des variables

 Les variables définies à l'intérieur d'une fonction ne sont accessibles qu'à

l'intérieur de cette fonction. Dans notre exemple, la variable $Html n'est pas

connue du reste du script.

 Les variables définies à l'extérieur d'une fonction ne sont pas accessibles à

l'intérieur de la fonction

 En utilisant le mot-clé global, les variables définies à l'extérieur d'une

fonction seront accessibles à l'intérieur de la fonction
Exemple

<html>
<head><title>Portée des variables</title></head>
<body>
<?php
$Var_script = 'script';
echo Affiche_simple();
echo Affiche_global();
echo '<p><b>En dehors d\'une fonction</b>'
.'<br>Variable Var_script : '. $Var_script
.'<br>Variable Var_fonction : '. $Var_fonction;
function Affiche_simple() {
$Var_fonction = 'fonction';
return '<p><b>Dans la fonction Affiche_simple</b>'
.'<br>Variable Var_script : ' . $Var_script
.'<br>Variable Var_fonction : ' . $Var_fonction;
}
//-------------------------------------------------------
function Affiche_global() {
global $Var_script;
return '<p><b>Dans la fonction Affiche_global</b>'
.'<br>Variable Var_script : ' . $Var_script
.'<br>Variable Var_fonction : ' . $Var_fonction;
}
?>
</body>
</html>
Nombre variable de paramètres

PHP 5 supporte les fonctions à nombre variable de paramètres. Pour déclarer

une telle fonction, il suffit de ne pas donner de paramètres dans la déclaration
de la fonction :
function Parametres_variables()

 PHP fournit trois fonctions qui donnent des informations sur les arguments passés à
une fonction
• func_get_args :retourne les arguments d’une fonction sous forme de tableau
• func_get_arg: retourne un élément de la liste des arguments
• func_num_args: retourne le nombre d’arguments passés à la fonction
Inclure du code externe
 Quatre instructions permettent d'inclure des fichiers externes dans un script :

include, include_once, require et require_once.

 Chacune des instructions accepte comme paramètre l'adresse du fichier à inclure

dans la page appelante :

include ('entete.html');

include_once ('fonctions_communes.php');

require ('commun/bibli.php');

require_once ('../bibli/mes_fonctions.php');
Comme pour les chaînes de caractères, PHP offre de nombreuses fonctions pour
travailler avec des tableaux.
Les tableaux peuvent être indexés ou associatifs et leur création est très facile,
directement, ou avec des fonctions de génération.

 Types de tableaux dans PHP

 PHP supporte deux types de tableaux : indexé et associatif.

 Dans un tableau indexé, les clés sont des entiers positifs.

 Dans un tableau associatif, les clés sont des chaînes de caractères.

 Les éléments d'un tableau peuvent être de n'importe quel type, et des éléments de

types différents peuvent être stockés dans le même tableau.

 En interne, PHP stocke tous les tableaux sous la forme de tableaux associatifs.
• La création d'un tableau est très facile : stocker une valeur dans un tableau

qui n'existe pas va créer le tableau.

• Pour accèder à un élément dans un tableau, on utilise des crochets :

$Tableau[10], $Tableau['abcd'], $Tableau[$i].

• Si au moment de l'assignation d'une valeur à un élément, on ne donne pas

d'index, PHP va automatiquement ajouter l'élément à la fin du tableau, et créer

un index numérique.

 La fonction count()renvoie le nombre d'élément dans un tableau (associatif

comme indexé)
Attention aux trous dans les tableaux indexés.

Si dans un tableau indexé, les index ne sont pas consécutifs, PHP ne comblera
pas automatiquement les trous. Cela peut parfois poser des problèmes dans les
itérations à travers ce type de tableau, comme le montre l'exemple suivant :

<html>
<head><title>Tableau à trous</title></head>
<body>
<?php
$t[0] = 'François';
$t[1] = 'Piat';
$t[5] = 407;
echo 'Nombre d\'éléments : ', count($t);
for ($i = 0; $i < count($t); $i++) {
echo "<br>Index = $i <br>Elément = $t[$i]
<br>";
}
?>

</body>
</html>
La solution pour éviter cette erreur est d'utiliser une instruction
foreachà la place de l'instruction forpour faire l'itération dans les
éléments du tableau :
<html>
<head><title>Tableau à trous</title></head>
<body>
<?php
$t[0] = 'François';
$t[1] = 'Piat';
$t[5] = 407;
echo 'Nombre d\'éléments : ', count($t);
//------------------------------------------------------
echo '<hr><b>Boucle avec for</b><hr>';
for ($i = 0; $i < count($t); $i++) {
echo "<br>Elément = $t[$i]";
}
//------------------------------------------------------
echo '<p><hr><b>Boucle avec foreach</b><hr>';
foreach ($t as $e) {
echo "<br>Elément = $e";
}
?></body></html>
 Créer un tableaux avec array()
L'instruction array()permet de créer un tableau à partir des arguments qui lui sont
passés. Cette instruction est pratique pour créer des tableaux de petite taille.
<html>
<head><title>Créer des tableaux avec array()</title></head>
<body><pre>
<?php
$t = array();
InfoTableau($t);
echo '<hr><b>Tableau indexé</b><hr>';

$t = array('François', 'Piat', 407);

infoTableau($t);
echo '<hr><b>Tableau associatif</b><hr>';

$t = array('B41d' => 'Pierre‘, 'C24a' => 'Paul‘, 'D12z' => 'Jacques');

infoTableau($t);

function infoTableau($t) {
echo 'Tableau de ', count($t), ' éléments<br>';
print_r($t);
}?></body></html>
Syntaxe de l'instruction foreach :

foreach ($Tableau as $Valeur)

{
instructions
}

<html>
<head><title>Boucle avec foreach</title></head>
<body><pre>
<?php
//---------------------------------------------------------
echo '<hr><b>Foreach avec un tableau associatif</b><hr>';
$ta['B41d'] = 'Pierre';
$ta['C24a'] = 'Paul';
$ta['D12z'] = 'Jacques';

foreach ($ta as $valeur) {

echo "<br>Elément = $valeur";
}
//---------------------------------------------------------
echo '<hr><b>Foreach avec un tableau indexé</b><hr>';
// remarque : le tableau contient des trous
$ti[0] = 'François‘;
$ti[3] = 'Piat‘;
$ti[6] = 407;

foreach ($ti as $valeur) {

echo "<br>Elément = $valeur";
}
?>
</body>
</html>
Syntaxe de l'instruction foreach :

foreach ($Tableau as $Valeur) {

instructions
}

Accèder aux clés

foreach permet aussi d'accéder à la clé d'un élément avec la syntaxe :

foreach ($Tableau as $Cle => $Valeur)

{
instructions
}
Trier un tableau

PHP dispose de plusieurs fonctions permettant de trier un tableau.

Les fonctions sort() et rsort() permettent de trier un tableau par valeurs croissantes ou
décroissante

PHP peut également trier un tableau par indice, à l’aide des fonctions ksort() et
brsort(), qui utilisent de la même manière que les fonctions précédentes
Une chaine de caractère est un ensemble de caractères entre guillemet simple ou double

Les fonctiosn de chaines de caractères:

 Trim(): string trim(string str):

Cette fonction retire les espaces blanc de début et de fin de chaine et retourne la chaine

nettoyée

 Strlen(): int strlen(string str):

Retourne la longueur de la chaine de caractère

<html>
<head><title>Nombre de caractères</title></head>
<body>
<?php
$x = 'abcdefghijklmnopqrstuvwxyz';

echo strlen($x), ' caractères dans la chaîne ', $x;

for ($i = 0; $i < strlen($x); $i++) {

echo '<br>Position ', $i, ' = ', $x[$i];
}
?>
</body>
</html>
 implode(): string implode(string separator, array tableau):

Retourne une chaine constituée de tous les éléments du tableaux , pris dans l’ordre,

transformé en chaine, et séparés par séparateur

 Explode(): array explode(string separator, string str):

Retourne un tableau qui contient les éléments de la chaine string, séparés par sépérator

 Str_replace(): string str_replace(modèle, remplacement, chaine):

Remplace toutes lesoccurences de modèle dans chaine par remplacement.

Exemple : transformer une chaîne en tableau
<html>
<head><title>Transformer une chaîne en tableau</title></head>
<body>
<?php
$x = 'François,Piat,407C';
$t = explode(',', $x);

foreach ($t as $cle=>$valeur) {

echo '<br>', $cle, ' = ', $valeur;
}
echo '<p>';
//------------------------------------------------------
$x = 'François Piat 407C';
$t = explode(' ', $x);

for ($i = 0; $i < count($t); $i++) {

echo '<br>', $i, ' = ', $t[$i];
}
?>
</body>
</html>
 Rechercher dans une chaîne

1. Différentes fonctions permettent de faire des recherches de caractères ou de chaînes à l'intérieur

d'une chaîne.
2. Parmi toutes les fonctions de recherche, les plus employées sont :
strpos()qui renvoie la position d'une sous-chaîne à l'intérieur d'une chaîne,
strrpos()qui renvoie la dernière position d'un caractère à l'intérieur d'une chaîne,
strstr()qui renvoie une partie de chaîne à partir de la position d'une sous-chaîne
stristr()est identique à strsstr, mais ignore les différences majuscules/minuscules
strrchr()qui renvoient une partie de chaîne à partir de la dernière position d'un caractère à l'intérieur
d'une chaîne.
3. Toutes les fonctions de recherche retournent false si elles ne trouvent pas ce qu'elles cherchent.
Afin d'éviter de confondre le 0 de false et le 0 de la position du premier caractère d'une chaîne, il
faut toujours tester le résultat de ces fonctions avec l'opérateur d'identité === et pas avec
l'opérateur d'égalité ==.
4. Soit le code suivant :
$x = 'François';
$Pos = strpos($x, 'F');