PHP 7.

PHP
Installation des serveurs (Wamp, Mamp, Lamp, Xamp)

Première page PHP
Syntaxe
Les variables
Les opérateurs
Les tableaux
Les structures de contrôle
Les fonctions
Les variables prédéfinies
Travail avec les fichiers
Patrice Pegaule / 2021

Pourquoi PHP ?
PHP: Hypertext Preprocessor (PHP) est un langage de script libre, très
populaire et open source. Les scripts PHP sont exécutés sur le serveur.
PHP est capable de :
‣ Génération de contenu de page dynamique
‣ Création, ouverture, lecture, écriture, suppression et fermeture de
fichiers sur le serveur
‣ Collecte des données de formulaire
‣ Ajout, suppression et modification des informations stockées dans
votre base de données
‣ contrôler l'accès des utilisateurs
‣ chiffrer les données
‣ et beaucoup plus …
Patrice Pegaule - patrice.pegaule@3il.fr 2

Pourquoi PHP ?
PHP fonctionne sur de nombreuses plateformes variées, y compris
Windows, Linux, Unix, Mac OS X, etc.
PHP est compatible avec presque tous les serveurs modernes, tels
qu'Apache, IIS et plus encore.
PHP supporte un large éventail de bases de données.
PHP est gratuit!

Installation des serveurs
(WAMP)

! Pourquoi utiliser un serveur ?
‣ Seul le serveur sait interpréter du PHP
! Que doit-on installer ?
‣ Apache : pour communiquer avec le navigateur
‣ PHP : pour interpréter les fichiers .php
‣ MySQL : pour utiliser la Base de Données
! Ces trois outils, couplés à Linux, Windows ou Mac OS, forment une
solution LAMP, WAMP ou MAMP

! LAMP, WAMP, MAMP, XAMP:
‣ regroupent tous ces serveurs
‣ intègrent aussi des outils d’administration
‣ sont gratuits
! WAMP n'est pas obligatoire ! On pourrait installer chaque serveur
séparément – il est d'ailleurs bon de savoir le faire.

! Installation de WAMP
‣ Télécharger WAMP depuis www.wampserver.com
! Questions posées par l'installeur :
‣ « Lancer les services automatiquement » : Oui
‣ « Dossier racine » : par défaut
‣ « Serveur SMTP » : par défaut (localhost)
‣ « Adresse email » : défaut
‣ « Navigateur par défaut » : Si Firefox, aller chercher firefox.exe,
sinon laisser explorer.exe (Mauvaise idée)
‣ « Alerte du pare-feu » : débloquer Apache

! Tester l'installation
‣ Tapez « localhost » dans la Barre d'adresse de votre navigateur
‣ La page d'accueil de WAMP doit s'afficher
! L'interface de WAMP :
‣ Sert à démarrer ou arrêter les serveurs
‣ Réside ensuite dans la Zone de notification
‣ Contient des raccourcis vers les outils d'administration :
phpMyAdmin
‣ Permet également de configurer Apache et PHP

Première page PHP
! Explication du fonctionnement
‣ Schéma d’une requête statique

Première page PHP
! Explication du fonctionnement : côté client
‣ Schéma d'une requête dynamique :

Première pages PHP
! Arborescence des dossiers
‣ Les fichiers PHP doivent être visibles par Apache
‣ Ils faut donc qu'ils soient dans le dossier WebRoot d'Apache
(par défaut C:\wamp\www)
‣ Créez un dossier test dans le dossier www
! Premier fichier PHP
‣ Ouvrez une page HTML avec Atom ou un autre éditeur
‣ Enregistrez-la dans www\test\index.php

Première pages PHP
! Affichage de la page
‣ Ouvrez votre navigateur
‣ Tapez l’adresse : http://localhost/test/index.php
‣ La page HTML, servie par Apache, s’affiche.

Première pages PHP
! Inclusion d'un code PHP
‣ Ouvrez le fichier www\test\index.php avec ATOM
‣ Rajouter dans le <body> la ligne :
<p>Date : <?php echo date("d-m-Y H:i:s") ?></p>
‣ Sauvegarder la page
! Affichage
‣ Ouvrir le navigateur pour tester le résultat
‣ La page doit comporter une ligne :
Date : 14-11-2006 18:15:42
‣ Si on rafraîchit la page (F5), la ligne se met à jour

Première page PHP
! Explication du fonctionnement : côté serveur
‣ <p>Date : <?php echo date("d-m-Y H:i:s") ?></p>
‣ La fonction date() affiche la date actuelle
‣ L’instruction echo sert à afficher le résultat

Variables

Variables
Les variables sont utilisées comme "conteneurs" dans lesquels nous
stockons des informations.
Une variable PHP commence par un signe dollar ($), suivi du nom de
la variable.
$variable_name = value;
Règles pour les variables PHP:

- Un nom de variable doit commencer par une lettre ou un trait de
soulignement
- Un nom de variable ne peut pas commencer par un nombre
- Un nom de variable ne peut contenir que des caractères
alphanumériques et des traits de soulignement (A-z, 0-9 et _)
- Les noms de variables sont sensibles à la casse ($ name et $ NAME
sont deux variables différentes)

Variables
<?php
$name = 'John';
$age = 25;
echo $name; // Résultat ‘John’
?>
Dans l'exemple ci-dessus, notez que nous n'avions pas besoin de dire à PHP
quel type de données est la variable.
PHP convertit automatiquement la variable en type de données correct, en
fonction de sa valeur.
Contrairement à d'autres langages de programmation, PHP n'a pas de

commande pour déclarer une variable. Il est créé au moment où vous lui
attribuez d'abord une valeur.

Variables
Constantes
Les constantes sont similaires aux variables sauf qu'elles ne peuvent
pas être modifiées ou indéfinies après leur définition.
Commencez le nom de votre constante avec une lettre ou un trait de
soulignement.
Pour créer une constante, utilisez la fonction define ():
define(name, value, case-insensitive)
Paramètres:
name: Spécifie le nom de la constante;
value: Spécifie la valeur de la constante;
case-insensitive: Indique si le nom de la constante doit être insensible
à la casse. La valeur par défaut est false;

