Chapitre 4 Langage de Programmation PHP

langage
PHP
Chapitre 4
Qu'est-ce que PHP ?
• PHP est l'acronyme de "PHP : Hypertext Preprocessor"
• PHP est un langage de script open source largement utilisé
• Les scripts PHP sont exécutés sur le serveur
• PHP est gratuit à télécharger et à utiliser
• Les fichiers PHP peuvent contenir du texte, du code HTML, CSS, JavaScript et PHP
• Le code PHP est exécuté sur le serveur et le résultat est renvoyé au navigateur sous
forme de HTML brut
• Les fichiers PHP ont l'extension " .php"

Exemple de code PHP
" echo" fonction PHP intégrée
<!DOCTYPE html>
afficher le texte
<html>
<body> <!DOCTYPE html>
<html>
<?php <body>
$color = "red";
echo "My car is " . $color <h1>My first PHP page</h1>
. " ";
echo "My house is " . $COLOR <?php
. " "; echo "Hello World!";
echo "My boat is " . $coLOR ?>
. " ";
?> </body>
</html>
</body>
</html>
Remarque les commentaire en php sont comme dans le langage de programmation c

Balises PHP ¶
• Lorsque PHP traite un fichier, il cherche les balises d'ouverture et de fermeture (<?php et
?>) qui délimitent le code qu'il doit interpréter.
• De cette manière, cela permet à PHP d'être intégré dans toutes sortes de documents, car
tout ce qui se trouve en dehors des balises ouvrantes / fermantes de PHP est ignoré.
Séparation des instructions
• PHP requiert que les instructions soient terminées par un point-
virgule à la fin de chaque instruction. La balise fermante d'un bloc de
code PHP implique automatiquement un point-virgule ; vous n'avez
donc pas besoin d'utiliser un point-virgule pour terminer la dernière
ligne d'un bloc PHP. La balise fermante d'un bloc inclura
immédiatement un caractère de nouvelle ligne si un est présent.
Les types de variables
PHP supporte les types basiques.
types scalaires :
boolean
integer
float (nombre à virgule flottante,
i.e. double)
string
types composés :
array
object
iterable
Pour forcer la conversion d'une variable en un certain type, vous pouvez transtyper (cast) la
variable ou utiliser la fonction settype().
Les chaînes de caractères ¶
Une chaîne de caractères est une série de caractères, où un caractère est la même
chose qu'un octet. De ce fait, PHP ne supporte que les jeux de caractères
comportant 256 caractères différents.
Les tableaux ¶
• Un tableau en PHP est en fait une carte ordonnée qui associe des valeurs à des clés.
• Un tableau peut être créé en utilisant la structure de langage array().
Remarque: La clé key peut être soit un integer, soit une chaîne de caractères. La valeur peut être de
n'importe quel type.
Tableaux associatifs - parcours avec boucle foreach
Portée des variables
La portée d'une variable dépend du contexte dans lequel la variable est
définie. Pour la majorité des variables, la portée concerne la totalité d'un
script PHP. Mais, lorsque vous définissez une fonction, la portée d'une
variable définie dans cette fonction est locale à la fonction. Par exemple :
Le script n'affichera rien à l'écran car l'instruction echo utilise la variable locale $a, et celle-ci n'a pas été assignée
préalablement dans la fonction
Exemple avec global
Le script ci-dessus va afficher la valeur 3. En déclarant globales les variables

