# PHP - Les bases
## Introduction
Sur le web, on distingue deux grandes catégories de langages : ceux qui s'exécutent **côté client**, comme HTML, CSS ou JavaScript, et ceux qui s'exécutent **côté serveur**, comme PHP.
Les langages côté client fonctionnent uniquement dans le navigateur de l'utilisateur. Ils sont visibles et modifiables par celui-ci, et ne permettent pas de gérer des données sensibles ou de créer des applications accessibles en continu à grande échelle.
En revanche, les langages côté serveur, comme PHP (Hypertext Preprocessor), permettent d'exécuter du code sur des serveurs connectés en permanence à Internet. Ces serveurs restent allumés 24h/24, ce qui permet à des milliers d'utilisateurs d'accéder simultanément à des services comme des sites web dynamiques, des boutiques en ligne ou des plateformes de gestion de données.
Pour travailler en PHP, il faut disposer d'un environnement spécifique capable d'exécuter du code serveur. Cet environnement comprend généralement :
* un serveur web (Apache, Nginx)
* PHP
* un système de gestion de bases de données (MySQL, MariaDB)
* éventuellement un outil d'administration comme phpMyAdmin
## Environnements de développement
### Solutions traditionnelles
Pendant longtemps, les développeurs utilisaient des logiciels appelés **serveurs locaux** pour installer facilement cet environnement sur leur ordinateur. Voici quelques outils populaires :
* [WAMP](https://www.wampserver.com/) (Windows)
* [XAMPP](https://www.apachefriends.org/fr/index.html) (Windows / Linux / Mac)
* [MAMP](https://www.mamp.info/en/) (Mac / Windows)
* [Laragon](https://laragon.org/) (Windows)
Ces solutions fonctionnent bien, mais peuvent poser des problèmes de compatibilité ou de configuration selon la machine ou le système utilisé.
### Pourquoi utiliser Docker ?
Aujourd'hui, on privilégie souvent [Docker](https://www.docker.com/) pour créer un environnement de développement PHP. Docker permet d'isoler chaque projet dans un **conteneur**, embarquant tout ce dont il a besoin (serveur web, PHP, base de données, etc.).
**Avantages de Docker :**
✅ Plus moderne et flexible
✅ Évite les conflits entre projets ou versions
✅ Permet de reproduire exactement le même environnement sur n'importe quelle machine
✅ Simplifie l'installation, la mise à jour ou la suppression d'un environnement
En résumé, Docker garantit que votre projet PHP fonctionnera de manière identique chez tous les développeurs et sur le serveur de production.
Dans ce cours, nous utiliserons donc **Docker** pour travailler avec PHP, MySQL et phpMyAdmin afin de bénéficier d’un environnement moderne, fiable et professionnel.
:::info
 **phpMyAdmin** est une application web gratuite écrite en PHP conçue pour gérer les bases de données MySQL via une interface graphique web. Elle permet d'effectuer une grande variété d'opérations sur MySQL et MariaDB, y compris la gestion des bases de données, des tables, des colonnes, des relations, des index, des utilisateurs et des permissions. phpMyAdmin est particulièrement apprécié pour sa facilité d'utilisation, car il permet aux utilisateurs, même ceux ayant peu de connaissances techniques, de gérer les bases de données sans avoir à utiliser la ligne de commande.
:::
:::success
Voir l'annexe sur la l'installation et la configuration avec Docker
:::
### Configuration de php
La configuration de PHP se fait dans un fichier appelé "php.ini"
Tout d'abord pour obtenir les informations de configuration de php, il faut créer un fichier `info.php` et insérez les lignes suivantes dans le fichier:
```php=
<?php
phpinfo();
?>
```
Pour executer le script, ouvrez la page `info.php` sur votre navigateur.
Votre page est visible à l'adresse **http://localhost/info.php** (attention le port est 80 par défaut mais il peut changer selon votre configuration).
>☝ Ouvrez le fichier `php.ini` situer dans le dossier d'installation de php.
Assurez-vous que les clés de configuration `error_reporting` et `display_errors` ont respectivement les valeurs `E_ALL` & `on`
> ✔ Installer **xdebug** à l'aide de l'outil en ligne https://xdebug.org/wizard
> Xdebug est une extension pour PHP et fournit une gamme de fonctionnalités pour améliorer l'expérience de développement PHP.
### Les balises php
Les instructions PHP sont placées entre les balises **`<?php ?>`**
```php
<?php
// Instruction 1
// Instruction 2
// ...
?>
```
### echo — Afficher une chaîne de caractères
```php=
<?php
$world = "world";
echo "hello $world";
?>
```
:::info
A noter que PHP peut afficher directement le texte dans la fenêtre du navigateur mais beaucoup de langage serveur affiche le texte dans une console.
:::
Syntaxe courte avec des balises PHP
On peut se passer de `echo` dans ce contexte
```php=
<?php
$world = "world";
?>
<p>Hello <?=$world?></p>
```
### Les commentaires
#### Les commentaires monolignes
```php=
// Ceci est un commentaire sur une seule ligne
```
#### Les commentaires multilignes
```php=
/* Ceci est un commentaire sur plusieurs ligne
On peut écrire davantage */
```
## Les variables
Une variable est une petite information qui reste stockée en mémoire le temps de la génération de la page PHP. Elle a un nom et une valeur.
En PHP, un nom de variable commence par le symbole dollar : `$age` par exemple.
La valeur d'une variable peut être affichée avec l'instruction `echo` .
Les variables sont capables de stocker différents types d'informations. On parle de types de données.
**Exemple de données** | **Description** | **Exemple de valeur**
--- | --- | ---
**string** | Une chaîne de caractère | `Du texte`
**integer** | Un nombre entier | `42`
**double (float)** | Un nombre à virgule flottante | `3.14`
**bool** | Un bool représente une valeur de vérité. Il peut valoir true (vrai) ou false (faux) | `true` ou `false`
**null** | La valeur spéciale null représente une variable sans valeur (vide) | `null`
:::info
Une variable est considérée comme null si :<br>
- elle s'est vue assigner la constante null.<br>
- elle n'a pas encore reçu de valeur.<br>
- elle a été effacée avec la fonction unset().
:::
Voir la page de documentation :
- https://www.php.net/manual/fr/language.types.php
- https://www.php.net/manual/fr/function.gettype.php
```php=
<?php
// Voici comment déclarer une variable
$age_toto = 17
$age_titi = "vingt"
$age_tata = 'quarante'
```
:::danger
Notez qu'on ne peut pas mettre d'espace dans un nom de variable.
À la place, utilisez un underscore `_`
De manière général évitez les caractères spéciaux.
:::
:::spoiler Les constantes
Les constantes en PHP sont des identifiants (noms) pour des valeurs simples qui, une fois définies, ne peuvent pas être modifiées pendant l'exécution du script. Elles sont souvent utilisées pour stocker des valeurs qui ne changent pas, comme des valeurs de configuration, des chemins de fichiers, des clés API, etc.
### Utilité des Constantes
1. **Lisibilité et Maintenance** : Les constantes rendent le code plus lisible et plus facile à maintenir. Par exemple, utiliser `MAX_SIZE` au lieu d'un nombre magique comme `1024` dans le code rend ce dernier plus compréhensible.
2. **Sécurité** : Modifier une constante par accident dans le code peut générer une erreur, ce qui aide à prévenir les modifications non désirées.
3. **Performance** : L'utilisation de constantes peut parfois améliorer les performances, car la valeur est déterminée au moment de la compilation et non à chaque exécution.
### Déclaration de Constantes
En PHP, vous pouvez définir une constante en utilisant la fonction `define()` ou le mot-clé `const`. Par exemple :
```php
define("MAX_SIZE", 1024);
const API_KEY = "your-api-key";
```
### Exemples avec `$_SERVER` pour gérer les chemins
`$_SERVER` est une superglobale en PHP qui contient des informations sur les en-têtes, les chemins et les emplacements des scripts. Vous pouvez l'utiliser pour définir des constantes pour les chemins dans un projet.
```php
define("ROOT_PATH", $_SERVER['DOCUMENT_ROOT']);
define("APP_PATH", ROOT_PATH . '/mon_application');
```
Dans cet exemple, `ROOT_PATH` est définie comme étant le chemin racine du serveur web, et `APP_PATH` utilise cette constante pour définir le chemin d'un sous-dossier spécifique.
### Utilisation dans un Contexte Réel
Supposons que vous ayez un projet avec des fichiers de configuration, des bibliothèques et des templates stockés dans différents dossiers. Vous pouvez définir des constantes pour ces chemins :
```php
define("CONFIG_PATH", APP_PATH . '/config');
define("LIB_PATH", APP_PATH . '/lib');
define("TEMPLATE_PATH", APP_PATH . '/templates');
```
Cela vous permet de faire référence à ces chemins dans votre code de manière cohérente et facile à comprendre, par exemple :
```php
require_once(LIB_PATH . '/maBibliotheque.php');
```
L'utilisation de constantes pour les chemins de fichiers est particulièrement utile dans les grands projets où les chemins sont susceptibles d'être réutilisés dans de nombreux scripts. Cela simplifie les modifications de l'architecture du projet, car vous n'avez besoin de modifier le chemin qu'à un seul endroit.
:::
### La concaténation
La concaténation signifie assemblage.
La concaténation est un moyen d'afficher du texte et des variables.
#### Concaténer avec des **guillemets doubles**
Avec des guillemets doubles, c'est le plus simple. Vous pouvez écrire le nom de la variable au milieu du texte et il sera remplacé par sa valeur.
Concrètement, essayez ce code :
```php=
<?php
$age_du_visiteur = 17;
echo "Le visiteur a $age_du_visiteur ans";
?>
```
Ça affiche : `Le visiteur a 17 ans`
#### Concaténer avec des **guillemets simples**
On relie les chaînes de caractères et les variables avec des points `.`
```php=
<?php
$age_du_visiteur = 17;
echo 'Le visiteur a ' . $age_du_visiteur . ' ans';
?>
```
Ça affiche : : `Le visiteur a 17 ans`
> ☝ Notez que cette méthode d'écriture est un peu plus rapide, car PHP voit de suite où se trouve la variable et n'a pas besoin de la chercher au milieu du texte.
### Les opérateurs arithmétiques
Vous rappelez-vous des opérations élémentaires apprises à l'école ? Les opérateurs arithmétiques fonctionnent comme elles.
Symbole | Signification
--- | ---
**+** | Addition
**-** | Soustraction
**\*** | Multiplication
**/** | Division
> Voir la page de documentation : https://www.php.net/manual/fr/language.operators.arithmetic.php
Faisons des calculs simples avec quelques exemples :
```php=
<?php
echo 6*7;
$nombre = 2 + 4; // $nombre prend la valeur 6
$nombre = 5 - 1; // $nombre prend la valeur 4
$nombre = 3 * 5; // $nombre prend la valeur 15
$nombre = 10 / 2; // $nombre prend la valeur 5
// Allez on rajoute un peu de difficulté
$nombre = 3 * 5 + 1; // $nombre prend la valeur 16
$nombre = (1 + 2) * 2; // $nombre prend la valeur 6
echo $nombre; // Affiche la valeur 6
?>
```
:::warning
Si vous assignez plusieurs valeurs a la même variable, c'est la dernière valeur qui sera pris en compte
:::
#### Le modulo
Le modulo représente le reste de la division entière.
Par exemple, 6 / 3 = 2 et il n'y a pas de reste. En revanche, 7 / 3 = 2 (car le nombre 3 « rentre » 2 fois dans le nombre 7) et il reste 1. Vous avez fait ce type de calculs à l'école primaire, souvenez-vous !
Le modulo permet justement de récupérer ce « reste ». Pour faire un calcul avec un modulo, on utilise le symbole `%` .
```php=
<?php
$nombre = 10 % 5; // $nombre prend la valeur 0 car la division tombe juste
$nombre = 10 % 3; // $nombre prend la valeur 1 car il reste 1
?>
```
## if - else
### Les opérateurs de comparaison
Symbole | Signification
--- | ---
**==** | Est égale à
**>** | Est supérieur à
**<** | Est inférieur à
**>=** | Est supérieur ou égal à
**<=** | Est inférieur ou égal à
**!=** | Est diférent de
> Voir la page de documentation : https://www.php.net/manual/fr/language.operators.comparison.php
Maintenant passons au teste
#### Syntaxe 1
$resultat= true;
Si cela est vrai alors...
```php=
if ( $resultat ) {
// alors ...
}
else{
// sinon ...
}
```
> Voir la page de documentation :
https://www.php.net/manual/fr/control-structures.elseif.php
#### Syntaxe 2
$resultat= true;
Si cela est different de vrai (true) alors...
```php=
if ( !$resultat ) :
// alors ...
else :
// sinon ...
endif;
```
### Les opérateurs logigues
Mot-clé | Signification | Symbole équivalent
--- | --- | ---
**AND** | Et| `&&`
**OR** | Ou | `\|\|`
Voir la page de documentation : https://www.php.net/manual/fr/language.operators.logical.php
```php=
$html = true;
$css = false;
$php = true;
$js = true;
$django = false;
if ($html == true && $css == true && $js == true) {
echo "FRONT-END"; //faux
} elseif ($php == true || $django == true && $js == true ) {
echo "BACK-END"; //vrai
} else {
echo "Apprentissae en-cours"; //faux
}
```
### Les opérateurs ternaires
Considérons le teste suivant
```php=
$userLangage = "fr";
$lang = "";
if (!empty($userLangage)) {
$lang = $userLangage;
} else {
$lang = "en";
}
```
Avec l'opérateur ternaire cela pourrait s'écrire
```php=
$userLangage = "fr";
$lang = $userLangage ? $userLangage : "en";
```
> Voir la page de documentation : https://www.php.net/manual/fr/language.operators.comparison.php#language.operators.comparison.ternary
> Voir l'ensemble des opérateurs dans la documentation : https://www.php.net/manual/fr/language.operators.php
## switch - case
Ici on réalise un test qui teste plusieurs cas :
### Syntaxe 1
```php=
$userLang = "fr";
switch ($userLang){
case "fr":
echo "FR";
break;
case "en":
echo "EN";
break;
case "it":
echo "IT";
break;
case "es":
echo "ES";
break;
default:
echo "Select userLang";
break;
}
```
### Syntaxe 2
```php=
$userLang = "fr";
switch ($userLang):
case "fr":
echo "FR";
break;
case "en":
echo "EN";
break;
case "it":
echo "IT";
break;
case "es":
echo "ES";
break;
default:
echo "Select userLang";
break;
endswitch;
```
## Les boucles
### while
On répète une instruction tant que le teste est vrai
#### Syntaxe 1
```php=
$compteur = 0;
while ($compteur <= 10){
echo $compteur;
$compteur++;
}
```
#### Syntaxe 2
```php=
$compteur = 0;
while ($compteur <= 10):
echo $compteur;
$compteur++;
endwhile;
```
### for
Ici on répète une instruction pour une sequence donnée
#### Syntaxe 1
```php=
for ($compteur = 1; $compteur <= 100; $compteur++){
echo $compteur;
}
```
#### Syntaxe 2
```php=
for ($compteur = 1; $compteur <= 100; $compteur++):
echo $compteur;
endfor;
```
## Les tableaux
Les tableaux, ou array, servent a stocker plusieurs valeurs dans une même variable.
Cela peut s'apparenter à une liste de valeur.
On dispose de différents type de tableau.
### Les tableaux numérotés
```php=
// La fonction array permet de créer un array
$prenoms = array ('François', 'Michel', 'Nicole', 'Véronique', 'Benoît');
```
ou bien
```php=
$prenoms[] = 'François'; // Créera $prenoms[0]
$prenoms[] = 'Michel'; // Créera $prenoms[1]
$prenoms[] = 'Nicole'; // Créera $prenoms[2]
```
ou bien
```php=
$prenoms[0] = 'François';
$prenoms[1] = 'Michel';
$prenoms[2] = 'Nicole';
```
### Les tableaux associatifs
```php=
$coordonnees = array (
'prenom' => 'François',
'nom' => 'Dupont',
'adresse' => '3 Rue du Paradis',
'ville' => 'Marseille');
```
ou bien
```php=
$coordonnees['prenom'] = 'François';
$coordonnees['nom'] = 'Dupont';
$coordonnees['adresse'] = '3 Rue du Paradis';
$coordonnees['ville'] = 'Marseille';
```
### Afficher un élément d'un tableau
```php=
echo $prenoms[0];
echo $coordonnees['ville'];
```
Bien que des valeurs soient stockées dans un tableau, on ne peut pas afficher directement les valeurs à l'utilisateur (Le visiteur)
> Voir aussi `print_r($prenoms)` ou `var_dump($prenoms)`
### Afficher tous les éléments d'un tableau avec une boucle
#### Avec la boucle for
En connaissant a l'avance la longueur du tableau, on peut afficher chaque valeur à l'aide de la boucle for.
```php=
// On crée notre array $prenoms
$prenoms = array ('François', 'Michel', 'Nicole', 'Véronique', 'Benoît');
// Puis on fait une boucle pour tout afficher :
for ($numero = 0; $numero < 5; $numero++){
echo $prenoms[$numero] . '<br />'; // affichera $prenoms[0], $prenoms[1] etc.
}
```
:::info
Ici 5 peut être remplacé par une fonction qui retournerait directement la "longueur" du tableau.
:::
#### Avec la boucle foreach
Sans se soucier de la longueur du tableau, on peut afficher chaque valeur à l'aide de la boucle foreach.
```php=
$prenoms = array ('François', 'Michel', 'Nicole', 'Véronique', 'Benoît');
foreach($prenoms as $prenom)
{
echo $prenom . '<br>'; // affichera $prenoms[0], $prenoms[1] etc.
}
```
Afficher la valeur de l'index également
```php=
$coordonnees = array (
'prenom' => 'François',
'nom' => 'Dupont',
'adresse' => '3 Rue du Paradis',
'ville' => 'Marseille');
foreach($coordonnees as $key => $value)
{
echo '[' . $key . '] : ' . $value . '<br>';
}
```
## Les fonctions
### Les fonctions définies par l'utilisateur
```php=
function hello($name){
echo 'hello ' . $name;
}
hello('Toto');
```
### Les fonctions internes
#### gettype()
Retourne le type de la variable value. Pour vérifier le type de la variable, vous pouvez utiliser les fonctions is_*.
#### Fonctions sur les tableaux
- **array_key_exists() :** pour vérifier si une clé existe dans l'array
- **in_array() :** pour vérifier si une valeur existe dans l'array
- **array_search() :** pour récupérer la clé d'une valeur dans l'array
#### Vérifier le contenu d'une variable
PHP function | "" | "apple" | NULL | FALSE | 0 | undefined
--- | --- | --- | --- | --- | --- | ---
**_empty()_** | TRUE | FALSE | TRUE | TRUE | TRUE | TRUE
**_is_null()_** | FALSE | FALSE | TRUE | FALSE | FALSE | ERROR
**_isset()_** | TRUE | TRUE | FALSE | TRUE | TRUE | FALSE
#### Date
```php
date();
```
Paramètre | Description
--- | ---
**H** | Heure
**i** | Minute
**d** | Jour
**m** | Mois
**Y** | Année
<!--
### Pour aller plus loin
Voir "comment lire la définition d'une fonction (prototype)" https://www.php.net/manual/fr/about.prototypes.php
-->
{%hackmd @alternative-rvb/contact %}
Sign in with Wallet
Connect another wallet