#+Title: PHP
#+INCLUDE: "../common/inc/index.org"
* Les bases en PHP
#+BEGIN_NOTES
- HTML, CSS et JS sont des langages interprétés par un navigateur
côté client
- PHP s'utilise côté serveur et permet de générer du contenu HTML
- en pratique PHP peut générer n'importe quel type de contenu mais
nous nous limiterons à du HTML pour ce cours
- Afin de stocker des informations de manière durable, nous verrons
comment manipuler des fichiers et des bases de données SQL avec PHP
#+END_NOTES
** Pourquoi PHP ?
[[http://www.commitstrip.com/fr/2015/01/12/the-right-tool-for-the-right-job/][file:./inc/img/Strip-PHP-doute650-Web.jpg]]
#+BEGIN_NOTES
- la langage PHP est souvent critiqué mais il reste quand même
majoritairement le langage le plus utilisé pour réaliser un site
sur le web un peu moins de 80%
- https://w3techs.com/technologies/history_overview/programming_language
#+END_NOTES
** Introduction à PHP
- *[[http://php.net][PHP]]* (PHP: Hypertext Preprocessor)
- Langage de programmation
- impératif, procédural (suite d'instructions)
- interprété côté serveur
- libre
- Pages Web dynamiques
- Logo : [[./inc/img/php.png]]
- Mascotte (Elephpant) : [[./inc/img/elephpant.png]]
#+BEGIN_NOTES
- PHP est initialement proche du langage C
- Il permet de rendre un site dynamique
#+END_NOTES
*** Quelques versions de php
- =1.0 : 1995 := /PHP: Personal Home Page/
- =2.0 : 1997 := Base du langage PHP actuel
- =3.0 : 1998-2000 := /PHP: Hypertext Preprocessor/
- =4.0 : 2000-2001 := Zend engine
- =4.3 : 2002-2005 := /CLI: Command line interface/
- =5.0 : 2004-2005 := Zend engine 2, Programmation objet
- =5.3 : 2009-2014 := Namespace, closure
- =5.4 : 2012-2015 := Trait
- =6.0 : ......... := Unicode
- =7.0 : 2015-2018 := Zend engine 3
#+BEGIN_NOTES
- PHP évolue et s'utilise de plus en plus avec le paradigme de la programmation orientée objet.
- Comme pour javascript, nous ne nous attarderons pas sur cet aspect et nous nous limiterons aux bases de PHP.
#+END_NOTES
*** Hello world
:PROPERTIES:
:CUSTOM_ID: hello-world
:END:
- Créer un fichier avec l'extension .php
- Insérer du code HTML et/ou PHP
- Le code PHP doit être délimité par les balises ==
- Les instructions se terminent par =;=
- Les commentaires sont délimités par :
- =//= pour un commentaire sur une ligne
- =/*= pour un commentaire sur plusieurs lignes =*/=
#+NAME: phpjs-hello
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Dans cet exemple simple, on souhaite afficher la chaîne de
caractères « Hello world »
- En cliquant sur le bouton « Run » une fenêtre découpée en 3 vous affichera
- à gauche le code PHP
- en haut à droite le résultat du code PHP (la génération du code
HTML généré)
- en bas à droite l'affichage du code HTML par le navigateur
- Cliquer de nouveau sur le bouton « Run » pour voir le résultat
- Le comment hack est une illustration pour vous montrer comment
commenter/décommenter rapidement un bloc de code
- En supprimant le premier =/= le code complet est commenté
transformant le code =//*= par un =/*= passant d'un commentaire
sur une ligne à un commentaire sur un bloc qui se termine grâce au
code =// */= qui combine le commentaire linéaire et le commentaire
fin de bloc.
#+END_NOTES
** Les types en PHP
- types simples :
- boolean
- integer
- float (avant double)
- string
- types composés :
- array (tableau)
- /object (objet)/
- types spéciaux :
- /resource/
- NULL
#+BEGIN_NOTES
- PHP n'est pas un langage fortement typé contrairement au langage
C. Il se rapproche sur point avec javascriptq
- Nous allons préciser chaque type sauf les types 'object' et
'resource' que nous aborderons plus tard.
#+END_NOTES
*** Les booléens (boolean)
- Type le plus simple pour exprimer une valeur de vérité.
- Deux constantes insensibles à la casse :
- TRUE (vrai)
- FALSE (faux)
#+NAME: phpjs-true
#+BEGIN_SRC php
#+END_SRC
#+NAME: phpjs-false
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Le type booléen représente la notion vrai/faux
- La fonction =var_dump= permet d'afficher des informations
précises sur le paramètre donné.
- On peut remarquer que l'affichage de =false= n'affiche pas =0=
contrairement à ce qu'on aurait pu penser après avoir vu que
=true= affichait =1=
#+END_NOTES
*** Les booléens (cast)
- On utilise =(bool)= ou =(boolean)=
- Quand on convertit une valeur en booléen, sont considérés =false= :
- le booléen =false=
- l'entier =0=
- le réel =0.0=
- la chaîne vide = "" = et la chaîne = "0" =
- tout tableau vide
- tout objet sans membre ni variable (PHP4)
- le type =NULL= (ainsi que les variables non définies)
- Toutes les autres valeurs sont considérées comme =true=
#+BEGIN_NOTES
- De façon générale, il faut faire attention avec la conversion des types.
#+END_NOTES
*** Les booléens (exemple)
#+NAME: phpjs-boolean
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Essayer d'anticiper les résultats pour voir si vous avez bien
compris la conversion en booléen.
#+END_NOTES
*** Les entiers (integer)
- Un entier est un nombre de ${\mathbb{Z} = \{ \dots, -2, -1, 0, 1, 2, \dots\}}$
- Il peut se définir en :
- décimal (base 10) : @@html:42@@
- hexadécimal (base 16) : @@html:0x2A@@
- octal (base 8) : @@html:052@@
- binaire (base 2) : @@html:0b101010@@ (PHP 5.4)
- Il peut être précédé du signe =-= ou =+=
#+BEGIN_NOTES
- Il existe différentes notations pour les entiers mais en pratique
la base décimale est celle qui est pratiquement toujours utilisée.
#+END_NOTES
*** Les entiers (définis formellement)
#+BEGIN_SRC text
decimal : [1-9][0-9]*
| 0
hexadecimal : 0[xX][0-9a-fA-F]+
octal : 0[0-7]+
binary : 0b[01]+
integer : [+-]?decimal
| [+-]?hexadecimal
| [+-]?octal
| [+-]?binary
#+END_SRC
#+BEGIN_NOTES
- Cette notation formelle est juste présente pour illustrer la
définition des entiers en PHP.
- Par exemple pour la notation décimale, un entier en PHP correspond
à un '0' ou un nombre qui commence par 1, 2, ..., 9 suit ou pas
d'un autre chiffre compris entre 0 et 9
#+END_NOTES
*** Les entiers (cast)
- On utilise =(int)= ou =(integer)=
- =false= correspond à =0= et =true= à =1=
- Un réel sera arrondi vers =0=
- Seule la partie initiale d'une chaîne de caractères est prise en compte
- Faire attention de manière générale à la conversion des autres types
#+BEGIN_NOTES
- De façon générale, il faut faire attention avec la conversion des types.
#+END_NOTES
*** Les réels (float/double)
- Un réel (nombre à virgule flottante) appartient à ${\mathbb{R}}$
- La taille d'un réel dépend de la plateforme, mais en général
- max = ~1.8e308
- précision de 14 chiffres
- Attention à la perte de précision : http://www.floating-point-gui.de/
#+BEGIN_NOTES
- De façon générale, il faut faire attention avec la conversion des types.
- la perte de précision vient du fait de la représentation des
réels avec un ordinateur qui ne sait manipuler que des '0' et des
'1 et qui ne peut donc avoir que des représentations approchées
de ces réels. Un exemple concret sera donné par la suite
#+END_NOTES
*** Les réels (définis formellement)
#+BEGIN_SRC text
LNUM [0-9]+
DNUM ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM [+-]?(({LNUM} | {DNUM}) [eE][+-]? {LNUM})
#+END_SRC
#+BEGIN_NOTES
- Définition formelle des réels en PHP.
#+END_NOTES
*** Les réels (cast)
- On utilise =(float)= ou =(double)=
- Seule la partie initiale d'une chaîne de caractères est prise en compte
- Pour les autres types, l'élément est d'abord converti en =int= puis en =float=
#+BEGIN_NOTES
- De façon générale, il faut faire attention avec la conversion des types.
#+END_NOTES
*** Les entiers et les réels (exemple)
#+NAME: phpjs-int-float
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Essayer de trouver le résultat avant d'exécuter le code.
- Commenter ensuite le code en supprimant le premier '/' petit
rappel du comment hack
- Décommenter le code en bas en ajoutant un '/' au bon endroit et
essayer de trouver le résultat avant l'exécution. Si vous n'avez
pas la bonne réponse c'est que vous venez de découvrir le Floating
point problem sinon c'est que vous l'avez compris.
#+END_NOTES
*** Les chaînes de caractères (string)
- Une chaîne de caractères correspond à un tableau d'octets.
- Elle se définit à l'aide des = ' = ou = " =
- Les guillemets simples :
- pour afficher = ' = il faut le préfixer par =\=
- pour afficher =\= il faut utiliser =\\=
- tous les autres caractères préfixés par =\= sont affichés (=\n=, =\r=)
- Les guillemets doubles :
- pour afficher = " = il faut le préfixer par =\=
- les caractères préfixés par =\= sont interprêtés
- les variables sont également interprêtées
#+BEGIN_NOTES
- De façon générale essayer d'utiliser les guillemets simples qui
sont plus efficaces pour représenter les chaînes de caractères.
#+END_NOTES
*** Les chaînes de caractères (cast)
- On utilise =(string)=
- Convertion automatique avec certaines fonctions comme =echo=, =print=
- =true= est converti en = "1" = et =false= en = "" =
#+BEGIN_NOTES
- De façon générale, il faut faire attention avec la conversion des types.
#+END_NOTES
*** Les chaînes de caractères (affichage)
- =echo= et =print= ne sont pas de vraies fonctions (l'utilisation
des parenthèses est facultative, mais recommandée)
- la fonction [[http://php.net/manual/en/function.printf.php][=printf=]] affiche une chaîne de caractère formatée et
retourne la longueur de la chaîne affichée
#+BEGIN_SRC c-center
int printf (string $format [, mixed $args [, mixed $... ]] )
#+END_SRC
- la fonction [[http://php.net/manual/en/function.sprintf.php][=sprintf=]] retourne une chaîne formatée
#+BEGIN_SRC c-center
string sprintf (string $format [, mixed $args [, mixed $... ]] )
#+END_SRC
#+BEGIN_NOTES
- Vous devriez reconnaître ces fonctions inspirées du langage C
#+END_NOTES
*** Les chaînes de caractères (format)
- Le format dépend du type du paramètre que l'on veut afficher
- ~ "%s" ~ pour une chaîne de caractères
- ~ "%d" ~ pour un entier
- ~ "%f" ~ pour un réel
- Il peut spécifier un affichage personnalisé
- ~ "%4d" ~ affiche un entier de 4 caractères préfixé par des espaces
- ~ "%'04d" ~ affiche un entier de 4 caractères préfixé par des ~0~
- Il permet de réordonner les paramètres
- ~ "%2$s" ~ affiche le 2^e paramètre comme une chaîne de caractères
- ~ "%1$'04d" ~ affiche le 1^{er} paramètre sous forme d'entier de
4 caractères minimum préfixé par des ~0~
#+BEGIN_NOTES
- Le formatage des chaînes de caractères avec un ordre des
paramètres différent est principalement utilisé pour la
traduction.
- En français, on aurait pour afficher 'voiture bleue' :
- =$chaine = '%s %s';=
- =$object = 'voiture';=
- =$color = 'bleue';=
- En anglais, on aurait pour afficher 'blue car' :
- =$chaine = '%2$s %1$s';=
- =$object = 'car';=
- =$color = 'blue';=
- Avec la fonction =printf($chaine, $object, $color)=
#+END_NOTES
*** Les chaînes de caractères (fonctions de base)
- =strlen = : retourne la longueur de la chaîne
- =strcmp = : compare deux chaînes
- =trim = : supprime les espaces ou un autre caractère\\
= = en début (=ltrim=) et fin de chaîne (=rtrim=)
- =substr = : retourne une sous-chaîne
- =strpos = : cherche la position d'une sous-chaîne dans une autre chaîne
- =nl2br = : remplace =\n= en =
=
- =ucfirst= : première lettre en majuscule
- =ucwords= : première lettre de chaque mot en majuscule
- D'autres fonctions =str_replace=, =strtolower=, =strtoupper=, =implode=, =explode= sur : http://php.net/manual/en/ref.strings.php
#+BEGIN_NOTES
- Je vous invite à tester toutes ces fonctions
#+END_NOTES
*** Résumé (types simples)
#+NAME: phpjs-string
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Essayer d'anticiper le résultat avant de l'exécuter
#+END_NOTES
*** Les tableaux (array)
- Il faut utiliser le mot clé =array()= (=[]= autorisé depuis PHP 5.4)
- Chaque paramètre correspond à une paire =clé => valeur=
- Une clé peut-être un entier ou une chaîne de caractères
- Une chaîne correspondant à un entier valide sera transformé en entier
- Les autres types sont convertis en entiers
- Les clés sont optionnelles.
#+BEGIN_NOTES
- En pratique on utilise maintenant les crochets '[]'
- Les tableaux sont créés dynamiquement
- Quand la clé correspond à une chaîne de caractères on parle de
tableaux associatifs
#+END_NOTES
*** Les tableaux (fonctions de base)
- =count = : retourne le nombre d'éléments contenus dans un tableau
- =sort = : trie par rapport aux valeurs un tableau (=rsort= reverse)
- =asort = : trie les valeurs en conservant les clés (=arsort= reverse)
- =ksort = : trie les clés d'un tableau (=krsort= reverse)
- =array_keys = : retourne les clés d'un tableau sous forme d'un tableau
- =array_values= : retourne les valeurs d'un tableau sous forme d'un tableau
- D'autres fonctions =array_pop=, =array_shift=, =array_map= sur : http://php.net/manual/en/function.array.php
#+BEGIN_NOTES
- Je vous invite à tester toutes ces fonctions
#+END_NOTES
*** Les tableaux (exemple)
#+NAME: phpjs-array
#+BEGIN_SRC php
"b", 3 => "c"));
var_dump(array("a", 3 => "b", "c"));
?>
#+END_SRC
#+BEGIN_NOTES
- On peut remarquer que par défaut les clés correspondent à des
index commençant par 0
- Le deuxième tableau montre qu'il est possible d'utiliser des clés
numériques et textuelles dans le même tableau
- Le dernier tableau montre que les index créés se basent sur le
plus grand index existant. On aurait pu penser que le 'c' soit
associé à l'index 1 ou 2.
#+END_NOTES
** Les variables et constantes
*** Les variables
- Une variable est désignée par le signe =$=
- Le nom est sensible à la casse et commence par une lettre ou un
tiret du bas =_= suivi de lettres, de chiffres ou =_=
- =$this= est une variable spéciale qui ne peut pas être modifiée
- Il n'est pas obligatoire de déclarer et d'initialiser les variables (recommandé)
- Le nom d'une variable peut être dynamique
#+BEGIN_NOTES
- la variable =$this= est utilisée pour la manipulation des objets
en PHP.
#+END_NOTES
*** Gérer le type d'une variable
- La fonction =gettype()= permet d'obtenir une chaîne de caractères
correspondant au type de l'argument : =boolean=, =integer=,
=double=, =string=, =array=, =object=, =resource=, =NULL= ou
=unknown type=.
- Les fonctions suivantes : =is_array()=, =is_bool()=,
=is_float()=, =is_int()=, =is_null()=, =is_numeric()=,
=is_object()=, =is_resource()=, =is_scalar()= (integer, float,
string and booleen), =is_string()= permettent de vérifier si un
argument est d'un type particulier.
- Le typage est dynamique en PHP
#+BEGIN_NOTES
- comme le typage est dynamique en PHP, il peut parfois être utile
de vérifier le type associé à une variable pour utiliser cette
variable sans erreur dans le code.
#+END_NOTES
*** Tester l'état d'une variable
- =empty()=
- =is_null()=
- =isset()=
- =(bool)=
- http://php.net/manual/en/types.comparisons.php
#+BEGIN_SRC text-center
empty() !== (bool)
is_null() !== isset()
#+END_SRC
#+BEGIN_SRC text-center
'php' == 0 => true
0 == null => true
null == 'php' => false
#+END_SRC
#+BEGIN_NOTES
- les tests =empty()= et le cast =(bool)= ainsi que =is_null()= et
=isset()= sont strictement différents, quand l'un est =true=
l'autre est =false=
- Il faut faire cependant attention avec l'égalité simple, on peut
voir que la transitivité n'est pas respectée, on aurait pu
s'attendre à ce que =null= soit égal à ='php'=. Ceci illustre les
problèmes liés à la conversion des types
#+END_NOTES
*** Les constantes
- Par définition, la valeur d'une constante ne peut pas être modifiée
- On utilise par convention, un nom écrit en lettres capitales
- La fonction =define= est utilisée
#+NAME: phpjs-define
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Essayer de trouver le résultat avant d'exécuter le code.
- On peut voir la différence entre l'utilisation des guillemets
simples et doubles
- Il n'est pas possible d'utiliser les noms dynamiques des variables
dans une chaîne de caractères d'où l'affichage =$hello= et non pas
=world=
- Les constantes ne sont pas interprêtées et la chaînes =HELLO= est
donc conservées
#+END_NOTES
** Les opérateurs
- Les opérateurs arithmétiques
- Les opérateurs d'affectation
- Les opérateurs de comparaison
- Les opérateurs d'incrémentation et décrémentation
- L'opérateur ternaire
- Les opérateurs logiques
- Les autres opérateurs
#+BEGIN_NOTES
- Tous les opérateurs vont être présentés
#+END_NOTES
*** Les opérateurs arithmétiques
- =-$a = : la négation
- =$a + $b = : l'addition
- =$a - $b = : la soustraction
- =$a * $b = : la multiplication
- =$a / $b = : la division
- =$a % $b = : le modulo
- =$a ** $b= : l'exponentielle (PHP 5.6)
#+BEGIN_NOTES
- Ce sont les mêmes opérateurs que le langage C avec l'ajout de
l'exponentielle
#+END_NOTES
*** Les opérateurs d'affectation
- Le signe = = =
- Il est possible de combiner le signe = = = avec d'autres opérateurs
- Le passage par référence est possible avec = & =
- L'opérateur = * = du C n'a pas de signification en PHP
#+NAME: phpjs-assign
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- La notion de pointeur n'est pas défini comme en C et l'opérateur
= & = permet de créer un alias
#+END_NOTES
*** Les opérateurs de comparaison
- =$a == $b = : égalité des valeurs
- =$a === $b= : identité (égalité des valeurs et des types)
- =$a != $b = : différence
- =$a <> $b = : différence
- =$a !== $b= : non identité (différence des valeurs ou des types)
- =$a < $b = : infériorité
- =$a > $b = : supériorité
- =$a <= $b = : infériorité ou égalité
- =$a >= $b = : supériorité ou égalité
#+BEGIN_NOTES
- Comme PHP n'est pas fortement typé, il faut considérer
principalement l'identité et la non identité pour comparer des
variables, ceci afin d'éviter les erreurs liées à la conversion de
types
#+END_NOTES
*** Les opérateurs d'incrémentation et décrémentation
- =++$a= : incrémente =$a= de 1, puis retourne =$a=
- =$a++= : retourne =$a= puis incrémente =$a= de 1
- =--$a= : décrémente =$a= de 1, puis retourne =$a=
- =$a--= : retourne =$a= puis décrémente =$a= de 1
#+NAME: phpjs-incr-decr
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Essayer de trouver le résultat avant d'exécuter le code. Il s'agit
du même comportement que le langage C
#+END_NOTES
*** L'opérateur ternaire
- =?:= est un opérateur conditionnel ternaire
- =(expr1) ? (expr2) : (expr3)= est évalué à :
- =expr2= si =expr1= est évaluée à =true=
- =expr3= si =expr1= est évaluée à =false=
- =expr2= n'est plus obligatoire depuis PHP 5.3
#+NAME: phpjs-ternary
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- L'opérateur ternaire n'est utile pour simplier la lecture du code source.
#+END_NOTES
*** Les opérateurs logiques
- =$a && $b = : =true= si =$a= et =$b= valent =true=
- =$a and $b= : =true= si =$a= et =$b= valent =true=
- =$a || $b = : =true= si =$a= vaut =true= ou =$b= vaut =true=
- =$a or $b = : =true= si =$a= vaut =true= ou =$b= vaut =true=
- =$a xor $b= : =true= si =$a= vaut =true= ou =$b= vaut =true= mais pas les 2
- =!$a = : =true= si =$a= ne vaut pas =true=
#+BEGIN_NOTES
- Il s'agit ici des opérateurs logiques classiques
#+END_NOTES
*** Les autres opérateurs
- =.= correspond à l'opération de concaténation pour les chaînes de caractères
- =[index]= permet d'accéder à un élément particulier d'un tableau
- =[]= permet assigner une valeur à la fin d'un tableau
#+NAME: phpjs-array-op
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Essayer de trouver le résultat avant d'exécuter le code.
#+END_NOTES
** Les structures de contrôle
- Les structures conditionnelles
- Les structures répétitives
- L'inclusion de fichiers
#+BEGIN_NOTES
- Tous les structures de contrôle vont être présentées
#+END_NOTES
*** Les structures conditionnelles (if, else, elseif)
#+BEGIN_SRC c
if (condition) {
instructions; // si condition évaluée à true
}
#+END_SRC
#+BEGIN_SRC c
if (condition) {
instructions; // si condition évaluée à true
} else {
instructions; // si condition évaluée à false
}
#+END_SRC
#+BEGIN_SRC c
if (condition1) {
instructions; // si condition1 évaluée à true
} elseif (condition2) {
instructions; // si condition1 évaluée à false et condition2 évaluée à true
} else {
instructions; // si condition1 et condition 2 évaluées à false
}
#+END_SRC
#+BEGIN_NOTES
- =elseif= n'existe pas en C où il faut utiliser =else if=
#+END_NOTES
*** Les structures conditionnelles (switch)
#+BEGIN_SRC c
switch ($i) {
case 0:
echo "i equals 0";
break;
case 'a':
echo "i equals a";
break;
default:
echo "aucune valeur correspondante";
}
#+END_SRC
- équivalent à :
#+BEGIN_SRC c
// == pas ===
if ($i == 0) {
echo "i equals 0";
} elseif ($i == 'a') {
echo "i equals a";
} else {
echo "aucune valeur correspondante";
}
#+END_SRC
#+BEGIN_NOTES
- Il faut faire attention à la conversion de types quand on utilise
un switch car la comparaison n'est pas effectuée sur le type
#+END_NOTES
*** Les structures répétitives (tant que)
#+BEGIN_SRC c
while (condition) {
instructions; // tant que condition est évaluée à true
}
#+END_SRC
#+BEGIN_SRC c
do {
instructions; // tant que condition est évaluée à true
} while (condition);
#+END_SRC
#+BEGIN_NOTES
- =do...while= est à utiliser pour exécuter l'instruction au moins
une fois
#+END_NOTES
*** Les structures répétitives (pour)
#+BEGIN_SRC c
for (expr1; expr2; expr3) { // expr1 est exécutée une seule fois au début de la boucle
instructions; // exécuté tant que expr2 est évaluée à true
// expr3 est exécutée à la fin de chaque itération
}
#+END_SRC
- équivalent à :
#+BEGIN_SRC c
expr1;
while (expr2) {
instructions;
expr3;
}
#+END_SRC
#+BEGIN_NOTES
- Les structures répétitives sont équivalentes, c'est à vous de
choisir celle que vous préférez
#+END_NOTES
*** Les structures répétitives (tableau)
- =foreach= permet de parcourir les éléments d'un tableau
#+BEGIN_SRC c
foreach ($array as $value) {
instructions;
}
#+END_SRC
#+BEGIN_SRC c
foreach ($array as $key => $value) {
instructions;
}
#+END_SRC
#+BEGIN_NOTES
- Pour parcourir un tableau, il est conseillé d'utiliser =foreach=
#+END_NOTES
*** Exemple général sur les structures
#+NAME: phpjs-while-foreach-example
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Essayer de trouver le résultat avant d'exécuter le code.
#+END_NOTES
** Les fonctions
- sont des blocs d'instructions que l'on peut répéter dans un programme
- ne sont pas exécutées directement après leurs définitions
- sont exécutées par un appel
#+NAME: phpjs-function
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- les fonctions sont similaires aux fonctions du langage C
#+END_NOTES
*** Les arguments
- Un argument est une variable, défini après le nom de la fonction entre paranthèses
- Les arguments sont séparés par une virgule
#+NAME: phpjs-function-args
#+BEGIN_SRC php
\n";
}
helloWorld('Hello', 'world');
helloWorld('Bonjour', 'tous');
?>
#+END_SRC
#+BEGIN_NOTES
- les fonctions avec des arguments sont similaires aux fonctions du langage C
#+END_NOTES
*** Les valeurs par défaut
- Il est possible de définir une valeur par défaut à un argument
- Les arguments qui ont une valeur par défaut sont définis en dernier
#+NAME: phpjs-function-default-args
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Contrairement aux fonctions en C il est possible de définir une
valeur par défaut si aucun paramètre n'est donné à la fonction
alors la variable prendra cette valeur
#+END_NOTES
*** Les retours
- Tous les types de variables peuvent être retournés par une fonction
- Si =return= est absent, =null= est retourné
#+NAME: phpjs-function-return
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- les retours des fonctions sont similaires aux retours des
fonctions du langage C
#+END_NOTES
*** Retourner plusieurs valeurs
- Il faut utiliser un tableau
#+NAME: phpjs-function-return-array
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Comme il est possible de retourner un tableau en PHP, cela permet
de renvoyer plusieurs valeurs
#+END_NOTES
*** Arguments par référence
#+NAME: phpjs-function-args-reference
#+BEGIN_SRC php
#+END_SRC
#+BEGIN_NOTES
- Les références correspondent plus ou moins aux pointeurs en C à la
différence qu'il n'y a pas d'équivalent pour l'opérateur '*'. On
ne peut pas manipuler les adresses seulement le contenu des variables.q
#+END_NOTES
*** Une fonction récursive
#+NAME: phpjs-function-rec
#+BEGIN_SRC php
0) {
$res = 'o'.o($n -1);
}
return $res;
}
function helloWorld($n = 1) {
echo 'Hell'.o($n)." world!\n";
}
helloWorld();
helloWorld(10);
?>
#+END_SRC
#+BEGIN_NOTES
- La récursivité des fonctions fonctionne comme en langage C
#+END_NOTES
** Les variables prédéfinies
- =$_GET = : variables de la méthode GET (dans l'url)
- =$_POST = : variables de la méthode POST (dans l'entête HTTP)
- =$_REQUEST= : contenu de =$_GET=, =$_POST= (=$_COOKIE= : PHP < 5.3)
- =$_FILES = : gestion des fichiers uploadés
- =$_COOKIE = : variables des cookies HTTP (stockées chez le client)
- =$_SESSION= : variables de session (stockées sur le serveur)
- =$_SERVER = : variables de serveur et d'exécution
- =$GLOBALS = : variables disponibles dans le contexte global (/à éviter/)
- =$argc = : nombre d'arguments passés au script (=CLI=)
- =$argv = : tableau avec les arguments passés au script (=CLI=)
#+BEGIN_NOTES
- Nous reverrons l'utilisation de ces variables en fonction des
besoins
#+END_NOTES
** =$_SERVER=
| =$_SERVER['DOCUMENT_ROOT']= | Racine du serveur |
| =$_SERVER['HTTP_ACCEPT_LANGUAGE']= | Langage accepté par le navigateur |
| =$_SERVER['HTTP_HOST']= | Nom de domaine du serveur |
| =$_SERVER['HTTP_USER_AGENT']= | Type de navigateur |
| =$_SERVER['PATH_INFO']= | Chemin WEB du script |
| =$_SERVER['REQUEST_URI']= | Chemin du script |
| =$_SERVER['REMOTE_ADDR']= | Adresse IP du client |
| =$_SERVER['REMOTE_PORT']= | Port de la requête HTTP |
| =$_SERVER['QUERY_STRING']= | Liste des paramètres passés au script |
| =$_SERVER['SERVER_ADDR']= | Adresse IP du serveur |
#+BEGIN_NOTES
- Il faut faire attention à l'usage de cette variable car les
résultats ne sont pas nécessairement consistant et sont liés à la
configuration du serveur
#+END_NOTES
* Les formulaires
#+BEGIN_NOTES
- L'interaction avec les formulaires va montrer l'intérêt de PHP. Avec
PHP nous allons pouvoir récupérer des informations envoyées par le
client sur le serveur et interagir en conséquence.
- Pour rappel l'attribut =action= de la balise form permet d'indiquer
la page qui va récupérer les informations du formulaire et
l'attribut =method= indiquera la façon d'envoyer les informations
(=GET= ou =POST=)
#+END_NOTES
** GET
#+INCLUDE: "./examples/form_get.php" src php-src
[[./examples/form.php?filename=form_get][exemple]]
#+BEGIN_NOTES
- dans cet exemple, =action= considère la page courante. Pour cela la
variable =$_SERVER= qui est un tableau peut être utilisée et l'index
=PHP_SELF= contient le nom de page courante (ce qui évite de coder
en dur le nom de la page et évite des erreurs si on décide de
renommer le fichier)
- Attention ceci n'est pas forcément la meilleure solution, nous y
reviendrons.
- Le formulaire contient une information textuelle avec le nom =input=
- Après avoir validé le formulaire, regardez dans l'URL de votre
navigateur, il devrait y avoir l'information suivante
=?input=la_valeur_que_vous_avez_entree=
- La méthode =GET= permet de récupérer des paramètres dans les URL. Il
ne faut donc pas l'utiliser pour des informations sensibles (mot de
passe par exemple)
- La redirection sur la page de résultat affiche le contenu de
certaines variables PHP =GET=, =POST=, =REQUEST=, =FILES=, =COOKIE=
pour rappel =REQUEST= regroupe les valeurs passées dans =GET= et
=POST=
- Ce qu'il faut retenir c'est que =GET= permet de passer des valeurs
de formulaire dans l'URL. Le format est =?nom1=valeur1&nom2=valeur2=
#+END_NOTES
** Sécurité
:PROPERTIES:
:reveal_background: #C8321E
:END:
- Attention à l'utilisation de =$_SERVER["PHP_SELF"]=
- Attention aux données reçues sur le serveur
#+BEGIN_NOTES
- l'utilisation seule de =$_SERVER["PHP_SELF"]= n'est pas sécurisée
comme vous allez le voir dans l'exemple d'après.
- il faut également faire attention aux données qui sont envoyées par
le =client= sur le =serveur=, elles pourraient chercher à
compromettre l'usage normal. Il faut donc toujours les vérifier
avant de les utiliser.
#+END_NOTES
*** =$_SERVER["PHP_SELF"]=
=$_SERVER["PHP_SELF"]= permet de faire référence au script en cours
- Problème
#+BEGIN_SRC html-center