diff --git a/docs/04-php/01-Installation.md b/docs/04-php/01-Installation.md
index 088800a..7357727 100644
--- a/docs/04-php/01-Installation.md
+++ b/docs/04-php/01-Installation.md
@@ -1,3 +1,7 @@
+---
+sidebar_position: 1
+---
+
 Installation PHP
 ================
 
diff --git a/docs/04-php/02-variables.md b/docs/04-php/02-variables.md
new file mode 100644
index 0000000..0366e94
--- /dev/null
+++ b/docs/04-php/02-variables.md
@@ -0,0 +1,57 @@
+---
+sidebar_position: 2
+---
+
+# Les variables en PHP
+ 
+En PHP comme dans presque tous les langages de programmation, le concept des variables est incontournable.
+
+Les variables sont des sortes de boites dans lesquelles on va ranger des données. Elle peuvent venir de celui qui écrit le programme ou de celui qui l'utilise.
+
+Pour déclarer une variable, on écrit caractère ```$``` suivi du nom de la variable, suivi d'un signe égal, suivi de la valeur qu'on souhaite ranger dans cette variable.
+
+Par exemple : 
+
+```php
+$test = 2;
+
+echo $test;
+```
+
+Dans une variable, on peut ranger différents types de données :
+ 
+ - des nombres entiers
+ - des nombres réels
+ - des valeurs booléenes (vrai ou faux)
+ - des chaînes de caractères
+ - des tableaux
+ - des objets
+
+On peut aussi déclarer une valeur nulle, avec le type ```null```.
+
+
+On peut également déclarer des constantes : 
+
+```php
+define("PI", 3.141592);
+
+echo PI;
+```
+
+Les tableaux sont des collections de données ou de variables. Ils peuvent contenir tous les types de données, ou même un mix des types. Ils s'écrivent entre crochets, avec les données séparées par une virgule. Un tableau peut contenir d'autres tableaux. Par exemple :
+
+```php
+$numbers = [2, 4, 6, 8];
+
+$mixed = ['texte', 2, true];
+
+$array_in_array = [[0, 1], [2, 3]];
+```
+
+On les verra plus en détail dans la rubrique suivante.
+
+Les objets sont une façon de représenter un objet abstrait qui dispose de propriétés, chacune ayant une valeur. On les verra dans le chapitre sur la POO.
+
+## Ressources
+
+* [Apprendre à gérer les variables par Grafikart](https://grafikart.fr/tutoriels/variables-php-1115#autoplay)
\ No newline at end of file
diff --git a/docs/04-php/03-tableaux.md b/docs/04-php/03-tableaux.md
new file mode 100644
index 0000000..4096f91
--- /dev/null
+++ b/docs/04-php/03-tableaux.md
@@ -0,0 +1,62 @@
+---
+sidebar_position: 3
+---
+
+# Les tableaux en PHP
+ 
+En PHP comme dans presque tous les langages de programmation, on peut écrire des tableaux, c'est à dire des listes de données. Un tableau peut contenir tout type de données, et on peut même écrire des tableaux dans des tableaux.
+
+Pour écrire une tableau, on utilise les crochets, à l'intérieur desquels on écrit nos valeurs séparées par des virgules.
+
+Exemple :
+
+```php
+$mois = ['janvier', 'février', 'mars'];
+```
+
+Lorsqu'on veut récupérer une valeur dans un tableau, on utilse son index, c'est à dire sa position dans le tableau, en sachant que la première position est à l'index 0.
+
+```php
+$selection = $mois[2];
+echo $selection; 
+```
+
+Ce code renverra le mot ```mars```, puis que l'index 2 représente la troisième position dans le tableau.
+
+On peut aussi rajouter une valeur dans un tableau. Dans ce cas, il n'est pas nécessaire de spécifier l'index :
+
+```php
+$mois[] = 'avril';
+echo $mois; 
+```
+
+On peut aussi écrire ce qu'on appelle des tableaux **associatifs**, c'est à dire des tableaux qui associent une valeur à une clef.  
+
+Exemple :
+
+```php
+$resultats = [
+    'janvier' => 25,
+    'février' => 32,
+    'mars' => 17
+];
+```
+
+Pour récuper une valeur particulière, on utilisera sa clef. 
+
+```php
+$resultat_fevrier = $resultats['février'];
+echo $resultat_fevrier; 
+```
+
+Ce code renverra la valeur ```32```.
+
+On peut aussi modifier une valeur dans un tableau :
+
+```php
+$resultats['février'] = 29;
+```
+
+ ## Ressources
+
+* [Apprendre à gérer les tableaux en PHP par Grafikart](https://grafikart.fr/tutoriels/tableaux-php-1116#autoplay)
\ No newline at end of file
diff --git a/docs/04-php/04-conditions.md b/docs/04-php/04-conditions.md
new file mode 100644
index 0000000..e4f7cc6
--- /dev/null
+++ b/docs/04-php/04-conditions.md
@@ -0,0 +1,45 @@
+---
+sidebar_position: 4
+---
+
+# Les conditions en PHP
+ 
+En PHP comme dans presque tous les langages de programmation, le concept des conditions est incontournable. Il consiste à pouvoir gérer le cas où l'on souhaite qu'un bout de code soit exécuté si une condition est remplie.
+
+Pour écrire une condition, on utilise le mot-clé ```if```, suivi entre parenthèses de la condition, puis d'un bloc de code entouré par des accolades.
+
+Exemple :
+
+```php
+if($age >= 18) {
+    echo 'vous êtes majeur';
+}
+```
+
+Ici, si la valeur de la variable ```$age``` est supérieure ou égale )à 18, on écrit un message.
+
+On peut éventuellement ajouter un autre bout de code qui sera exécuté si la condition n'est pas remplie.
+
+Exemple :
+
+```php
+if($age >= 18) {
+    echo 'vous êtes majeur';
+} else {
+    echo 'vous êtes mineur';
+}
+```
+
+Dans la condition, on utilise des opérateurs de comparaison, comme ```===``` pour une égalité stricte, ```>``` ou ```<``` pour supérieur ou inférieur, ```>=``` ou ```<=``` pour supérieur ou égal et inférieur ou égal, ou encore ```!==``` pour une différence.
+
+On peut également utiliser une version raccourcie, qu'on appelle une ternaire pour écrire une condition sur une seule ligne.
+
+Exemple :
+
+```php
+$phrase = 'Vous êtes ' . ($age >= 18 ? 'majeur' : 'mineur');
+```
+
+ ## Ressources
+
+* [Apprendre à gérer les conditions en PHP par Grafikart](https://grafikart.fr/tutoriels/conditions-php-1117#autoplay)
\ No newline at end of file
diff --git a/docs/04-php/05-boucles.md b/docs/04-php/05-boucles.md
new file mode 100644
index 0000000..426f5fb
--- /dev/null
+++ b/docs/04-php/05-boucles.md
@@ -0,0 +1,75 @@
+---
+sidebar_position: 5
+---
+
+# Les boucles en PHP
+ 
+En PHP comme dans presque tous les langages de programmation, le concept des boucles est incontournable. 
+
+Il consiste à pouvoir répeter une instruction ou un bloc de code autant de fois qu'on le désire ou tant qu'une condition est remplie ou non.
+
+Il existe différents types de boucle en PHP :
+
+- les boucles ```for```
+- les boucles ```while```
+- les boucles ```for each```
+
+#### Boucle for
+
+Elle permet de répeter les choses un nombre défini de fois. Imaginons qu'on souhaite réaliser un compteur :
+
+```php
+for ($i = 1; $i <= 5; $i++) {
+    echo "compteur: " . $i;
+}
+```
+
+Dans ce code, on part avec ```$i``` à 1. On indique qu'on continue tant que ```$i``` est inférieur ou égal à 5. On explique ensuite qu'on va incrémenter ```$i``` de 1 à chaque tour avec ```$i++``` (on aurait pu écrire ```$i = $i + 1```). Au premier tour, on va afficher ```1```, puis ```2``` au deuxième tour, et ainsi de suite jusqu'à ```5``` au dernier tour.
+
+#### Boucle while
+
+Elle permet de répeter les choses tant qu'une condition est remplie. En reprennant l'exemple de la boucle ```for```, cela donne :
+
+```php
+$i = 1;
+while ($i <= 5) {
+    echo "compteur: " . $i;
+    $i++;
+}
+```
+
+On peut également remplacer le ```$i++``` par ```$i = $i + 1```.
+
+
+#### Boucle for each
+
+Elle permet de parcourir les élements d'un tableau.
+
+```php
+$tableau = [2, 4, 6, 8];
+foreach ($tableau as $valeur){
+    echo $valeur;
+}
+```
+
+Cette boucle affichera d'abord ```2```, puis ```4``` puis ```6``` puis ```8```.
+
+On peut aussi extraire les clefs d'un tableau : 
+
+```php
+$tableau = [
+    'nom' => 'Doe',
+    'prenom' => 'John',
+    'age' => 32
+];
+
+foreach ($tableau as $clef => $valeur){
+    echo $clef . ': ' . $valeur;
+}
+```
+
+Cette boucle affichera d'abord ```Nom: Doe```, puis ```prenom: John``` puis ```age: 32```.
+
+ ## Ressources
+
+* [Apprendre à gérer les boucles en PHP par Grafikart](https://grafikart.fr/tutoriels/boucles-php-1118#autoplay)
\ No newline at end of file
diff --git a/docs/04-php/06-fonctions.md b/docs/04-php/06-fonctions.md
new file mode 100644
index 0000000..d3f8fee
--- /dev/null
+++ b/docs/04-php/06-fonctions.md
@@ -0,0 +1,37 @@
+---
+sidebar_position: 6
+---
+
+# Les fonctions en PHP
+
+Les fonctions permettent d'encapsuler du code pour pouvoir le réutiliser facilement. On peut appeller une fonction soi-même ou bien la déclencher lorsqu'un qu'un évênement arrive.
+
+Une fonction peut prendre en entrée des paramètres que l'on va utiliser dans le contenu de la fonction. Elle peut aussi retourner une valeur.
+
+Prenons un example :
+
+```php
+function sayHello(string $prenom) {
+    return 'Bonjour ' . $prenom
+}
+```
+
+Cette fonction permet de renvoyer une chaine de caractère qui dit ```bonjour``` suivi d'un prénom que l'on a passé en paramètre. Pour l'appeler, on écrira par exemple ```sayHello('Bob')```.
+
+Les paramètres peuvent prendre des valeurs par défaut. 
+
+
+```php
+function sayHello(string $prenom="Bob"): string
+{
+    return 'Bonjour ' . $prenom
+}
+```
+
+Ici, si on appelle la fonction sans lui passer de paramètre, elle renverra ```Bonjour Bob'```.
+
+On peut typer les paramètres et le retour. Ici, on indique que notre paramètre est un chaine de caractère et que leretour de la fonction l'est aussi.
+
+ ## Ressources
+
+* [Apprendre à gérer les fonctions par Grafikart](https://grafikart.fr/tutoriels/fonctions-utilisateurs-php-1120#autoplay)
\ No newline at end of file
diff --git a/docs/04-php/07-POO.md b/docs/04-php/07-POO.md
new file mode 100644
index 0000000..5eb5ba4
--- /dev/null
+++ b/docs/04-php/07-POO.md
@@ -0,0 +1,51 @@
+---
+sidebar_position: 7
+---
+
+# La programmation oritentée objet en PHP
+ 
+Il serait bien difficule de décrire en totalité les principes de la programmation orientée objet (POO) en quelques lignes. Nous allons juste voir quelques exemples rapidement.
+
+Imaginons que vous travailliez sur un annuaire. Vous allez donc devoir gérer des personnes. Chacune aura par exemple un nom, un prénom et un email. C'est l'occasion de ce créer un type d'objet dédié, en écrivant ce qu'on appelle une classe.
+
+```php
+class Person {
+
+    constructor (
+        public string $firstname, 
+        public string $lastname, 
+        public string $email
+        ) {}
+}
+```
+
+Dans cette classe, on définit des propriétés grâce à la méthode ```constructor```. Quand on va construire un objet ```Person```, on le fera comme ceci :
+
+```
+$personne = new Person('John', 'Doe', 'john.doe@gmail.com');
+```
+
+Pour récupérer l'email on écrira ```$personne->email;```.
+
+On peut aussi écrire des méthodes dans notre classe. Par exemple, rajoutons une méthode qui renverra une chaine formatée pour afficher la personne :
+
+```php
+class Person {
+
+    constructor (
+        public string $firstname, 
+        public string $lastname, 
+        public string $email
+        ) {}
+
+    public function getFormated() {
+        return "$this->firstName $this->lastname : $this->email";
+    }
+}
+```
+
+On pourra donc utiliser cette méthode sur l'objet en écrivant ```$personne->getFormated()```. Cela renverra ```John Doe : john.doe@gmail.com```.
+
+## Ressources
+
+* [Apprendre la POO en PHP par Lior Chamla](https://www.youtube.com/watch?v=fZcGXjg97Ns&ab_channel=LiorCHAMLA-WebDevelopMe)
\ No newline at end of file
diff --git a/docs/04-php/08-namespaces.md b/docs/04-php/08-namespaces.md
new file mode 100644
index 0000000..9777ea7
--- /dev/null
+++ b/docs/04-php/08-namespaces.md
@@ -0,0 +1,66 @@
+---
+sidebar_position: 8
+---
+
+# Les espaces de nom en PHP
+ 
+Quand on écrit du code PHP, on souhaite que celui-ci soit bien rangé. En effet, on va écrire beaucoup de code, de classes et on souhaite que tout soit à sa place. 
+
+Pour cela, on va utiliser ce qu'on appelle des espaces de noms, ou **namespace** en anglais. L'idée est de déclarer dans le fichier l'emplacement de la classe. Par exemple : 
+
+```php
+<?php
+
+namespace App\Entity;
+
+class Video
+{}
+```
+
+Ici on déclare que la classe ```Video``` est rangé dans un dossier ```Entity```, lui même rangé dans un dossier ```App```. Ce premier dossier ```App``` n'est pas forcément un dossier réel, c'est le point d'entrée de notre architecture. 
+
+Pour déclarer un point d'entrée, nous avons besoin de définir ce qu'on appelle un **autoloader**. C'est cela qui va indiquer à PHP à quel dossier réel correspond le namespace ```App```.
+
+Pour mettre en place un autoloader, on utilise composer. Pour cela, on tape dans la console la commande suivante : 
+
+```
+composer init
+```
+
+Cela va créer un fichier ```composer.json``` à la racine du projet. Puis, dans ce fichier, vous rajoutez une clef ```autoload``` qui va indiquer le point d'entrée (ici, le dossier ```src```) :
+
+```json
+"autoload": {
+    "psr-4": {
+        "App\\": "src/"
+    }
+}
+```
+
+Puis vous tapez la commande suivante pour enregister l'autoloader :
+
+```
+composer dump-autoload
+```
+
+Vous pouvez maintenant utiliser l'autoloader. Par exemple, dans une autre classe, qui va utiliser la classe ```Video```, vous pouvez l'importer en utilise le mot clef ```use```, comme ceci : 
+
+```php
+use App\Entity\Video;
+
+class VideoController 
+{
+    public function index(): Response
+    {
+        $video = new Video();
+    }
+}
+```
+
+Ici, cette classe saura qu'il faut aller chercher la classe Video dans le dossier ```src/Entity```.
+
+## Ressources
+
+* [Apprendre les namespaces en PHP par Grafikart](https://grafikart.fr/tutoriels/namespace-php-1143#autoplay)
+
+* [Apprendre à utiliser l'autoloader par Grafikart](https://grafikart.fr/tutoriels/autoloader-composer-php-1144#autoplay)
\ No newline at end of file
diff --git a/docs/04-php/09-composer.md b/docs/04-php/09-composer.md
new file mode 100644
index 0000000..ed6a71c
--- /dev/null
+++ b/docs/04-php/09-composer.md
@@ -0,0 +1,23 @@
+---
+sidebar_position: 9
+---
+
+# Composer avec PHP
+ 
+ Aujourd'hui, quand on écrit du code, on ne code pas tout à la main. On utilise parfois du code qui a été écrit par d'autres et qui est disponible en Open Source. 
+
+ Il existe des dizaines de milliers de librairies que l'on peut télécharger sur [Packagist](https://packagist.org/). Mais on va utiliser [Composer](https://getcomposer.org/) pour les installer sur notre machine. 
+
+ Une fois composer installé, il suffit de taper ```composer require``` suivi du nom de la librairie. 
+
+ Imaginons que nous souhaitions installer dans notre projet la librairie [Symfony Var Dumper](https://packagist.org/packages/symfony/var-dumper), qui permet de disposer d'un ```var_dump``` plus complet que l'original. Il suffit de taper ```composer require symfony/var-dumper```. SI on n'en a besoin que pour le développement, on tape ```composer require --dev symfony/var-dumper```
+
+ Cela va créer un dossier ```vendor``` à la racine du projet, dans lequel la librairie va être téléchargée. Pour l'utiliser, il suffit de faire un ```dump($ma_variable);```. Pour d'autres librairies, vous aurez sans doute besoin d'ajouter un ```use``` suivi du namespace de la librairie.
+
+ Une fois la librairie téléchargée, un fichier ```composer.json``` est créé ou mis à jour à la racine du projet. Il liste toutes les librairies dont le projet a besoin et qui peuvent être installées avec Composer.
+
+ Le dossier ```vendor``` n'a pas vocation à être versionné. Si vous supprimez le dossier ```vendor```, ou si vous récupérez un projet via ```Git```, il vous suffit de taper ```composer install``` pour installer toutes les dépendances du projet. 
+
+## Ressources
+
+* [Apprendre à gérer composer par Grafikart](https://grafikart.fr/tutoriels/composer-require-1146#autoplay)
\ No newline at end of file
diff --git a/docs/04-php/xx-langage-php.md b/docs/04-php/xx-langage-php.md
index 0dbe31a..583812d 100644
--- a/docs/04-php/xx-langage-php.md
+++ b/docs/04-php/xx-langage-php.md
@@ -1,5 +1,5 @@
 ---
-sidebar_position: 1
+sidebar_position: 10
 ---
 
 # le langage php