Variables
L'exemple ci-dessous crée une constante avec un nom sensible à la
casse:
<?php
define("MSG", "Hi 3il !");
echo MSG;
// Résultat "Hi 3il !"
?>
L'exemple ci-dessous crée une constante avec un nom insensible à la casse:

<?php
define("MSG", " "Hi 3il !", true);
echo msg;
// Résultat "Hi 3il !"
?>
Aucun signe dollar ($) n'est nécessaire avant le nom de la constante.
Variables
Types de données
Les variables peuvent stocker une variété de types de données.
Types de données pris en charge par PHP: String, Integer, Float,
Booléen, Array, Object, NULL, Resource.
Chaîne PHP
Une chaîne est une séquence de caractères, comme "Hello world!"
Une chaîne peut être n'importe quel texte dans un ensemble de
guillemets simples ou doubles.
<? php
$ string1 = "Bonjour tout le monde!"; //double quote
$ string2 = 'Bonjour tout le monde!'; // guillemets simples
?>
Vous pouvez joindre deux chaînes à l'aide de l'opérateur de concaténation point (.)
Par exemple: echo $ s1. $ s2
Variables
PHP Interger
Un nombre entier est un nombre entier (sans décimales) qui doit
correspondre aux critères suivants:
- Il ne peut pas contenir de virgules ou d'espaces
- Il ne doit pas avoir un point décimal
- Il peut être positif ou négatif
<? php
$ int1 = 42; // nombre positif
$ int2 = -42; // nombre négatif
?>

Variables
PHP Float
Un float ou un nombre à virgule flottante est un nombre qui inclut un
point décimal.
<? php
$ x = 42.168;
?>
PHP Boolean
Un booléen représente deux états possibles: VRAI ou FAUX.
<? php
$ x = vrai; $ y = faux;
?>
A noter: Les booléens sont souvent utilisés dans les tests conditionnels.

Variables
La plupart des types de données peuvent être utilisés en combinaison
les uns avec les autres. Dans cet exemple, string et integer sont mis
ensemble pour déterminer la somme de deux nombres.
<?php
$str = "10";
$int = 20;
$sum = $str + $int;
echo ($sum); // Sortie 30
?>

Variables
Variables Scope
Les variables PHP peuvent être déclarées n'importe où dans le script.

La portée d'une variable est la partie du script dans laquelle la
variable peut être référencée ou utilisée.
Les étendues de variables les plus utilisées de PHP sont locales,

globales.
Une variable déclarée en dehors d'une fonction a une portée
globale.
Une variable déclarée dans une fonction a une portée locale et n'est
accessible que dans cette fonction.

Variables
<?php
$name = 'David';
function getName() {
echo $name;
}
getName(); // Error: Undefined variable: name
?>
Ce script produira une erreur, car la variable $name a une portée
globale et n'est pas accessible dans la fonction getName().

Variables
Le mot-clé global
Le mot clé global est utilisé pour accéder à une variable globale
depuis une fonction.
Pour ce faire, utilisez le mot-clé global dans la fonction, avant les
variables.
<?php
$name = 'David';
function getName() {
global $name;
echo $name;
}
getName(); //Outputs 'David'
?>

Variables
Variable variables
Avec PHP, vous pouvez utiliser une variable pour spécifier le nom
d'une autre variable.
Ainsi, une variable variable traite la valeur d'une autre variable
comme son nom.
Par exemple:
<?php
$a = 'hello';
$hello = "Hi!";
echo $$a; // Sorties ‘Hi!'
?>
$$a est une variable qui utilise la valeur d'une autre variable, $a, comme nom.
La valeur de $a est égale à "bonjour". La variable résultante est $hello, qui
contient la valeur "Hi!".

Les opérateurs

Les opérateurs
Les opérateurs effectuent des opérations sur des variables et des
valeurs.
Les opérateurs arithmétiques travaillent avec des valeurs numériques

pour effectuer des opérations arithmétiques communes.

Les opérateurs
Example:
<?php
$num1 = 8;
$num2 = 6;
echo $num1 + $num2; // Addiction : 14

echo $num1 - $num2; // Soustraction : 2
echo $num1 * $num2; // Multiplication : 48
echo $num1 / $num2; // Division : 1.33333333333
?>

Les opérateurs
Modulo
L’opérateur de modulo, représenté par le signe %, renvoie le reste de
la division du premier opérande par le deuxième opérande:
<? php
$ x = 14;
$ y = 3;
echo $ x% $ y; // Sortie 2
?>
A noter : Si vous utilisez des nombres à virgule flottante avec

l'opérateur de modulo, ils seront convertis en entiers avant l'opération.

Les opérateurs
Increment & Decrement
Les opérateurs d'incrémentation sont utilisés pour incrémenter la

valeur d'une variable.
Les opérateurs de décrémentation sont utilisés pour décrémenter la
valeur d'une variable.
$ x ++; // équivalent à $ x = $ x + 1;
$ x--; // équivalent à $ x = $ x-1;

Les opérateurs
Increment & Decrement
Les opérateurs d'incrémentation et de décrémentation précèdent ou

suivent une variable.
$ x ++; // post-incrément
$ x--; // post-décrément
++ $ x; // pré-incrément
- $ x; // pré-décrément
La différence est que le post-incrément renvoie la valeur d'origine
avant de modifier la variable, tandis que le pré-incrément modifie
d'abord la variable, puis renvoie la valeur.
Exemple:
$ a = 2; $ b = $ a ++; // $ a = 3, $ b = 2
$ a = 2; $ b = ++ $ a; // $ a = 3, $ b = 3

Les opérateurs
Opérateurs d'affectation
Les opérateurs d'affectation sont utilisés pour écrire des valeurs dans
des variables.
$num1 = 5;
$num2 = $num1; // $ num1 et $ num2 contiennent la valeur de 5.
<?php
$x = 50;
$x += 100;
echo $x;
// Sortie : 150
?>

Les opérateurs
Opérateurs de comparaison
Les opérateurs de comparaison comparent deux valeurs (nombres ou
chaînes).
Les opérateurs de comparaison sont utilisés dans les instructions
conditionnelles et évaluent TRUE ou FALSE.

Les opérateurs
Opérateurs de comparaison
Opérateurs de comparaison supplémentaires:

Les opérateurs
Opérateurs logiques
Les opérateurs logiques sont utilisés pour combiner des instructions
conditionnelles.

Les opérateurs
Opérateurs logiques
Les opérateurs logiques sont utilisés pour combiner des instructions
conditionnelles.

Tableaux

Tableaux
Tableaux (Arrays)
Un tableau est une variable spéciale qui peut contenir plusieurs
valeurs à la fois.
Si vous avez une liste d'éléments (une liste de noms, par exemple), les
stocker dans des variables simples ressemblerait à ceci:
$name1 = "David";
$name2 = "Amy";
$name3 = "John";
Que faire si vous avez 100 noms sur votre liste?
Créer un tableau !

Tableaux
Tableaux numériques
Les tableaux numériques ou indexés associent un index numérique à
leurs valeurs.
L'index peut être affecté automatiquement (l'index commence
toujours à 0), comme ceci:
$names = array("David", "Amy", "John");