$a et $b locales de la fonction somme(), toutes les références à ces
variables concerneront les variables globales.
VariaLes tableaux prédéfinis de PHP :
Superglobales
Ce sont des tableaux concernant pour l’essentiel le protocole HTTP ou
la gestion de Cookies
ou des Sessions.
— $_GET[ ], $_POST[ ] ou $_REQUEST[ ] qui englobe les 2
— $_SERVER[ ] : Variables décrivant le client ou la page courante
— $_GLOBALS[ ] variables globales
— $_COOKIE[ ] pour les cookies
— $_SESSION[ ] pour les sessions
Les opérateurs
du langage
PHP
Les opérateurs
• Un opérateur est quelque chose qui prend une ou plusieurs
valeurs (ou expressions, dans le jargon de la programmation)
et qui retourne une autre valeur (donc la construction elle-
même devient une expression).
• Les opérateurs peuvent être regroupés en fonction du nombre de
valeurs qu'ils acceptent.
• L'opérateur unaire n'opère que sur une seule valeur, par exemple !
(l'opérateur de négation) ou ++ (l'opérateur d'incrémentation).
• les opérateurs binaires (+ ou -) contient la plupart des opérateurs supportés
par PHP.
• l'opérateur ternaire, ? :, qui accepte trois valeurs (on peut aussi l'appeler
l'opérateur conditionnel).
Les opérateurs arithmétiques
L'opérateur de division ("/") retourne une valeur à virgule flottante sauf si les 2 opérandes sont des entiers
(ou une chaîne de caractères qui a été convertie en entiers) et que leur division est exacte (i.e. a pour reste
0), auquel cas une valeur entière sera retournée. Pour la division entière, voir intdiv().
Les opérateurs d'affectation
• L'opérateur d'affectation le plus simple est le signe "=".
• Il signifie que l'opérande de gauche se voit affecter la valeur
de l'expression qui est à droite du signe égal.
<?php
$a = 3;
$a += 5; // affecte la valeur 8 à la variable $a correspond à l'instruction '$a = $a + 5';
$b = "Bonjour ";
$b .= " tout le monde!"; // affecte la valeur "Bonjour tout le monde!" à
// la variable $b
// identique à $b = $b." tout le monde!";
?>
Affectation par référence
• L'affectation par référence est aussi supportée, au moyen de la syntaxe
"$var = &$othervar;". L'affectation par référence signifie que les deux
variables pointent vers le même conteneur de donnée, rien n'est copié nulle
part.
<?php
$a = 3;
$b = &$a; // $b est une référence à $a
print "$a\n"; // affiche 3

print "$b\n"; // affiche 3
$a = 4; // change $a
print "$a\n"; // affiche 4

print "$b\n"; // affiche 4 aussi, car $b est une référe
nce à $a, qui a été
// changée
?>
Les opérateurs d'assignement
arithmétiques
Opérateurs de comparaison
Les opérateurs de comparaison, comme leur nom l'indique, vous permettent de
comparer deux valeurs.
Exemple Nom Résultat
$a == $b Egal TRUE si $a est égal à $b après le transtypage.
$a === $b Identique TRUE si $a est égal à $b et qu'ils sont de même type.
$a != $b Différent TRUE si $a est différent de $b après le transtypage.
$a <> $b Différent TRUE si $a est différent de $b après le transtypage.
$a !== $b Différent TRUE si $a est différent de $b ou bien s'ils ne sont pas du même type.
$a < $b Plus petit que TRUE si $a est strictement plus petit que $b.
$a > $b Plus grand TRUE si $a est strictement plus grand que $b.
$a <= $b Inférieur ou égal TRUE si $a est plus petit ou égal à $b.
$a >= $b Supérieur ou égal TRUE si $a est plus grand ou égal à $b.

L'opérateur ternaire ("?:").
<?php
// Exemple d'utilisation pour l'opérateur ternaire
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];
// La ligne ci-dessus est identique à la condition suivante :

if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}
?>
var_dump() affiche les informations structurées d'une variable, y compris son type et sa valeur
Opérateur de fusion Null (??)
<?php
// Exemple d'utilisation pour: Opérateur de fusion Null
$action = $_POST['action'] ?? 'default';
// le code ci-dessus est équivalent à cette structure if/else

if (isset($_POST['action'])) {
$action = $_POST['action'];
} else {
$action = 'default';
}
?>
Opérateurs d'incrémentation et décrémentation
• PHP supporte les opérateurs de pre- et post-incrémentation et
décrémentation, comme en langage C.
• La décrémentation des valeurs NULL n'a également aucun effet, mais
leur incrémentation donnera comme résultat 1.
Exemple Nom Résultat

++$a Pre-incrémente Incrémente $a de 1, puis retourne $a.
$a++ Post-incrémente Retourne $a, puis incrémente $a de 1.
--$a Pré-décrémente Décrémente $a de 1, puis retourne $a.
$a-- Post-décrémente Retourne $a, puis décrémente $a de 1.
Opérateurs de chaînes
Il y a deux opérateurs de chaînes de caractères string. Le premier est l'opérateur de concaténation
('.'), qui retourne la concaténation de ses deux arguments. Le second est l'opérateur d'affectation
concaténant (.=).
<?php
$a = "Bonjour ";
$b = $a . "Monde !"; // $b contient "B
onjour Monde !"
$a = "Bonjour ";
$a .= "Monde !"; // $a contient "Bonjo
ur Monde !"
?>
Opérateurs de types
instanceof est utilisé pour déterminer si une variable PHP est un objet instancié
d'une certaine classe :
<?php
class MaClasse
{
}
class PasMaClasse
{
}
$a = new MaClasse;
var_dump($a instanceof MaClasse);

