# Initiation a la programmation avec PHP
## Table of Content
[TOC]
## OBJECTIFS PÉDAGOGIQUES
> * Être en mesure désormais d'identifier les élements primordiaux des écosystèmes Web et Internet
> * Débuter avec les langages web de base
> * Ameliorer son expérience avec les CMS (WordPress, Joomla, etc) et les Framework (Laravel, Symfony, CodeIgniter, etc)
## Introduction
**Presentation de PHP**
* C'est un outil puissant pour la réalisation de sites Web Intranet et Internet. PHP n'est pas parfait mais c'est un outil précieux et digne pour les programmeurs, les architectes du Net et ceux qui aiment faire des sites pour le plaisir. De grands médias comme FaceBook, Wikipedia sont écrit en PHP.
* Le nom complet de PHP est: Hypertext Preprocessor (l'un de ces fameux acronymes).
* PHP dispose d'un très grand nombre d'API, ce qui le rend très populaire auprès des développeurs. Une API (Application Programming Interface), est un ensemble de bibliothèques qui permet aux programmeurs d'interagir avec les systèmes d'exploitations, les bases de données ou autres applications.
Creation et utilite
Syntaxe et balise
`echo`
## Variables
c'est quoi une variable ?
> Une variable est un élément qui peut prendre différente valeur a un certains niveau du code.
Quels sont les types de variable?
> types de donnee: Int, Float, String, Array, Boolean, Null, Ressource, Class
Comment définir une variable ?
> En PHP une variable est définie en utilisant le signe du dollar '$'
Comment Nommer une variable en PHP ?
> Un nom de variable peut commencer par un trait de soulignement (underscore) " _ " ou une lettre majuscule ou minuscule
> Un nom de variable peut commencer par un trait de soulignement (underscore) " _ " ou une lettre majuscule ou minuscule
```php=8
<?php
// Nom de Variable valide ☑️
$_123; $variable; $VARiable;
// Nom de variable non valide ❎
$123; $var-1rv; $var+man;
?>
```
### Variable Type
PHP possède un total de huit types de données que nous utilisons pour construire nos variables.
#### Les entiers
- Les entiers(Integers) - sont des nombres entiers, sans point décimal, comme 4195.
#### les Nombres Flottant (decimals)
- Doubles ou Float - sont des nombres à virgule flottante, comme 3.14159 ou 49.1.
#### Les booléens
- Les booléens(Booleans) - n'ont que deux valeurs possibles : `true` ou `false`.
#### NULL
- NULL - est un type spécial qui n'a qu'une seule valeur : `NULL` or `null`.
#### Les Chaines de caracteres
- Les chaînes de caractères(string) - sont des séquences de caractères, comme `"PHP supporte les opérations sur les chaînes de caractères"`.
#### Les Tableaux
- Les tableaux(array) - sont des collections nommées et indexées d'autres valeurs.
- Un tableau est une structure de données qui stocke une ou plusieurs valeurs de même type dans une seule valeur. Par exemple, si vous voulez stocker 100 nombres, au lieu de définir 100 variables, il est facile de définir un tableau de 100 longueurs.
### Variable Typecast
PHP nous permet de convertir le type de données de n'importe quelle variable explicitement en utilisant certains mots-clés intégrés. De même, PHP peut convertir les types de données en utilisant la méthode implicite.
#### Conversion de type implicite en PHP
PHP va automatiquement convertir le type d'une variable en fonction de la valeur qui lui est assignée. Ce type de conversion est appelé Implicite, et PHP le fait pour nous. Par exemple, si nous déclarons une variable avec une chaîne vide et que nous lui assignons une valeur entière plus tard dans le programme, PHP convertira automatiquement le type de cette variable de chaîne en entier.
#### Conversion de type explicite en PHP
La détermination explicite du type a été faite par des programmeurs comme nous en utilisant les mots-clés autorisés par le langage PHP. Vous trouverez ci-dessous les méthodes d'encodage de type autorisées en PHP,
- (int) ou (integer) - conversion en un Integer (nombre entier)
- (bool) ou (boolean) - Conversion en booléen
- (float) ou (double) ou (real) - Conversion en Flottant
- (string) - Conversion en String
- (array) - Conversion en tableau
- (object) - Conversion en un objet
## Les Tableaux
Il existe trois types de tableaux différents et chaque valeur de tableau est accessible à l'aide d'un ID c appelé index de tableau.
### Tableau numérique
- Un tableau avec un index numérique. Les valeurs sont stockées et accessibles de manière linéaire.
Ces tableaux peuvent stocker des nombres, des chaînes de caractères et n'importe quel objet, mais leur index sera représenté par des nombres. Par défaut, l'indice du tableau commence à zéro.
**Exemple**
L'exemple suivant montre comment créer et accéder à des tableaux numériques.
Ici, nous avons utilisé la fonction array() pour créer un tableau. Cette fonction est expliquée dans la référence de la fonction.
```php
<?php
/* First method to create array. */
$numbers = array( 1, 2, 3, 4, 5);
foreach( $numbers as $value ) {
echo "Value is $value <br />";
}
/* Second method to create array. */
$numbers[0] = "one";
$numbers[1] = "two";
$numbers[2] = "three";
$numbers[3] = "four";
$numbers[4] = "five";
foreach( $numbers as $value ) {
echo "Value is $value <br />";
}
?>
```
### Tableau associatif
- Un tableau avec des chaînes de caractères comme index. Il stocke les valeurs des éléments en association avec les valeurs des clés plutôt que dans un ordre d'indexation linéaire strict.
Les tableaux associatifs sont très similaires aux tableaux numériques en termes de fonctionnalité mais ils sont différents en termes d'index. Les tableaux associatifs auront leur index sous forme de chaîne de caractères afin que vous puissiez établir une association forte entre la clé et les valeurs.
Pour stocker les salaires des employés dans un tableau, un tableau à indexation numérique ne serait pas le meilleur choix. Au lieu de cela, nous pourrions utiliser les noms des employés comme clés dans notre tableau associatif, et la valeur serait leur salaire respectif.
NOTE - Ne gardez pas le tableau associatif entre guillemets doubles lors de l'impression, sinon il ne retournera aucune valeur.
Exemple
```php
<?php
/* First method to associate create array. */
$salaries = array("mohammad" => 2000, "qadir" => 1000, "zara" => 500);
echo "Salary of mohammad is ". $salaries['mohammad'] . "<br />";
echo "Salary of qadir is ". $salaries['qadir']. "<br />";
echo "Salary of zara is ". $salaries['zara']. "<br />";
/* Second method to create array. */
$salaries['mohammad'] = "high";
$salaries['qadir'] = "medium";
$salaries['zara'] = "low";
echo "Salary of mohammad is ". $salaries['mohammad'] . "<br />";
echo "Salary of qadir is ". $salaries['qadir']. "<br />";
echo "Salary of zara is ". $salaries['zara']. "<br />";
?>
```
### Tableau multidimensionnel
- Un tableau contenant un ou plusieurs tableaux et les valeurs sont accessibles à l'aide d'indices multiples.
Un tableau multidimensionnel, chaque élément du tableau principal peut également être un tableau. Et chaque élément du tableau secondaire peut être un tableau, et ainsi de suite. Les valeurs d'un tableau multidimensionnel sont accessibles à l'aide d'un index multiple.
**Exemple**
Dans cet exemple, nous créons un tableau bidimensionnel pour stocker les notes de trois étudiants dans trois matières -.
Cet exemple est un tableau associatif, vous pouvez créer un tableau numérique de la même manière.
```php
<?php
$marks = array(
"mohammad" => array (
"physics" => 35,
"maths" => 30,
"chemistry" => 39
),
"qadir" => array (
"physics" => 30,
"maths" => 32,
"chemistry" => 29
),
"zara" => array (
"physics" => 31,
"maths" => 22,
"chemistry" => 39
)
);
/* Accessing multi-dimensional array values */
echo "Marks for mohammad in physics : " ;
echo $marks['mohammad']['physics'] . "<br />";
echo "Marks for qadir in maths : ";
echo $marks['qadir']['maths'] . "<br />";
echo "Marks for zara in chemistry : " ;
echo $marks['zara']['chemistry'] . "<br />";
?>
```
#### Objets
- Objets - sont des instances de classes définies par le programmeur, qui peuvent contenir à la fois d'autres types de valeurs et des fonctions spécifiques à la classe.
#### Ressources
- Ressources - sont des variables spéciales qui contiennent des références à des ressources externes à PHP (comme les connexions aux bases de données).
## Operators
**Qu'est-ce qu'un opérateur ?**
Une réponse simple peut être donnée en utilisant l'expression 4 + 5 est égal à 9. Ici, 4 et 5 sont appelés opérandes et + est appelé opérateur. Le langage PHP supporte les types d'opérateurs suivants.
**Catégories d'opérateurs**
Tous les opérateurs que nous avons abordés ci-dessus peuvent être classés dans les catégories suivantes :
* Les opérateurs préfixes unaires, qui précèdent un seul opérande.
* Les opérateurs binaires, qui prennent deux opérandes et effectuent une variété d'opérations arithmétiques et logiques.
* L'opérateur conditionnel (opérateur ternaire), qui prend trois opérandes et évalue soit la deuxième soit la troisième expression, en fonction de l'évaluation de la première expression.
* Les opérateurs d'affectation, qui attribuent une valeur à une variable.
### Opérateurs arithmétiques
Les opérateurs arithmétiques suivants sont supportés par le langage PHP.
Si la variable A contient 10 et la variable B contient 20, alors -
| Operator | Description | Example |
| -------- | -------- | -------- |
|+ |Additionne deux opérandes| A + B donne 30|
| - | Soustraire le deuxième opérande du premier |A - B donne -10|
|* |Multiplier les deux opérandes |A * B donne 200
|/ | Diviser le numérateur par le dé-numérateur| B / A donne 2
|% |Opérateur de modulation et reste de après une division entière| B % A donnera 0
|++| Opérateur d'incrémentation, augmente la valeur entière de un |A++ donnera 11|
| - -| Opérateur de décrémentation, diminue la valeur de l'entier de un| A-- donnera 9|
### Opérateurs de comparaison
Les opérateurs de comparaison suivants sont supportés par le langage PHP
Supposons que la variable A contient 10 et que la variable B contient 20 alors -
| Operator | Description | Example |
| -------- | -------- | -------- |
|== |Vérifie si la valeur de deux opérandes sont égale ou non, si oui, la condition devient vraie.|(A == B) is not true.|
|!=|Vérifie si les valeurs des deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie.|(A != B) is true.|
|>|Vérifie si la valeur de l'opérande de gauche est supérieure à la valeur de l'opérande de droite, si oui, la condition devient vraie.|(A > B) is not true.|
|<|Vérifie si la valeur de l'opérande de gauche est inférieure à la valeur de l'opérande de droite, si oui, la condition devient vraie.|(A < B) is true.|
|>=|Vérifier si la valeur de l'opérande de gauche est supérieure ou égale à la valeur de l'opérande de droite, si oui, la condition devient vraie.|(A >= B) is not true.|
|<=|Vérifier si la valeur de l'opérande de gauche est inférieure ou égale à la valeur de l'opérande de droite, si oui, la condition devient vraie.|(A <= B) is true.|
### Opérateurs logiques (ou relationnels)
| Operator | Description | Example |
| -------- | -------- | -------- |
and|Appelé opérateur AND logique. Si les deux opérandes sont différents de zéro, la condition devient vraie.| (A and B) is true.
or|Appelé opérateur OU logique. Si l'un des deux opérandes est différent de zéro, la condition devient vraie.| (A or B) is true.
&&| Appelé opérateur AND logique. Si les deux opérandes sont différents de zéro, la condition devient vraie. |(A && B) is true.
|! |Appelé opérateur logique NOT. Il est utilisé pour inverser l'état logique de son opérande. Si une condition est vraie, l'opérateur logique NOT rendra faux.| !(A && B) is false.|
### Opérateurs d'assignation
<table class="table table-bordered">
<tbody><tr>
<th class="ts">Operator</th>
<th class="ts">Description</th>
<th class="ts">Example</th>
</tr>
<tr>
<td class="ts">=</td>
<td>Opérateur d'affectation simple, affecte les valeurs des opérandes de droite aux opérandes de gauche.</td>
<td>C = A + B assignera la valeur de A + B dans C</td>
</tr>
<tr>
<td class="ts">+=</td>
<td>Opérateur d'affectation addition, il ajoute l'opérande de droite à l'opérande de gauche et assigne le résultat à l'opérande de gauche.</td>
<td>C += A est équivalent à C = C + A</td>
</tr>
<tr>
<td class="ts">-=</td>
<td>Opérateur d'affectation soustracteur ET, il soustrait l'opérande de droite de l'opérande de gauche et affecte le résultat à l'opérande de gauche.</td>
<td>C -= A est équivalent à C = C - A</td>
</tr>
<tr>
<td class="ts">*=</td>
<td>Opérateur d'affectation multiplicateur ET, il multiplie l'opérande de droite par l'opérande de gauche et affecte le résultat à l'opérande de gauche.</td>
<td>C *= A est équivalent à C = C * A</td>
</tr>
<tr>
<td class="ts">/=</td>
<td>Opérateur d'affectation diviseur ET, il divise l'opérande gauche avec l'opérande droit et affecte le résultat à l'opérande gauche.</td>
<td>C /= A est équivalent à C = C / A</td>
</tr>
<tr>
<td class="ts">%=</td>
<td>Opérateur d'affectation modulus AND, il prend le modulus en utilisant deux opérandes et affecte le résultat à l'opérande de gauche.</td>
<td>C %= A est équivalent à C = C % A</td>
</tr>
</tbody></table>
### Opérateurs conditionnels (ou ternaires)
Il existe un autre opérateur appelé opérateur conditionnel. Il évalue d'abord une expression pour obtenir une valeur vraie ou fausse, puis exécute l'une des deux instructions données en fonction du résultat de l'évaluation.
| Operator | Description | Example |
| -------- | -------- | -------- |
|? :| Expression conditionnelle| `(condition) ? true : false` |
## Structure de controle
Introduction aux structure de controle
### Test conditionnel
#### If
L'instruction `if` est une des plus importantes instructions de tous les langages, PHP inclus. Elle permet l'exécution conditionnelle d'une partie de code. Les fonctionnalités de l'instruction `if` sont les mêmes en PHP qu'en C.
Comme nous l'avons vu dans le paragraphe consacré aux `expressions`, expression est convertie en sa valeur booléenne. Si l'expression vaut `true`, PHP exécutera l'instruction et si elle vaut `false`, l'instruction sera ignorée. Plus de détails sur les valeurs qui valent false sont disponibles dans la section [Conversion en booléen](https://https://www.php.net/manual/fr/language.types.boolean.php#language.types.boolean.casting).
```php=
<?php
if(10<=10){echo 'justice';}
?>
```
#### If Else
Souvent, vous voulez exécuter une instruction si une condition est remplie, et une autre instruction si cette condition n'est pas remplie. C'est à cela que sert else. else fonctionne après un if et exécute les instructions correspondantes au cas où l'expression du if est false. Dans l'exemple suivant, ce bout de code affiche a est plus grand que b si la variable $a est plus grande que la variable $b, et a est plus petit que b sinon :
```php=
<?php
$age = 10;
if($age>=18)
{
echo 'vous etes majeurs';
}
else
{
// echo 'vous n\'etes pas majeur';
echo "vous n\'etes pas majeur";
}
?>
```
```php=
```
#### If ElseIf() else
elseif, comme son nom l'indique, est une combinaison de if et de else. Comme l'expression else, il permet d'exécuter une instruction après un if dans le cas où le "premier" if est évalué comme false. Mais, à la différence de l'expression else, il n'exécutera l'instruction que si l'expression conditionnelle elseif est évaluée comme true. L'exemple suivant affichera a est plus grand que b, a est égal à b ou a est plus petit que b.
```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";
}
```
#### switch
L'instruction `switch` équivaut à une série d'instructions `if`. En de nombreuses occasions, vous aurez besoin de comparer la même variable (ou expression) avec un grand nombre de valeurs différentes, et d'exécuter différentes parties de code suivant la valeur à laquelle elle est égale. C'est exactement à cela que sert l'instruction switch.
```php=
if ($i == 0) {
echo "i égal 0";
} elseif ($i == 1) {
echo "i égal 1";
} elseif ($i == 2) {
echo "i égal 2";
}
```
```php=
switch ($i) {
case 0:
echo "i égal 0";
break;
case 1:
echo "i égal 1";
break;
case 2:
echo "i égal 2";
break;
}
```
#### match
L'expression de correspondance branche l'évaluation sur la base d'un contrôle d'identité d'une valeur. Tout comme une instruction switch, une expression match possède une expression sujet qui est comparée à plusieurs alternatives. Contrairement à l'instruction switch, elle est évaluée à une valeur, comme les expressions ternaires. Contrairement à switch, la comparaison est un contrôle d'identité (`===`) plutôt qu'un contrôle d'égalité faible (`==`). Les expressions Match sont disponibles depuis PHP 8.0.0.
source: [match](https://www.php.net/manual/fr/control-structures.match.php)
```php=
<?php
$text = 'Bienvenue chez nous';
$result = match (true) {
str_contains($text, 'Welcome') || str_contains($text, 'Hello') => 'en',
str_contains($text, 'Bienvenue') || str_contains($text, 'Bonjour') => 'fr',
};
```
### Boucles
Les boucles en PHP sont utilisées pour exécuter le même bloc de code un nombre déterminé de fois ou bien tant que une conditions est vrai. PHP supporte les quatre types de boucles suivants.
### 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.
La signification d'une boucle while est très simple. PHP exécute l'instruction tant que l'expression de la boucle `while` est évaluée comme `true`. La valeur de l'expression est vérifiée à chaque début de boucle, et, si la valeur change durant l'exécution de l'instruction, l'exécution ne s'arrêtera qu'à la fin de l'itération (chaque fois que PHP exécute l'instruction, on appelle cela une itération). Si l'expression du `while` est `false` avant la première itération, l'instruction ne sera jamais exécutée.
```php=
<?
$i = 1;
while ($i <= 10) {
echo $i++;
}
//
$b = 1;
while ($b <= 10) :
echo $b++;
endwhile;
```
### 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. La principale différence par rapport à la boucle while est que la première itération de la boucle do-while est toujours exécutée (l'expression n'est testée qu'à la fin de l'itération), ce qui n'est pas le cas lorsque vous utilisez une boucle while (la condition est vérifiée dès le début de chaque itération, et si elle s'avère false dès le début, la boucle sera immédiatement arrêtée).
```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++).La première expression (`expr1`) est évaluée (exécutée), quoi qu'il arrive au début de la boucle.
Au début de chaque itération, l'expression `expr2` est évaluée. Si l'évaluation vaut `true`, la boucle continue et les commandes sont exécutées. Si l'évaluation vaut false, l'exécution de la boucle s'arrête.
À la fin de chaque itération, l'expression `expr3` est évaluée (exécutée).
Les expressions peuvent éventuellement être laissées vides ou peuvent contenir plusieurs expressions séparées par des virgules. Dans `expr2`, toutes les expressions séparées par une virgule sont évaluées mais le résultat est obtenu depuis la dernière partie. Si l'expression `expr2` est laissée vide, cela signifie que c'est une boucle infinie (PHP considère implicitement qu'elle vaut `true`, comme en C). Cela n'est pas vraiment très utile, à moins que vous souhaitiez terminer votre boucle par l'instruction conditionnelle `break`.
```php=
for ($i = 1; $i <= 10; $i++) {
echo $i;
}
for ($i = 1; ; $i++) {
if ($i > 10) {
break;
}
echo $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 :
```php=
foreach (iterable_expression as $value){
//commandes
}
foreach (iterable_expression as $key => $value){
//commandes
}
```
La première forme passe en revue le tableau iterable_expression. À chaque itération, la valeur de l'élément courant est assignée à $value.
La seconde forme assignera en plus la clé de l'élément courant à la variable $key à chaque itération.
```php=
<?php
$arr = array(1, 2, 3, 4);
print_r($arr);
foreach ($arr as $value) {
echo $value;
print($value);
printf('%d',$value);
echo "\n";
// $value = $value * 2;
}
print_r($arr);
```
## Importations et inclusion de fichier
l'importation de fichier ce fait avec soit l'instruction `require` ou `include`.
### Include
Les fichiers sont inclus suivant le chemin du fichier fourni ; si aucun n'est fourni, l'include_path sera vérifié. Si le fichier n'est pas trouvé dans l' include_path, include vérifiera dans le dossier du script appelant et dans le dossier de travail courant avant d'échouer. L'instruction include émettra E_WARNING si elle ne peut trouver le fichier; ce comportement est différent de require, qui émettra E_ERROR.
Si un chemin est défini, absolu (commençant par une lettre de lecteur suivie de \ pour Windows, ou / pour Unix/Linux) ou relatif (commençant par . ou ..), l'include_path sera ignoré. Par exemple, si un nom de fichier commence par ../, PHP cherchera dans le dossier parent pour y trouver le fichier spécifié.
L'utilisation d'un point (.) dans le chemin d'inclusion vous permet de faire des inclusions relatives au répertoire courant. Cependant, il est plus efficace d'inclure explicitement un fichier avec `include './file'`, que de demander à PHP de vérifier le dossier courant à chaque inclusion.
```php=
include 'path/to/file.php';
```
### Require
Require est utilise les fichiers qui sont indispensable au bon fonctionnement du script PHP. et si elles ne sont pas accessible, une erreur fatal est survient ce qui arrete le script.
```php=
require 'path/to/file.php';
```
## Cookies et Sessions
### Cookie
C'est quoi un cookie?
Les cookies sont des fichiers texte stockés sur l'ordinateur du client et ils sont conservés à des fins de suivi. PHP supporte de manière transparente les cookies HTTP. Les cookies permettent les donnees disponibles a travers les pages d'un sites web.
```php=
<?php
setcookie(
string $name,
string $value = "",
int $expires = 0,
string $path = "",
string $domain = "",
bool $secure = false,
bool $httponly = false
): bool
setcookie("nom", "John Watkin", time()+3600, "/","", 0);
setcookie("age", "36", time()+3600, "/", "", 0);
?>
```
### Session
C'est quoi une session ?
Une session crée un fichier dans un répertoire temporaire sur le serveur où sont stockées les variables de session enregistrées et leurs valeurs.
```php=
<?php session_start(); ?>
```
```php=
<?php
if(isset($_SESSION['variable'])){
echo 'La variable "variable" existe et vaut: '. $_SESSION['variable'];}
?>
```
```php=
<?php
session_unset();
session_destroy();
session_write_close();
setcookie(session_name(),'',0,'/');
session_regenerate_id(true);
?>
```
## Fonctions
C'est quoi une fonction ?
- Une fonction d’après le dictionnaire Ensemble d'instructions constituant un sous-programme identifié par un nom, qui se trouve implanté en mémoire morte ou dans un programme.
- Une fonction en PHP est défini par le mot clé `function` suivit du nom de la fonction après le nom de la fonction nous avons les parenthèses `($args)`qui vont contenir les paramètres ou arguments de la function et qui est dans des accolades `{instructions }` .
- le nom des fonction suit le meme principe que celui des variables. La seule diference est que le nom des fonctions en PHP n'est pas sensible a la case.
une fonction en PHP ressemblerait a ca
```php=
function traitement($args){
// instructions
}
```
```php=
function addition($a,$b){
echo 'addition de '.$a.'+'.$b."\n";
return $a+$b;
}
echo addition(167,20);
function sayBonjour(){
echo 'Bonjour';
}
sayBonjour();
```
## Connexion a une base de Donnee
### Intro au SQL
Le SQL (Structured Query Language) est un langage permettant de communiquer avec une base de données. Ce langage informatique est notamment très utilisé par les développeurs web pour communiquer avec les données d’un site web. Vous pouvez consulter [sql.sh](https://sql.sh/) qui recense des cours de SQL et des explications sur les principales commandes pour lire, insérer, modifier et supprimer des données dans une base.
### Intro au SGBD
C'est quoi un Systeme de gestion de base de Donne?
> Un systeme de gestion de base de donne est un logiciel système servant à stocker, à manipuler ou gérer, et à partager des données dans une base de données, en garantissant la qualité, la pérennité et la confidentialité des informations, tout en cachant la complexité des opérations.
Examples de SGBD
- MySQL
- SQLite
- PostGreSQL
- Oracle
- MongoDB
- etc.
### MySQLi
#### Methode procedurale
```php=8.0
<?php
// Créer une connexion
$conn = mysqli_connect($servername, $username, $password, $DBname);
// Vérifier la connexion
if (!$conn) {
die("La connexion a échoué: " . mysqli_connect_error());
}
?>
```
#### Methode Objet
```php=
<?php
// init MySQLi object with server details
$conn = new MySQLi($servername, $username, $password, $DBname);
```
### PDO
L'extension PDO (PHP Data Objects) permet aux développeurs de se connecter à de nombreux types de bases de données et d'exécuter des requêtes sur celles-ci de manière uniforme et orientée objet.
```php=
<?php
$dsn = 'mysql:host=localhost;dbname=test;charset=utf8';
$pdo = new PDO(
$dsn,
$username,
$password,
array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION)
);
try {
$pdoStatement = $pdo->prepare("UPDATE user SET name = :name");
$pdo->beginTransaction();
$pdoStatement->execute(["name"=>'Bob']);
$pdoStatement->execute(["name"=>'Joe']);
$pdo->commit();
}
catch (\Exception $e) {
if ($pdo->inTransaction()) {
$pdo->rollback();
// If we got here our two data updates are not in the database
}
throw $e;
}
```
## Mails
Envoyer du courrier en PHP peut être aussi simple que d'appeler la fonction intégrée mail() . mail() prend jusqu'à cinq paramètres mais les trois premiers sont suffisants pour envoyer un email (bien que les quatre paramètres soient couramment utilisés comme démontré ci-dessous). Les trois premiers paramètres sont :
```php=
<?php
mail(
string $to,
string $subject,
string $message,
array|string $additional_params = [],
string $additional_params = ""
): bool
```
le code ci dessous envoie un mail de `webmaster@example.com` a `nobody@example.com` avec pour sujet `the Subject` et pour message `hello`
```php=
<?php
$to = 'nobody@example.com';
$subject = 'the subject';
$message = 'hello';
$headers = array(
'From' => 'webmaster@example.com',
'Reply-To' => 'webmaster@example.com',
'X-Mailer' => 'PHP/' . phpversion()
);
mail($to, $subject, $message, $headers)? 'mail sent':'mail not sent';
?>
```
PHPMAILLER WILL BE USED IN THE EXERCICE
## Forms Processing
```php=
$_SERVER
$_REQUEST
$_GET
$_POST
$_FILES
```
Method: GET, POST, PUT, PATCH, DELETE, etc
## Files and file Upload
## EXO: ContactForm + Module Abonnement Newsletter
Sign in with Wallet
Connect another wallet