Tableaux
Vous pouvez également affecter votre index manuellement.
$names[0] = "David";
$names[1] = "Amy";
$names[2] = "John";
Nous avons défini un tableau appelé $names qui stocke 3 valeurs.
Vous pouvez accéder aux éléments du tableau à travers leurs index.
echo $names [1]; // Sortie "Amy"
Attention : Rappelez-vous que le premier élément d'un tableau a
l'index de 0, pas 1.

Tableaux
Numeric Arrays
Vous pouvez regrouper des entiers, des chaînes et d'autres types de
données dans un tableau.
Exemple:
<?php
$myArray[0] = "John";
$myArray[1] = "<strong>PHP</strong>";
$myArray[2] = 21;
echo "$myArray[0] is $myArray[2] and knows $myArray[1]";

// Sortie "John is 21 and knows PHP"
?>

Tableaux
Tableaux associatifs
Les tableaux associatifs sont des tableaux qui utilisent des clés
nommées que vous leurs attribuez.
Il existe deux façons de créer un tableau associatif:
$people = array("David"=>"27", "Amy"=>"21", "John"=>"42");
// ou
$people['David'] = "27";
$people['Amy'] = "21";
$people['John'] = "42";
Dans le premier exemple, notez l'utilisation des signes => dans
l'affectation des valeurs aux clés nommées.

Tableaux
Tableaux associatifs
Utilisez les clés nommées pour accéder aux membres du tableau.
$people = array("David"=>"27", "Amy"=>"21", "John"=>"42");
echo $people['Amy']; // Sortie 21"

Tableaux
Tableaux multidimensionnels
Un tableau multidimensionnel contient un ou plusieurs tableaux.
La dimension d'un tableau indique le nombre d'indices dont vous
auriez besoin pour sélectionner un élément.
- Pour un tableau à deux dimensions, vous avez besoin de deux
indices pour sélectionner un élément
- Pour un tableau en trois dimensions, vous avez besoin de trois indices
pour sélectionner un élément
Les tableaux de plus de trois niveaux de profondeur sont difficiles à
gérer.

Tableaux
Tableaux multidimensionnels
Créons un tableau à deux dimensions qui contient 3 tableaux:
$people = array(
'online'=>array('David', 'Amy'),
'offline'=>array('John', 'Rob', 'Jack'),
'away'=>array('Arthur', 'Daniel')
);
Maintenant, le tableau $people à deux dimensions contient trois
tableaux, et il a deux indices: ligne et colonne.
Pour accéder aux éléments du tableau $people, nous devons pointer
vers les deux indices.
echo $people['online'][0]; //Outputs "David"
echo $people['away'][1]; //Outputs « Daniel"
Les tableaux du tableau multidimensionnel peuvent être à la fois numériques et
associatifs.
Structures de contrôle

Expressions conditionnelles
Les instructions conditionnelles effectuent différentes actions pour
différentes décisions.
L'instruction if else est utilisée pour exécuter un certain code si une
condition est vraie et un autre code si la condition est fausse.
Syntaxe:
Si (condition) {
code à exécuter si la condition est vraie;
}
Sinon {
code à exécuter si la condition est fausse;
}
Vous pouvez également utiliser l'instruction if sans l'instruction else, si vous
n'avez rien à faire, dans le cas où la condition est fausse.

If Else
L'exemple ci-dessous affichera le plus grand nombre des deux.
<?php
$x = 10;
$y = 20;
if ($x >= $y) {
echo $x;
}
else {
echo $y; // Sortie "20"
}
?>

La déclaration Elseif
Utilisez l'instruction if ... elseif ... else pour spécifier une nouvelle
condition à tester, si la première condition est fausse.
Syntaxe:
if (condition) {
} elseif (condition) {
} else {
code à exécuter si la condition est fausse;
}
Vous pouvez ajouter autant d'instructions elseif que vous le souhaitez.
Notez simplement que l'instruction elseif doit commencer par une
instruction if.

La déclaration Elseif
Par exemple:
<? php
$age = 21;
if ($age<=13) {
echo "Enfant";
} elseif ($age>13 && $age<19) {
echo "Adolescent";
} autre {
echo "Adulte"; // Sorties "Adulte"
}
?>
Nous avons utilisé l'opérateur logique AND (&&) pour combiner les
deux conditions et vérifier si $ age se situe entre 13 et 19.