var_dump($a instanceof PasMaClasse);
?>
L'exemple ci-dessus va afficher :

bool(true)
bool(false)
Les classes et les objets
Syntaxe de base ¶
• Une définition de classe basique
commence par le mot-clé class, suivi <?php
du nom de la classe. Suit une paire class SimpleClass

d'accolades contenant la définition des {
// déclaration d'une propriété
propriétés et des méthodes public $var = 'une valeur par défaut';
appartenant à la classe. // déclaration des méthodes
• Le nom de la classe peut être public function displayVar() {
echo $this->var;
quelconque à condition que ce ne soit }
}
pas un mot réservé en PHP.
?>
• La pseudo-variable $this est disponible
lorsqu'une méthode est appelée
depuis un contexte objet.
Le mot-clé new ¶
Pour créer une instance d'une classe, le mot-clé new doit être utilisé. Un objet sera alors
systématiquement créé.
<?php
$instance = new SimpleClass();
// Ceci peut également être réalisé avec une variable :

$className = 'SimpleClass';
$instance = new $className(); // new SimpleClass()
?>
Lors de l'assignation d'une instance déjà créée d'une classe à une variable, la nouvelle variable accédera à la même
instance que l'objet qui a été assigné.
$instance = new SimpleClass();
$assigned = $instance;
$reference =& $instance;
Propriétés et méthodes
• Les propriétes et méthodes de classe vivent dans des "espaces de noms" séparé,
donc il est possible d'avoir une propriété et une méthode avec le même nom
<?php
class Foo
{
public $bar = 'property';
L'exemple va afficher :
public function bar() {
return 'method'; property
} method
}
$obj = new Foo();

echo $obj->bar, PHP_EOL, $obj->bar(), PHP_EOL;
Le mot-clé extends
• Une classe peut hériter des méthodes et des membres d'une autre classe en utilisant le mot-clé extends dans
la déclaration.
• Il n'est pas possible d'étendre plusieurs classes : une classe peut uniquement hériter d'une seule classe de
base.
• Les méthodes et membres hérités peuvent être surchargés en les redéclarant avec le même nom
que dans la classe parente.
• Cependant, si la classe parente a défini une méthode comme final, alors celle-ci ne sera pas
surchargeable.
Héritage simple d'une classe
<?php
class SimpleClass
{
// définition de la méthode parente
function displayVar()
{
echo "une valeur par défaut";
}
}
?>
<?php
class ExtendClass extends SimpleClass
{
// Redéfinition de la méthode parente
function displayVar()
{
echo "Classe étendue\n";
parent::displayVar();
} L'exemple va afficher :
}
$extended = new ExtendClass(); Classe étendue