Boucles (Loops)
Lorsque vous écrivez du code, vous pouvez souhaiter que le même
bloc de code s'exécute encore et encore. Au lieu d'ajouter plusieurs
lignes de code presque égales dans un script, nous pouvons utiliser
des boucles pour effectuer une tâche comme celle-ci.
La boucle while exécute un bloc de code tant que la condition
spécifiée est vraie.
Syntaxe:
while (la condition est vraie) {
code à exécuter;
}
Si la condition ne devient jamais fausse, l'instruction continuera à
s'exécuter indéfiniment.

The while Loop
L'exemple ci-dessous définit d'abord une variable $ i à un ($ i = 1).
Ensuite, la boucle while s'exécute tant que $ i est inférieur à sept ($ i
<7). $ i augmentera d'une unité chaque fois que la boucle sera
exécutée ($ i ++):
$i = 1;
while ($i < 5) {
echo « La valeur est $i <br />";
$i++;
}
Résultat :
La valeur est 1
La valeur est 2
La valeur est 3
La valeur est 4
La boucle do ... while
La boucle do ... while exécute toujours le bloc de code une fois,
vérifie la condition et répète la boucle tant que la condition spécifiée
est vraie.
Syntaxe:
do {
code à exécuter;
} while (la condition est vraie);
Indépendamment du fait que la condition soit vraie ou fausse, le

code sera exécuté au moins une fois, ce qui pourrait être nécessaire
dans certaines situations.

The do… while Loop
L'exemple ci-dessous va écrire une sortie, puis incrémenter la variable
$ i par un. Ensuite, la condition est vérifiée et la boucle continue de
s'exécuter, tant que $ i est inférieur à 7.
$i = 5;
do {
echo "Le nombre est " . $i . "<br/>";
$i++;
} while($i<5);
Résultat dans le navigateur : Le nombre est 5
Le nombre est 6
Notez que dans une boucle while, la condition est testée APRES
l'exécution des instructions dans la boucle. Cela signifie que la boucle
while exécutera ses instructions au moins une fois, même si la
condition est fausse la première fois.
La boucle for
La boucle for est utilisée lorsque vous savez à l'avance combien de
fois le script doit être exécuté.
pour (init; test; increment) {
code à exécuter;
}
init: Initialise la valeur du compteur de boucle
test: Evalue chaque fois que la boucle est itérée, continue si elle est
est vraie (true) et se termine si elle est fausse (false).
increment: Augmente la valeur du compteur de boucle
Chacune des expressions de paramètre peut être vide ou contenir
plusieurs expressions séparées par des virgules.
Dans l'instruction for, les paramètres sont séparés par des points-
virgules.

La boucle for
L'exemple ci-dessous affiche les nombres de 0 à 5:
for ($ a = 0; $a < 6; $a++) {
echo "Valeur de a : ". $a. "<br />"
}
La boucle for de l'exemple ci-dessus définit d'abord la variable $a à 0,
puis vérifie la condition ($a < 6). Si la condition est vraie, elle exécute
le code. Après cela, elle incrémente $a ($a++).

La boucle foreach
La boucle foreach fonctionne uniquement sur les tableaux et est
utilisée pour faire une boucle sur chaque paire clé / valeur d'un
tableau.
Il y a deux syntaxes:
foreach (tableau en $ valeur) {
code à exécuter;
}
ou
foreach (tableau en $ key => valeur $) {
code à exécuter;
}

La première forme boucle sur le tableau. À chaque itération, la valeur
de l'élément en cours est assignée à $value, et le pointeur du tableau
est déplacé de un, jusqu'à ce qu'il atteigne le dernier élément du
tableau.
Le second formulaire affectera en outre la clé de l'élément courant à
la variable $key à chaque itération.
L'exemple suivant illustre une boucle qui génère les valeurs du
tableau $names.
$names = array("John", "David", "Amy");
foreach ($names as $name) {
echo $name.'<br />';
}
// John
// David
// Amy

L'instruction switch
L'instruction switch est une alternative à l'instruction if-elseif-else.
Utilisez l'instruction switch pour sélectionner l'un des blocs de code à
exécuter.
switch (n) {
case value1:
//code à exécuter si n=value1
break;
case value2:
//code à exécuter si n=value2
break;
default:
// code à exécuter si n est différent de toutes les étiquettes
}

$today = 'Tue';
switch ($today) {
case "Mon":
echo "Today is Monday.";
break;
case "Tue":
echo "Today is Tuesday.";
break;
…
case "Sun":
echo "Today is Sunday.";
break;
default:
echo "Invalid day.";
}
//Sortie : "Today is Tuesday."

L'instruction switch : default
L'instruction par défaut est utilisée si aucune correspondance n'est
trouvée.
$x=5;
switch ($x) {
case 1:
echo "One";
break;
case 2:
echo "Two";
break;
default:
echo "No match";
} // Sortie : "No match »
L'instruction par défaut est facultative, elle peut donc être omise.
Si vous ne spécifiez pas l'instruction break, PHP continue à exécuter les
instructions qui suivent le cas jusqu'à ce qu'il trouve une pause. Vous
pouvez utiliser ce comportement si vous devez obtenir la même sortie
pour plusieurs cas.

$day = 'Wed';
switch ($day) {
case 'Mon':
echo 'First day of the week';
break;
case 'Tue':
case 'Wed':
case ‘Thu':
echo 'Working day';
break;
case 'Fri':
echo 'Friday!';
break;
default:
echo 'Weekend!';
} //Sortie : "Working day"
L'exemple ci-dessus aura la même sortie si $ day est égal à 'Tue', 'Wed' ou 'Thu'.

L’instruction break
Comme indiqué dans la leçon précédente, l'instruction break est
utilisée pour sortir du commutateur lorsqu'une requête est trouvée.
Si la pause est absente, le code continue à fonctionner. Par exemple:
$ x = 1;
commutateur ($ x) {
cas 1:
écho "One";
cas 2:
écho "Deux";
cas 3:
écho "Trois";
défaut:
echo "Aucune correspondance";
}. // Sortie : "OneTwoThreeNo match »
La déclaration continue
Lorsqu'elle est utilisée dans une structure en boucle, l'instruction
continue permet d'ignorer ce qui reste de l'itération de la boucle en
cours. Il continue ensuite l'exécution à l'évaluation de l'état et passe
au début de l'itération suivante.
L'exemple suivant ignore les nombres pairs dans la boucle for:
for ($i=0; $i<10; $i++) {
if ($i%2==0) {
continue;
}
echo $i . ' ';
} // Sortie: 1 3 5 7 9
Vous pouvez utiliser l'instruction continue avec toutes les structures en
boucle.

include
Les instructions include et require permettent d'insérer le contenu d'un
fichier PHP dans un autre fichier PHP, avant que le serveur ne
l'exécute.
Y compris les fichiers permet d'économiser un peu de travail. Vous
pouvez créer un en-tête, un pied de page ou un fichier de menu
standard pour toutes vos pages Web. Ensuite, lorsque l'en-tête
nécessite une mise à jour, vous pouvez uniquement mettre à jour le
fichier d'inclusion d'en-tête.
Supposons que nous avons un fichier d'en-tête standard appelé
header.php.
<?php
echo '<h1>Welcome</h1>';
?>

Utilisez l'instruction include pour inclure le fichier d'en-tête dans une
page.
<html>
<head>
<title>Mon Site Web</title>
</head>
<body>
<?php include 'header.php'; ?>
<p>Lorem ipsum …</p>
<p>Lorem ipsum …</p>
</body>
</html>

include
En utilisant cette approche, nous avons la possibilité d'inclure le
même fichier header.php dans plusieurs pages.
<html>
<body>
<?php include 'header.php'; ?>
<p>This is a paragraph</p>
</body>
</html>
Les fichiers sont inclus en fonction du chemin du fichier.
Vous pouvez utiliser un chemin absolu ou relatif pour spécifier quel
fichier doit être inclus.

inclure vs require
L'instruction require est identique à include, l'exception étant que, en
cas d'échec, elle génère une erreur fatale.
Lorsqu'un fichier est inclus à l'aide de l'instruction include, mais que
PHP ne parvient pas à le trouver, le script continue à s'exécuter.
Dans le cas de require, le script va cesser d'exécuter et produire une
erreur.
Conseil : Utilisez require lorsque le fichier est requis pour que

l'application s'exécute.
Utilisez include lorsque le fichier n'est pas requis. L'application doit
continuer, même si le fichier n'est pas trouvé.

Fonctions

Fonctions
Les fonctions
‣ Une fonction est un bloc d'instructions pouvant être utilisé de
manière répétée dans un programme.
‣ Une fonction ne s'exécute pas immédiatement lorsqu'une page est
chargée. Il sera exécuté par un appel à la fonction.
Une déclaration de fonction définie par l'utilisateur commence par le

mot fonction:
function functionName () {
// code à exécuter
}
A noter : Un nom de fonction peut commencer par une lettre ou un
trait de soulignement, mais pas avec un nombre ou un symbole
spécial.