$extended->displayVar(); une valeur par défaut
?>
Propriétés
• Les variables au sein d'une classe sont appelées propriétés.
• Elles sont définies en utilisant un des mots-clés public, protected, ou private, suivi optionnellement d'une déclaration
de type, suivi d'une déclaration classique de variable.
• Cette déclaration peut comprendre une initialisation, mais celle-ci doit être une valeur constante, c'est à dire qu'elle
doit pouvoir être évaluée pendant la compilation du code.
• Au sein des méthodes de classes (méthode statique), les propriétés non statiques peuvent être appelées en utilisant
la syntaxe -> (opérateur de l'objet) : $this->property
• Les propriétés statiques peuvent être appelées en utilisant la syntaxe :: (deux doubles points) : self::$property.
• La pseudo-variable $this est disponible au sein de n'importe quelle méthode, lorsque cette méthode est appelée
depuis un objet.
Constantes de classe
• Il est possible de définir des valeurs constantes à l'intérieur d'une classe, qui
ne seront pas modifiables. Les constantes diffèrent des variables normales du
fait que l'on n'utilise pas le symbole $ pour les déclarer ou les utiliser. La
visibilité par défaut des constantes de classe est public.
• La valeur doit être une expression constante, pas (par exemple) une variable,
une propriété, ou un appel de fonction.
Définition et utilisation d'une constante de classe
<?php
class MyClass $class = new MyClass();
{ $class->showConstant();
const CONSTANT = 'valeur constante';
echo $class::CONSTANT."\n"; // Depuis PHP 5.3.0
function showConstant() { ?>
echo self::CONSTANT . "\n";
}
}
Constructeurs et destructeurs
Constructeur__construct ([ mixed $args = "" [, $... ]] ) : void
PHP permet de déclarer des constructeurs pour les classes.
Les classes qui possèdent une méthode constructeur appellent cette
méthode à chaque création d'une nouvelle instance de l'objet.
Si vous voulez utiliser un constructeur parent, il sera nécessaire de faire
appel à parent::__construct() depuis le constructeur enfant

Exemple d'utilisation des nouveaux constructeurs unifiés
<?php class OtherSubClass extends BaseClass {
class BaseClass { // Constructeur hérité de BaseClass
function __construct() { }
print "Dans le constructeur de BaseClass\n";
} // Dans le constructeur de BaseClass
$obj = new BaseClass();
function __destruct() {
// Dans le constructeur de BaseClass
print "Destroying " . __CLASS__ . "\n"; // Dans le constructeur de SubClass
} $obj = new SubClass();
}
// Dans le constructeur de BaseClass
$obj = new OtherSubClass();
class SubClass extends BaseClass { ?>
function __construct() {
parent::__construct();
print "Dans le constructeur de SubClass\n";
}
}
Visibilité
• La visibilité d'une propriété, d'une méthode ou d’une constante peut être
définie en préfixant sa déclaration avec un mot-clé : public, protected, ou
private.
• Les éléments déclarés comme publics sont accessibles partout.
• L'accès aux éléments protégés est limité à la classe elle-même, ainsi
qu'aux classes qui en héritent et parente.
• L'accès aux éléments privés est uniquement réservé à la classe qui les a
définis.
• Les propriétés des classes doivent être définies comme
publiques, protégées, ou privées.
• Si une propriété est déclarée en utilisant var, elle sera alors
définie comme publique.
Visibilité depuis d'autres objets
Les objets de mêmes types ont accès aux membres privés et protégés les uns des autres, même s'ils ne sont pas la même instance. Ceci
est dû au fait que les détails spécifiques de l'implémentation sont déjà connus en interne par ces objets.
<?php public function baz(Test $other)

class Test{ {
private $foo; // Nous pouvons modifier la propriété privée :
$other->foo = 'Bonjour';
public function __construct($foo) var_dump($other->foo);
{
$this->foo = $foo; // Nous pouvons également appeler la méthode privée :
} $other->bar();
}
private function bar() }
{ $test = new Test('test');
echo 'Accès à la méthode privée.'; $test->baz(new Test('other'));
} ?>

string(7) "Bonjour"
Accès à la méthode privée.
L'opérateur de résolution de portée (::)
L'opérateur de résolution de portée le symbole "double deux-points" (::), fournit un moyen d'accéder aux
membres static ou constant, ainsi qu'aux propriétés ou méthodes surchargées d'une classe.
Exemple #2 :: depuis la définition de la classe

Exemple #1 :: en dehors de la définition de la classe <?php
class OtherClass extends MyClass
{
<?php
public static $my_static = 'variable statique';
class MyClass {
const CONST_VALUE = 'Une valeur constante';
public static function doubleColon() {
}
echo parent::CONST_VALUE . "\n";
echo self::$my_static . "\n";
$classname = 'MyClass';
}
echo $classname::CONST_VALUE;
}
$classname = 'OtherClass';
echo MyClass::CONST_VALUE;
$classname::doubleColon();
?>
OtherClass::doubleColon();
?>
Abstraction de classes
Les classes définies comme abstraites ne peuvent pas être instanciées, et toute classe contenant au moins une méthode
abstraite doit elle-aussi être abstraite. Les méthodes définies comme abstraites déclarent simplement la signature de la
méthode - elles ne peuvent définir son implémentation.
Exemple #1 Exemple de classe abstraite

<?php
abstract class AbstractClass class ConcreteClass1 extends AbstractClass
{ {
// Force les classes filles à définir cette méthode protected function getValue() {
abstract protected function getValue(); return "ConcreteClass1";
abstract protected function prefixValue($prefix); }
// méthode commune
public function prefixValue($prefix) {
public function printOut() {
print $this->getValue() . "\n"; return "{$prefix}ConcreteClass1";
} }
} }
Exemple #1 Exemple de classe abstraite
class ConcreteClass2 extends AbstractClass

{ $class1 = new ConcreteClass1;
public function getValue() { $class1->printOut();
return "ConcreteClass2"; echo $class1->prefixValue('FOO_') ."\n";
}
$class2 = new ConcreteClass2;
public function prefixValue($prefix) { $class2->printOut();
return "{$prefix}ConcreteClass2"; echo $class2->prefixValue('FOO_') ."\n";
} ?>
}
ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
Interfaces
• Les interfaces objet vous permettent de créer du code qui spécifie
quelles méthodes une classe doit implémenter, sans avoir à définir
comment ces méthodes fonctionneront.
• Les interfaces sont définies de la même façon que pour une classe, mais
en utilisant le mot-clé interface à la place de class, et sans spécifié le
contenu des méthodes.
• toutes les méthodes déclarées dans une interface doivent être
publiques.
implements
• l'opérateur implements est utilisé pour implémenter .
• Toutes les méthodes de l'interface doivent être implémentées dans une
classe ; si ce n'est pas le cas, une erreur fatale sera émise.
• Les classes peuvent implémenter plus d'une interface, en séparant chaque
interface par une virgule.
Les constantes
Les interfaces peuvent contenir des constantes.
Les constantes d'interfaces fonctionnent exactement comme les constantes
de classe, mis à part le fait qu'elles ne peuvent pas être écrasées par une
classe ou une interface qui en hérite.
Exemple #1 Exemple d'interface
// Ceci ne fonctionnera pas
<?php
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
// Declaration de l'interface 'iTemplate'
interface iTemplate class BadTemplate implements iTemplate
{ {
public function setVariable($name, $var); private $vars = array();
public function getHtml($template);
}
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
// Implémentation de l'interface
// Ceci va fonctionner }
class Template implements iTemplate ?>
{
private $vars = array();
public function setVariable($name, $var)

Exemple #2 Interfaces avec des constantes
{
$this->vars[$name] = $var; <?php
} interface a
{
public function getHtml($template) const b = 'Constante de l\'interface';
{ }
foreach($this->vars as $name => $value) { // Affiche : Constante de l'interface
$template = str_replace('{' . $name . '}', $ echo a::b;
value, $template);
} // Par contre, ceci ne fonctionnera pas, puisqu'il n'est pas permis
// d'écraser des constantes.
return $template; class b implements a
{
} const b = 'Constante de classe';
} }
?>
Traits
• Les traits sont un mécanisme de réutilisation de code
• Un trait tente de réduire certaines limites de l'héritage simple, en autorisant
le développeur à réutiliser un certain nombre de méthodes dans des classes
indépendantes.
• La sémantique entre les classes et les traits réduit la complexité et évite les
problèmes typiques de l'héritage multiple et des Mixings.
• Un trait est semblable à une classe, mais il ne sert qu'à grouper des
fonctionnalités d'une manière intéressante.
• Il n'est pas possible d'instancier un Trait en lui-même.
• C'est un ajout à l'héritage traditionnel, qui autorise l'utilisation de méthodes
de classe sans besoin d'héritage.
Exemple #1 Exemple d'utilisation de Trait Exemple avec l'ordre de précédence
• <?php <?php
trait ezcReflectionReturnInfo { class Base {
function getReturnType() { /*1*/ } public function sayHello() {
function getReturnDescription() { / echo 'Hello ';
*2*/ }
}
}
}
class ezcReflectionMethod extends Refle trait SayWorld {
ctionMethod { public function sayHello() {
use ezcReflectionReturnInfo; parent::sayHello();
/* ... */ echo 'World!';
} }
}
class ezcReflectionFunction extends Ref class MyHelloWorld extends Base {
lectionFunction { Précédence use SayWorld;
use ezcReflectionReturnInfo;
/* ... */ }
} $o = new MyHelloWorld();
?> $o->sayHello();
?>
Une méthode héritée depuis la classe de

base est écrasée par celle provenant du
Trait.
Ce n'est pas le cas des méthodes réelles,
écrites dans la classe de base. L'exemple ci-dessus va afficher :
Hello World!
Mot-clé "final"
Empêche les classes filles de surcharger une méthode, lorsque la définition de cette
dernière est préfixée par le mot-clé "final".
Si la classe elle-même est définie comme finale, elle ne pourra pas être étendue.
Exemple #1 Exemple de méthode finale Exemple #2 Exemple de classe finale
<?php <?php
class BaseClass { final class BaseClass {
public function test() { public function test() {
echo "BaseClass::test() appelée\n"; echo "BaseClass::test() appelée\n";
} }
final public function moreTesting() {
echo "BaseClass::moreTesting() appelée\n"; // Ici, peu importe si vous spécifiez la
} fonction en finale ou pas
} final public function moreTesting() {
class ChildClass extends BaseClass { echo "BaseClass::moreTesting() appel
public function moreTesting() { ée\n";
echo "ChildClass::moreTesting() appelée\n"; }
} }
} class ChildClass extends BaseClass {
// Résultat : Fatal error: Cannot override final }
//method BaseClass::moreTesting() // Résultat : Fatal error: Class ChildClass
?> may not inherit //from final class (BaseCl
ass)
?>
Les structures de contrôle
du langage
PHP
L'instruction if
• Elle permet l'exécution conditionnelle d'une partie de code.
<?php
if ($a > $b)
echo "a est plus gran
d que b";
?>
<?php
if( $a == 1 || $a == 2 ) { <?php
if( $b == 3 || $b == 4 if( ($a==1 || $a==2) && ($b==3 || $b==4) &&
) { ($c==5 || $c==6) ) {
if( $c == 5 || //do that something here.
$ d == 6 ) { }
//Do ?>
something here.
}
}
}
L'instruction else
• Souvent, vous voulez exécuter une instruction si une condition est remplie,
et une autre instruction si cette condition n'est pas remplie.
<?php
if ($a > $b) {
echo "a est plus grand que b";
} else {
echo "a est plus petit que b";
}
?>
• elseif, comme son nom l'indique, est une combinaison de if et de else
<?php
if ($a > $b) {
echo "a est plus grand que b";
} elseif ($a == $b) {
echo "a est égal à b";
} else {
echo "a est plus petit que b";
}
?>
Note: A noter que elseif et else if sont traités de la même façon seulement quand des accolades sont utilisées,
Syntaxe alternative
• PHP propose une autre manière de rassembler des instructions à l'intérieur
d'un bloc, pour les fonctions de contrôle if, while, for, foreach et switch.
• Dans chaque cas, le principe est de remplacer l'accolade d'ouverture par
deux points (:) et l'accolade de fermeture par, respectivement, endif;,
endwhile;, endfor;, endforeach;, ou endswitch;.
<?php
if ($a == 5):
echo "a égale 5";
<?php if echo "...";
elseif ($a == 6):
($a == 5): ?> echo "a égale 6";
A égal 5 echo "!!!";
<?php endif; ?> else:
echo "a ne vaut ni 5 ni 6";
endif;
?>
L'instruction while
• La boucle while est le moyen le plus simple d'implémenter une boucle
en PHP. Cette boucle se comporte de la même manière qu'en C.
L'exemple le plus simple d'une boucle while est le suivant :
<?php
/* exemple 2 */
/* exemple 1 */
$i = 1;
$i = 1;
while ($i <= 10):
while ($i <= 10) {
echo $i;
echo $i++; /* La valeur affichée est $
$i++;
i avant l'incrémentation
endwhile;
(post-
?>
incrémentation) */
}
do-while ¶
• Les boucles do-while ressemblent beaucoup aux boucles while, mais
l'expression est testée à la fin de chaque itération plutôt qu'au début.
<?php
$i = 0;
do {
echo $i;
} while ($i > 0);
?>
for
• Les boucles for sont les boucles les plus complexes en PHP. Elles
fonctionnent comme les boucles for du langage C(C++).
for (expr1; expr2; expr3) commandes
La première expression (expr1) est évaluée (exécutée), quoi
qu'il arrive au début de la boucle.
• Considérons les exemples suivants. Tous affichent les nombres entiers de 1 à 10 :

<?php /* exemple 2 */ /* exemple 3 */
/* exemple 4 */
$i = 1;
/* exemple 1 */
for ($i = 1; ; $i++ for (; ; ) {
for ($i = 1, $j = 0;
) { if ($i > 10) {
for ($i = 1; $i <= $i <= 10; $j += $i,
if ($i > 10) { break;
10; $i++) { print $i, $i++);
break; }
?>
echo $i; } echo $i;
} echo $i; $i++;
} }
foreach
• La structure de langage foreach fournit une façon simple de parcourir des
tableaux.
• foreach ne fonctionne que pour les tableaux et les objets, et émettra une
erreur si vous tentez de l'utiliser sur une variable de type différent ou une
variable non initialisée. Il existe deux syntaxes :
foreach (array_expression as $value){
//commandes
}
Note:
foreach n'accepte pas l'opérateur de suppression
foreach (array_expression as $key => $value) des erreurs @.
{
//commandes
}
break
• L'instruction break permet de sortir d'une structure for, foreach, while, do-while ou
switch.
• break accepte un argument numérique optionnel qui vous indiquera combien de
structures emboîtées doivent être interrompues.
La valeur par défaut est 1, seulement la structure emboitée immédiate est interrompue.
/* Utilisation de l'argument optionnel. */

<?php
$i = 0;
$arr = array('un', 'deux', 'trois', 'quatre',
while (++$i) {
'stop', 'cinq');
switch ($i) {
foreach ($arr as $val) {
case 5:
if ($val == 'stop') {
echo "At 5 \n";
break;
break 1; /* Termine uniquement le switch.
/* Vous pourriez aussi utiliser 'break 1;'
*/
ici. */
case 10:
}
echo "At 10; quitting \n";
echo "$val \n";
break 2; /* Termine le switch et la boucl
}
e while. */
/* Utilisation de l'argument optionnel. */
default:
break; } } ?>
continue
• L'instruction continue est utilisée dans une boucle afin de sauter les
instructions de l'itération courante et de continuer l'exécution à la
condition de l'évaluation et donc, de commencer la prochaine
itération.
• Continue accepte un argument numérique optionnel qui vous
indiquera combien de structures emboîtées doivent être éludées.
• La valeur par défaut est 1, ce qui revient à aller directement à la fin de
la boucle courante.
Exemple
$i = 0;
while ($i++ < 5) {
<?php echo "Dehors \n";
foreach ($arr as $key => $value) { while (1) {
if (!($key % 2)) { echo "Milieu \n";
// évite les membres pairs while (1) {
continue; echo "Intérieur \n";
} continue 3;
do_something_odd($value); }
} echo "Ceci n'est jamais atteint. \n";
}
echo "Ceci non plus. \n";
}
?>
switch
L'instruction switch équivaut à une série d'instructions if.
Les deux exemples suivants sont deux manières différentes
d'écrire la même chose, l'une en utilisant une séries de if, et Instruction switch utilisant une chaîne
l'autre en utilisant l'instruction switch : de caractères
<?php
switch ($i) {
switch ($i) { case "apple":
case 0: echo "i est une pomme";
<?php echo "i égal 0"; break;
if ($i == 0) { break; case "bar":
echo "i égal 0"; case 1: echo "i est une barre";
} elseif ($i == 1) { echo "i égal 1"; break;
echo "i égal 1"; break; case "cake":
} elseif ($i == 2) { case 2: echo "i est un gateau";
echo "i égal 2"; echo "i égal 2"; break;
} break; }
} ?>
?>
return
• return retourne le contrôle du programme au module appelant.
L'exécution reprend alors à l'instruction suivante de l'invocation du
module.
• Si appelée depuis une fonction, la commande return termine
immédiatement la fonction, et retourne l'argument qui lui est passé..
require et include
• L'instruction de langage require inclut et exécute le fichier spécifié en
argument.
• require est identique à include mis à part le fait que lorsqu'une erreur
survient, il produit également une erreur fatale de niveau
E_COMPILE_ERROR.
• require stoppera le script alors que include n'émettra qu'une alerte
de niveau E_WARNING, ce qui permet au script de continuer.
require_once
• L'instruction require_once est identique à require mis à part que PHP vérifie si le
fichier a déjà été inclus, et si c'est le cas, ne l'inclut pas une deuxième fois.
include_once
L'instruction include_once inclut et évalue le fichier spécifié durant l'exécution du script.

Le comportement est similaire à include, mais la différence est que si le code a déjà été inclus, il ne le sera pas
une seconde fois, et include_once retourne TRUE.
Comme son nom l'indique, le fichier sera inclut une seule fois.
Les fonctions définies par l'utilisateur
• Une fonction peut être définie en utilisant la syntaxe suivante :
<?php
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
echo "Exemple de fonction.\n";
return $retval;
}
?>
Les noms de fonctions suivent les mêmes règles que les autres
labels en PHP.
Un nom de fonction valide commence par une lettre ou un
souligné, suivi par un nombre quelconque de lettres, de nombres
ou de soulignés.
Les arguments de fonction
• Les arguments sont des informations peuvent être passées à une
fonction sous forme de liste, dont chaque expression est séparée par une
virgule. Les arguments seront évalués depuis la gauche vers la droite.
• PHP supporte le passage d'arguments par valeur (comportement par défaut),