Fonctions
Les fonctions
Dans l'exemple ci-dessous, nous créons la fonction sayHello().
L'accolade d'ouverture ({) indique que c'est le début du code de
fonction, tandis que l'accolade de fermeture (}) indique que c'est la
fin.
Pour appeler la fonction, il suffit d'écrire son nom:
function sayHello() {
echo "Hello!";
}
sayHello(); //Appel de la fonction
// Sortie "Hello!"

Fonctions
Paramètres de fonction
Les informations peuvent être transmises aux fonctions via des
arguments, qui sont comme des variables.
Les arguments sont spécifiés après le nom de la fonction et entre
parenthèses.
Ici, notre fonction prend un nombre, le multiplie par deux et imprime
le résultat:
function multiplyByTwo($number) {
$answer = $number * 2;
echo $answer;
}
multiplyByTwo(3);
//Outputs 6

Fonctions
Vous pouvez ajouter autant d'arguments que vous le souhaitez, à
condition qu'ils soient séparés par des points-virgules.
function multiply($num1, $num2) {

echo $num1 * $num2;
}
multiply(3, 6);
//Sortie : 18
Remarque : Lorsque vous définissez une fonction, les variables qui

représentent les valeurs qui lui seront transmises pour le traitement
sont appelées paramètres. Toutefois, lorsque vous utilisez une
fonction, la valeur que vous lui passez est appelée un argument.

Fonctions
Arguments par défaut
Les arguments par défaut peuvent être définis pour les arguments de
la fonction.
Dans l'exemple ci-dessous, nous appelons la fonction setCounter(). Il
n'y a pas d'arguments, donc il va prendre les valeurs par défaut qui
ont été définies.
function setCounter($num=10) {
echo "Counter is ".$num;
}
setCounter(42); //Counter est 42
setCounter(); //Counter est 10
Remarque : Lors de l'utilisation des arguments par défaut, les valeurs

par défaut doivent être sur le côté droit de tous les arguments autres
que ceux par défaut !

Fonctions
Instruction Return
Une fonction peut renvoyer une valeur en utilisant l'instruction return.
Le retour arrête l'exécution de la fonction et renvoie la valeur au
code appelant.
Par exemple:
function mult($num1, $num2) {
$res = $num1 * $num2;
return $res;
}
echo mult(8, 3);
// Sortie : 24

Variables prédéfinies

Une superglobale est une variable prédéfinie toujours accessible,
quelle que soit sa portée. Vous pouvez accéder aux superglobales
PHP à travers n'importe quelle fonction, classe ou fichier.
Les variables superglobales de PHP sont :
- $_SERVER,
- $GLOBALS,
- $_REQUEST,
- $_POST,
- $_GET,
- $_FILES,
- $_ENV,
- $_COOKIE,
- $_SESSION.

$ _SERVER
$ _SERVER est un tableau qui inclut des informations telles que les en-
têtes, les chemins et les emplacements de script. Les entrées de ce
tableau sont créées par le serveur Web.
$ _SERVER ['SCRIPT_NAME'] retourne le chemin du script courant:
<?php
echo $_SERVER['SCRIPT_NAME'];
//Sortie : "/somefile.php"
?>
Remarque : Notre exemple a été écrit dans un fichier appelé somefile.php, situé
à la racine du serveur Web.

$_SERVER
$_SERVER['HTTP_HOST'] renvoie l’entête de l’hôte de la requête en
cours.
<?php
echo $_SERVER[‘HTTP_HOST’];
// Sortie "localhost"
?>
Cette méthode peut être utile lorsque vous avez beaucoup d'images
sur votre serveur et devez transférer le site Web vers un autre hôte. Au
lieu de changer le chemin pour chaque image, vous pouvez créer un
fichier config.php comme ce qui suit:
<?php
$host = $_SERVER['HTTP_HOST'];
$image_path = $host.’/images/';
?>
Utilisation du fichier config.php :
<?php
require 'config.php';
echo '<img src="'.$image_path.'header.png" />';
?>
Remarque : Le chemin vers vos images est maintenant dynamique. Il
va changer automatiquement, en fonction de l'en-tête de l'hôte.


Formulaires
Le but des superglobales PHP $ _GET et $ _POST est de collecter des
données qui ont été entrées dans un formulaire.
L'exemple ci-dessous montre un formulaire HTML simple qui comprend
deux champs de saisie et un bouton de soumission:
<form action="first.php" method="post">
<p>Name: <input type="text" name="name" /></p>
<p>Age: <input type="text" name="age" /></p>
<p><input type="submit" name="submit" value="Submit" /></p>
</form>

L'attribut action spécifie que lorsque le formulaire est soumis, les
données sont envoyées à un fichier PHP nommé first.php.
Les éléments de formulaire HTML ont des noms, qui seront utilisés lors
de l'accès aux données avec PHP.

Maintenant, quand nous avons un formulaire HTML avec l'attribut
action défini dans notre fichier PHP, nous pouvons accéder aux
données du formulaire en utilisant le tableau associatif $ _POST.
dans le fichier first.php :
<html>
<body>
Welcome <?php echo $_POST["name"]; ?><br />
Your age: <?php echo $_POST["age"]; ?>
</body>
</html>
Le tableau superglobal $ _POST contient des paires clé/valeur. Dans
les paires, les clés sont les noms des contrôles de formulaire et les
valeurs sont les données d'entrée entrées par l'utilisateur.
Nous avons utilisé le tableau $ _POST, car la méthode = "post" a été
spécifiée dans le formulaire.
Méthode POST
Les deux méthodes pour soumettre des formulaires sont GET et POST.
Les informations envoyées à partir d'un formulaire via la méthode
POST sont invisibles aux autres, car tous les noms et/ou valeurs sont
incorporés dans le corps de la requête HTTP. En outre, il n'y a aucune
limite sur la quantité d'informations à envoyer.
En outre, POST prend en charge des fonctionnalités avancées telles
que la prise en charge d'une entrée binaire multi-parties lors du
téléchargement de fichiers sur le serveur.
Cependant, il n'est pas possible de mettre en signet la page, car les
valeurs soumises ne sont pas visibles.

Méthode GET
Les informations envoyées via un formulaire à l'aide de la méthode
GET sont visibles par tous (tous les noms et valeurs de variables sont
affichés dans l'URL). GET définit également des limites sur la quantité
d'informations pouvant être envoyées - environ 2000 caractères.
Cependant, comme les variables sont affichées dans l'URL, il est
possible de mettre en signet la page, ce qui peut être utile dans
certaines situations.
Exemple :
<form action="actionGet.php" method="get">
Name: <input type="text" name="name" /><br /><br />
Age: <input type="text" name="age" /><br /><br />
<input type="submit" name="submit" value="Submit" />
</form>

actionGet.php
<?php
echo "Hi ".$_GET['name'].". ";
echo "You are ".$_GET['age']." years old.";
?>
Maintenant, le formulaire est soumis à actionGet.php, et vous pouvez
voir les données soumises dans l’URL:
Remarque : GET ne doit jamais être utilisé pour envoyer des mots de
passe ou d'autres informations sensibles !
Lorsque vous utilisez POST ou GET, la validation correcte des données
de formulaire via le filtrage et le traitement est d'une importance
vitale pour protéger votre formulaire contre les pirates !

Variable de Session
En utilisant une session, vous pouvez stocker des informations dans des
variables, à utiliser sur plusieurs pages. Par défaut, les variables de
session durent jusqu'à ce que l'utilisateur ferme le navigateur.
Une session est démarrée en utilisant la fonction session_start ().
Utilisez le global PHP $ _SESSION pour définir les variables de session.
<?php
// Start the session
session_start();
$_SESSION['color'] = "red";
$_SESSION['name'] = "John";
?>
La fonction session_start() doit être la toute première chose dans votre
document. Avant les balises HTML.

Variables de session
Une autre page peut être créée pour accéder aux variables de
session définies dans la page précédente:
<?php
// Start the session
session_start();
?>
<!DOCTYPE html>
<html>
<body>
<?php
echo "Your name is " . $_SESSION[‘name']; // Sortie : "Your name is John"
?>
</body>
</html>

Vos variables de session restent disponibles dans la superglobale
$_SESSION jusqu'à la fermeture de votre session.
‣ Toutes les variables de session peuvent être supprimées
manuellement en utilisant session_unset().
‣ Vous pouvez également détruire la session avec
session_destroy().

Les cookies
Les cookies sont souvent utilisés pour identifier l'utilisateur. Un cookie
est un petit fichier que le serveur intègre sur l'ordinateur de l'utilisateur.
Chaque fois qu'un même ordinateur demande une page via un
navigateur, il envoie également le cookie. Avec PHP, vous pouvez
créer et récupérer des valeurs de cookies.
Créez des cookies en utilisant la fonction setcookie():
setcookie(name, value, expire, path, domain, secure, httponly);
name: spécifie le nom du cookie
value: Spécifie la valeur du cookie
expire: spécifie (en secondes) quand le cookie doit expirer. La valeur:
time()+ 86400*30, définira le cookie à expiration dans 30 jours. Si ce
paramètre est omis ou mis à 0, le cookie expirera à la fin de la session
(à la fermeture du navigateur). La valeur par défaut est 0.

path :Spécifie le chemin du serveur du cookie. S'il est défini sur "/", le
cookie sera disponible dans tout le domaine. S'il est réglé sur "/ php /",
le cookie ne sera disponible que dans le répertoire php et dans tous
les sous-répertoires de php. La valeur par défaut est le répertoire en
cours dans lequel le cookie est défini.
domain: spécifie le nom de domaine du cookie. Pour rendre le cookie
disponible sur tous les sous-domaines de example.com, définissez le
domaine sur "example.com".
secure: Indique si le cookie doit ou non être transmis via une
connexion HTTPS sécurisée. TRUE indique que le cookie ne sera défini
que si une connexion sécurisée existe. La valeur par défaut est FALSE.
httponly: S'il est défini sur TRUE, le cookie sera accessible uniquement
via le protocole HTTP (le cookie ne sera pas accessible aux langages
de script). L'utilisation de httponly permet de réduire le vol d'identité à
l'aide d'attaques XSS. La valeur par défaut est FALSE.

Les Cookies
L'exemple suivant crée un cookie nommé "user" avec la valeur "John".
Le cookie expirera après 30 jours, ce qui est écrit comme 86400*30,
dans lequel 86 400 secondes = un jour. Le '/' signifie que le cookie est
disponible sur l'ensemble du site.
Nous récupérons ensuite la valeur du cookie "user" (en utilisant la
variable globale $_COOKIE). Nous utilisons également la fonction
isset() pour savoir si le cookie est défini:
<?php
$value = "John";
setcookie("user", $value, time() + (86400 * 30), '/');
if(isset($_COOKIE['user'])) {
echo "Value is: ". $_COOKIE['user'];
} //Outputs "Value is: John »
?>

La fonction setcookie() doit apparaître AVANT la balise <html>.
La valeur du cookie est automatiquement encodée lors de l'envoi du
cookie et est automatiquement décodée lors de sa réception.
Néanmoins, ne stockez JAMAIS d'informations sensibles dans les
cookies.

Manipulations de fichiers

Manipuler des fichiers
PHP offre un certain nombre de fonctions à utiliser lors de la création,
de la lecture, du téléchargement et de l'édition de fichiers.
La fonction fopen() crée ou ouvre un fichier. Si vous utilisez fopen()
avec un fichier qui n'existe pas, le fichier sera créé, étant donné que
le fichier a été ouvert pour l'écriture (w) ou l'ajout (a).
Utilisez l'un des modes suivants pour ouvrir le fichier.
r: Ouvre le fichier en lecture seule.
w: Ouvre le fichier pour écriture seulement. Efface le contenu du
fichier ou crée un nouveau fichier s'il n'existe pas.
a: Ouvre le fichier pour écriture seulement.
x: Crée un nouveau fichier pour écriture seulement.
r +: Ouvre le fichier en lecture / écriture.

Manipuler des fichiers
r: Ouvre le fichier en lecture seule.
w: Ouvre le fichier pour écriture seulement. Efface le contenu du
fichier ou crée un nouveau fichier s'il n'existe pas.
a: Ouvre le fichier pour écriture seulement.
x: Crée un nouveau fichier pour écriture seulement.
r +: Ouvre le fichier en lecture / écriture.
w +: Ouvre le fichier en lecture / écriture. Efface le contenu du fichier
ou crée un nouveau fichier s'il n'existe pas.
a +: Ouvre le fichier en lecture / écriture. Crée un nouveau fichier si le
fichier n'existe pas
x +: Crée un nouveau fichier en lecture / écriture.
L'exemple ci-dessous crée un nouveau fichier, "fichier.txt", qui sera
créé dans le même répertoire que le code PHP.
$ myfile = fopen ("fichier.txt", "w");
Écrire dans un fichier
Lorsque vous écrivez dans un fichier, utilisez la fonction fwrite().
Le premier paramètre de fwrite() est le fichier à écrire; le deuxième
paramètre est la chaîne à écrire.

L'exemple ci-dessous écrit un couple de noms dans un nouveau
fichier appelé « names.txt".
<?php
$myfile = fopen("names.txt", "w");
$txt = "John\n";
fwrite($myfile, $txt);
$txt = "David\n";
fwrite($myfile, $txt);
fclose($myfile);
/* Contenu du fichier :
John
David
*/
?>

Notez que nous avons écrit deux fois dans le fichier "names.txt", puis
nous avons utilisé la fonction fclose() pour fermer le fichier.
Le symbole \n est utilisé lors de l'écriture de nouvelles lignes.
fclose()
La fonction fclose() ferme un fichier ouvert et renvoie TRUE en cas de
succès ou FALSE en cas d'échec.
C'est une bonne pratique de fermer tous les fichiers après avoir fini de
travailler avec eux.

Ajouter du contenu à un fichier
Si vous souhaitez ajouter du contenu à un fichier, vous devez ouvrir le
fichier en mode Ajout.
Par exemple:
$myFile = "test.txt";
$fh = fopen($myFile, 'a');
fwrite($fh, "Some text");
fclose($fh);
Lors de l'ajout à un fichier en utilisant le ‘a', le pointeur de fichier est
placé à la fin du fichier, s'assurant que toutes les nouvelles données
sont ajoutées à la fin du fichier.

Ajouter du contenu à un fichier
Formulaire qui ajoute des données remplies à un fichier.
<?php
if(isset($_POST['text'])) {
$name = $_POST['text'];
$handle = fopen('names.txt', 'a');
fwrite($handle, $name. »\n");
fclose($handle);
}
?>
<form method="post">
Name: <input type="text" name="text" />
<input type="submit" name="submit" />
</form>

Maintenant, chaque fois qu'un nom est entré et soumis, il est ajouté
au fichier "names.txt", avec une nouvelle ligne.
La fonction isset() détermine si le formulaire a été soumis, ainsi que si
le texte contient une valeur.
Nous n'avons pas spécifié d'attribut d'action pour le formulaire, donc il
se soumettra à lui-même.

Lire un fichier
La fonction file() lit le fichier entier dans un tableau. Chaque élément
du tableau correspond à une ligne du fichier:
$read = file('names.txt');
foreach ($read as $line) {
echo $line .", ";
}
Cela imprime toutes les lignes du fichier et les sépare par des virgules.
Nous avons utilisé la boucle foreach, car la variable $read est un
tableau.

Lire un fichier
À la fin de la sortie dans l'exemple précédent, nous aurions une
virgule, comme nous l'imprimons après chaque élément du tableau.
Le code suivant nous permet d'éviter d'imprimer cette virgule finale.
$read = file('names.txt');
$count = count($read);
$i = 1;
foreach ($read as $line) {
echo $line;
if($i < $count) {
echo ', ';
}
$i++;
}

La variable $count utilise la fonction count() pour obtenir le nombre
d'éléments dans le tableau $read.
Ensuite, dans la boucle foreach, après chaque impression de ligne,
nous déterminons si la ligne courante est inférieure au nombre total
de lignes, et imprimons une virgule si c'est le cas.
Cela évite d'imprimer cette virgule finale, comme pour la dernière
ligne, $i est égal à $count.

Développement Web
Cours PHP
Tél. 06 74 33 44 20
patrice.pegaule@3il.fr

PHP 7.

Transféré par

Informations du document

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

PHP 7.

Transféré par

Droits d'auteur :

Formats disponibles

PHP

Installation des serveurs (Wamp, Mamp, Lamp, Xamp)

Patrice Pegaule / 2021

Patrice Pegaule - patrice.pegaule@3il.fr 2

Patrice Pegaule - patrice.pegaule@3il.fr 3

Patrice Pegaule - patrice.pegaule@3il.fr 4

Patrice Pegaule - patrice.pegaule@3il.fr 5

Patrice Pegaule - patrice.pegaule@3il.fr 6

Patrice Pegaule - patrice.pegaule@3il.fr 7

Patrice Pegaule - patrice.pegaule@3il.fr 8

Patrice Pegaule - patrice.pegaule@3il.fr 9

Patrice Pegaule - patrice.pegaule@3il.fr 10

Patrice Pegaule - patrice.pegaule@3il.fr 11

Patrice Pegaule - patrice.pegaule@3il.fr 12

Patrice Pegaule - patrice.pegaule@3il.fr 13

Patrice Pegaule - patrice.pegaule@3il.fr 14

Patrice Pegaule - patrice.pegaule@3il.fr 15

Règles pour les variables PHP:

Patrice Pegaule - patrice.pegaule@3il.fr 16

Contrairement à d'autres langages de programmation, PHP n'a pas de

Patrice Pegaule - patrice.pegaule@3il.fr 17

Patrice Pegaule - patrice.pegaule@3il.fr 18

L'exemple ci-dessous crée une constante avec un nom insensible à la casse:

Patrice Pegaule - patrice.pegaule@3il.fr 21

Patrice Pegaule - patrice.pegaule@3il.fr 22

Patrice Pegaule - patrice.pegaule@3il.fr 23

Les variables PHP peuvent être déclarées n'importe où dans le script.

Les étendues de variables les plus utilisées de PHP sont locales,

Patrice Pegaule - patrice.pegaule@3il.fr 24

Patrice Pegaule - patrice.pegaule@3il.fr 25

Patrice Pegaule - patrice.pegaule@3il.fr 26

Patrice Pegaule - patrice.pegaule@3il.fr 27

Patrice Pegaule - patrice.pegaule@3il.fr 28

Les opérateurs arithmétiques travaillent avec des valeurs numériques

Patrice Pegaule - patrice.pegaule@3il.fr 29

echo $num1 + $num2; // Addiction : 14

Patrice Pegaule - patrice.pegaule@3il.fr 30

A noter : Si vous utilisez des nombres à virgule flottante avec

Patrice Pegaule - patrice.pegaule@3il.fr 31

Les opérateurs d'incrémentation sont utilisés pour incrémenter la

Patrice Pegaule - patrice.pegaule@3il.fr 32

Les opérateurs d'incrémentation et de décrémentation précèdent ou

Patrice Pegaule - patrice.pegaule@3il.fr 33

Patrice Pegaule - patrice.pegaule@3il.fr 34

Patrice Pegaule - patrice.pegaule@3il.fr 35

Patrice Pegaule - patrice.pegaule@3il.fr 36

Patrice Pegaule - patrice.pegaule@3il.fr 37

Patrice Pegaule - patrice.pegaule@3il.fr 38

Patrice Pegaule - patrice.pegaule@3il.fr 39

Patrice Pegaule - patrice.pegaule@3il.fr 40

Patrice Pegaule - patrice.pegaule@3il.fr 41

Patrice Pegaule - patrice.pegaule@3il.fr 42

echo "$myArray[0] is $myArray[2] and knows $myArray[1]";

Patrice Pegaule - patrice.pegaule@3il.fr 43

Patrice Pegaule - patrice.pegaule@3il.fr 44

Patrice Pegaule - patrice.pegaule@3il.fr 45

Patrice Pegaule - patrice.pegaule@3il.fr 46

Patrice Pegaule - patrice.pegaule@3il.fr 48

Patrice Pegaule - patrice.pegaule@3il.fr 49

Patrice Pegaule - patrice.pegaule@3il.fr 50

Patrice Pegaule - patrice.pegaule@3il.fr 51

Patrice Pegaule - patrice.pegaule@3il.fr 52

Patrice Pegaule - patrice.pegaule@3il.fr 53

Indépendamment du fait que la condition soit vraie ou fausse, le