• le passage par référence, et des valeurs d'arguments par défaut.
• Une liste variable d'arguments est également supportée.

Exemple #1 Nombre variable d'arguments
sous forme de tableau
<?php
function takes_array($input)
{
echo "$input[0] + $input[1] = ", $in
put[0]+$input[1];
}
?>
Valeur par défaut des arguments
• Vous pouvez définir comme en C++ des valeurs par défaut pour les arguments
de type scalaire :
<?php L'exemple ci-dessus va afficher :
function servir_cafe ($type = "cappuccino")
Servir un cappuccino.
{
Servir un .
return "Servir un $type.\n";
Servir un espresso.
}
echo servir_cafe();
echo servir_cafe(null);
echo servir_cafe("espresso");
?>

Chapitre 4 Langage de Programmation PHP

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 4 Langage de Programmation PHP

Transféré par

Droits d'auteur :

Formats disponibles

langage

• PHP est l'acronyme de "PHP : Hypertext Preprocessor"

• PHP est un langage de script open source largement utilisé

• Les scripts PHP sont exécutés sur le serveur

• PHP est gratuit à télécharger et à utiliser

forme de HTML brut

• Les fichiers PHP ont l'extension " .php"

Remarque les commentaire en php sont comme dans le langage de programmation c

Le script ci-dessus va afficher la valeur 3. En déclarant globales les variables

print "$a\n"; // affiche 3

print "$a\n"; // affiche 4

$a === $b Identique TRUE si $a est égal à $b et qu'ils sont de même type.

$a != $b Différent TRUE si $a est différent de $b après le transtypage.

$a <> $b Différent TRUE si $a est différent de $b après le transtypage.

$a <= $b Inférieur ou égal TRUE si $a est plus petit ou égal à $b.

$a >= $b Supérieur ou égal TRUE si $a est plus grand ou égal à $b.

// La ligne ci-dessus est identique à la condition suivante :

// le code ci-dessus est équivalent à cette structure if/else

Exemple Nom Résultat

var_dump($a instanceof MaClasse);

L'exemple ci-dessus va afficher :

du nom de la classe. Suit une paire class SimpleClass

// Ceci peut également être réalisé avec une variable :

$instance = new SimpleClass();

$obj = new Foo();

que dans la classe parente.

$extended = new ExtendClass(); Classe étendue

de type, suivi d'une déclaration classique de variable.

doit pouvoir être évaluée pendant la compilation du code.

la syntaxe -> (opérateur de l'objet) : $this->property

PHP permet de déclarer des constructeurs pour les classes.

Les classes qui possèdent une méthode constructeur appellent cette

méthode à chaque création d'une nouvelle instance de l'objet.

Si vous voulez utiliser un constructeur parent, il sera nécessaire de faire

appel à parent::__construct() depuis le constructeur enfant

<?php public function baz(Test $other)

L'exemple ci-dessus va afficher :

Exemple #2 :: depuis la définition de la classe

méthode - elles ne peuvent définir son implémentation.

Exemple #1 Exemple de classe abstraite

class ConcreteClass2 extends AbstractClass

L'exemple ci-dessus va afficher :

public function setVariable($name, $var)

Une méthode héritée depuis la classe de

• Considérons les exemples suivants. Tous affichent les nombres entiers de 1 à 10 :

/* Utilisation de l'argument optionnel. */

L'instruction include_once inclut et évalue le fichier spécifié durant l'exécution du script.

• PHP supporte le passage d'arguments par valeur (comportement par défaut),

• Une liste variable d'arguments est également supportée.

Vous aimerez peut-être aussi