🐘 PHP – Installation, Syntaxe & Écosystème

Positionnement : PHP vs Node.js vs Python

PHP est souvent comparé à d'autres langages de backend.

En résumé : PHP excelle par sa simplicité de déploiement et son écosystème mature (WordPress...). Il est synchrone, ce qui le rend plus simple à déboguer que Node.js pour des tâches web classiques.

LEMP / Nginx + PHP-FPM (Recommandé)

C'est l'architecture moderne et performante. Nginx (très rapide pour les fichiers statiques) et PHP-FPM (FastCGI Process Manager) sont deux services **séparés**.

[Image d'une architecture Nginx FPM]
+--------------------------------------+
| SERVEUR NGINX (Non-bloquant)         |
| (Sert CSS, JS, Images...)            |
|                                      |
| (Requête .php ?) ------------------+ |
+--------------------------------------+
                                     | (FastCGI)
                                     | (via Socket ou TCP 9000)
                                     ▼
+--------------------------------------+
| SERVICE PHP-FPM (Process Manager)    |
|                                      |
| (Pool de workers PHP)                |
|  [Worker 1] [Worker 2] [Worker 3]    |
+--------------------------------------+

• Avantage : Nginx gère les statiques (rapide), FPM gère le PHP (dédié).
• Avantage : FPM gère un "pool" de workers, bien plus efficace en mémoire.
• Avantage : Sécurisé. FPM peut tourner avec un utilisateur différent de Nginx.

Windows (WAMP / XAMPP)

Pour le développement Windows, XAMPP est la solution la plus simple. Elle installe une stack complète (Apache, MariaDB, PHP, PhpMyAdmin).

1. Allez sur apachefriends.org
2. Téléchargez et lancez l'installeur XAMPP.
3. Lancez le "XAMPP Control Panel".
4. Cliquez "Start" sur Apache et "Start" sur MySQL.
5. Placez vos fichiers PHP dans C:\xampp\htdocs\
6. Ouvrez votre navigateur sur http://localhost/

Docker (Environnement de Dev Moderne)

Utiliser Docker Compose est la meilleure façon de reproduire un environnement de production (Nginx, FPM, DB séparés).

docker-compose.yml (Exemple)

version: "3.8"
services:
  # 1. Le serveur Web
  nginx:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./src:/var/www/html
      - ./nginx.conf:/etc/nginx/conf.d/default.conf

  # 2. Le service PHP
  php:
    image: php:8.3-fpm-alpine
    volumes:
      - ./src:/var/www/html

  # 3. La BDD
  db:
    image: mariadb:10.11
    environment:
      MARIADB_ROOT_PASSWORD: root_secret
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data:

Placez vos fichiers PHP dans ./src/ et votre nginx.conf (cf 7.2) puis lancez docker compose up -d. Accédez via http://localhost:8080.

Comparaison : == vs === (Crucial)

C'est la source d'erreur n°1 des débutants.

== (Égalité - Valeur seule)

Compare les valeurs *après* "type juggling".

"10" == 10     // true (string "10" est converti en int 10)
0 == false     // true (0 est "falsy")
0 == null      // true
"" == null     // true

=== (Identique - Valeur ET Type)

Recommandé. Compare les valeurs ET les types. Pas de conversion.

"10" === 10    // false (string vs int)
0 === false    // false (int vs bool)
0 === null     // false

!= (Différent) vs !== (Non-identique)

"10" != 10     // false
"10" !== 10    // true

Opérateurs (Sélection)

Scope (Portée des variables)

Les fonctions ont un scope isolé. Elles n'ont pas accès aux variables extérieures, sauf si on les passe en paramètre.

$nom = "Alice"; // Scope global

function saluer() {
    echo $nom; // Erreur: Undefined variable $nom
}

function saluer_ok($nom_local) {
    echo $nom_local; // OK
}
saluer_ok($nom);

Mot-clé global (À éviter)

$nom = "Alice";
function saluer_global() {
    global $nom; // Importe $nom
    echo $nom;
}
// (Ceci est considéré comme une mauvaise pratique)

Fonctions Anonymes (Closures)

Une fonction stockée dans une variable. Très utilisée pour les callbacks (ex: array_map).

$nombres = [1, 2, 3];

$double = function($n) {
    return $n * 2;
};

$nombres_doubles = array_map($double, $nombres);
// [2, 4, 6]

// Utilisation du 'use' (Closure)
$facteur = 10;
$multiplier = function($n) use ($facteur) {
    return $n * $facteur; // $facteur est importé du scope parent
};
$nombres_x10 = array_map($multiplier, $nombres);
// [10, 20, 30]

Fonctions Fléchées (Arrow Functions) (PHP 7.4+)

Une syntaxe plus courte pour les closures simples, qui capture automatiquement le scope.

$facteur = 10;
$nombres = [1, 2, 3];

// 'fn' capture $facteur automatiquement
$nombres_x10 = array_map(fn($n) => $n * $facteur, $nombres);

$_SERVER (Infos Serveur & Requête)

Un tableau contenant des informations sur le serveur et la requête.

$_ENV & .env

$_ENV contient les variables d'environnement du système.

Pratique moderne : Ne pas stocker les secrets (ex: BDD) dans le code. Utiliser un fichier .env à la racine (exclu de Git).

# .env
DB_HOST=localhost
DB_USER=mon_user
DB_PASS=mon_pass_secret

Puis utiliser Composer (cf 6.1) pour installer une librairie qui charge ce fichier :

composer require vlucas/phpdotenv

<?php
require 'vendor/autoload.php';
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

// La variable est maintenant dispo
$db_host = $_ENV['DB_HOST'];
?>

JSON (JavaScript Object Notation)

Le format standard pour les APIs et les configs.

// Array PHP
$user = ["nom" => "Alice", "age" => 30];

// 1. Array PHP -> String JSON
$json_string = json_encode($user, JSON_PRETTY_PRINT);
/*
{
    "nom": "Alice",
    "age": 30
}
*/
file_put_contents("user.json", $json_string);

// 2. String JSON -> Array PHP
$json_lu = file_get_contents("user.json");
$user_array = json_decode($json_lu, true); // 'true' = array associatif

echo $user_array['nom']; // "Alice"

Uploads ($_FILES)

HTML (upload.html)

<!-- 'enctype' est obligatoire pour les fichiers -->
<form action="upload.php" method="POST" enctype="multipart/form-data">
    <label>Avatar:</label>
    <input type="file" name="avatar_file">
    <button type="submit">Envoyer</button>
</form>

PHP (upload.php)

<?php
if ($_SERVER['REQUEST_METHOD'] === 'POST' && isset($_FILES['avatar_file'])) {

    $file = $_FILES['avatar_file'];

    // 1. Vérifier les erreurs
    if ($file['error'] !== UPLOAD_ERR_OK) {
        die("Erreur d'upload (Code: " . $file['error'] . ")");
    }
    
    // 2. Infos du fichier
    $nom_original = $file['name'];
    $type_mime = $file['type'];
    $taille = $file['size'];
    $chemin_temporaire = $file['tmp_name']; // (ex: /tmp/phpAbc12)
    
    // 3. (Valider type, taille...)
    
    // 4. Déplacer le fichier
    $dossier_uploads = __DIR__ . '/uploads/';
    $nouveau_chemin = $dossier_uploads . basename($nom_original);
    
    if (move_uploaded_file($chemin_temporaire, $nouveau_chemin)) {
        echo "Fichier uploadé !";
    } else {
        echo "Échec du déplacement.";
    }
}
?>

$this (L'objet lui-même)

À l'intérieur d'une méthode, $this fait référence à l'instance actuelle de l'objet ($user1 ou $user2).

__construct (Constructeur)

Cette méthode magique est appelée automatiquement lors du new. Parfait pour initialiser l'objet.

class Utilisateur {
    public $nom;
    public $email;
    
    // 1. Le constructeur
    public function __construct(string $nom_init, string $email_init) {
        $this->nom = $nom_init;
        $this->email = $email_init;
        echo "Utilisateur créé !";
    }
    
    public function saluer() {
        // $this fait référence à l'objet courant
        echo "Bonjour, " . $this->nom;
    }
}

$user1 = new Utilisateur("Alice", "alice@mail.com");
$user1->saluer();

PHP 8+ : Promotion des Propriétés

Syntaxe raccourcie (très pratique) :

class Utilisateur {
    // PHP crée $nom et $email automatiquement
    public function __construct(
        public string $nom,
        public string $email
    ) {
        // (Corps vide)
    }
}

Visibilité (Encapsulation)

Permet de contrôler l'accès aux propriétés/méthodes.

• public : Accessible partout (par l'objet, par les classes enfants, et de l'extérieur).
• protected : Accessible par la classe et ses classes enfants (Héritage).
• private : Accessible *uniquement* par la classe elle-même.

class CompteBancaire {
    private float $solde; // Privé !
    
    public function __construct(float $depot_initial) {
        $this->solde = $depot_initial;
    }
    
    // "Getter" public
    public function getSolde(): float {
        return $this->solde;
    }
    
    // "Setter" public
    public function deposer(float $montant) {
        if ($montant > 0) {
            $this->solde += $montant;
        }
    }
}
$compte = new CompteBancaire(100);
// $compte->solde = -500; // Erreur Fatale ! (private)
$compte->deposer(50);
echo $compte->getSolde(); // 150

static

Lié à la Classe, pas à l'objet. On utilise self:: (ou static::).

class MathUtil {
    public static float $pi = 3.14;
    
    public static function addition(int $a, int $b): int {
        return $a + $b;
    }
}
// Pas de 'new'
echo MathUtil::$pi;
echo MathUtil::addition(5, 10);

Interfaces (implements)

Une Interface est un "contrat". Elle définit les méthodes qu'une classe **doit** implémenter, mais pas *comment*.

// Le Contrat
interface Forme {
    public function calculerAire(): float;
}

interface Colorable {
    public function setCouleur(string $c);
}

// Implémentation (oblige à définir calculerAire() et setCouleur())
class Carre implements Forme, Colorable {
    private $cote;
    private $couleur;
    
    public function __construct($cote) { $this->cote = $cote; }
    
    public function calculerAire(): float {
        return $this->cote * $this->cote;
    }
    
    public function setCouleur(string $c) {
        $this->couleur = $c;
    }
}

class Cercle implements Forme {
    private $rayon;
    
    public function __construct($rayon) { $this->rayon = $rayon; }
    
    public function calculerAire(): float {
        return pi() * ($this->rayon ** 2);
    }
}

Classes Abstraites (abstract)

Un mélange entre une classe et une interface. Elle ne peut pas être instanciée (pas de new). Elle peut contenir des méthodes implémentées (normales) ET des méthodes abstraites (non-implémentées).

// Classe abstraite (ne peut pas faire 'new Vehicule')
abstract class Vehicule {
    protected $vitesse = 0;
    
    // Méthode implémentée
    public function rouler() {
        $this->vitesse = 50;
    }
    
    // Méthode abstraite (Contrat pour les enfants)
    abstract public function getNombreRoues(): int;
}

class Voiture extends Vehicule {
    // Doit implémenter la méthode abstraite
    public function getNombreRoues(): int {
        return 4;
    }
}

class Moto extends Vehicule {
    public function getNombreRoues(): int {
        return 2;
    }
}

$v = new Voiture();
$v->rouler();
echo $v->getNombreRoues(); // 4

Traits (Réutilisation horizontale)

PHP n'autorise pas l'héritage multiple. Un "Trait" est un "copier-coller" de méthodes que vous pouvez "use" dans une classe.

// 1. Le Trait (un ensemble de méthodes)
trait LoggerTrait {
    public function log(string $message) {
        echo "LOG: $message";
    }
}

// 2. Les Classes
class Article {
    use LoggerTrait; // "Copie" les méthodes
    
    public function save() {
        $this->log("Article sauvegardé");
    }
}
class Commentaire {
    use LoggerTrait;
    
    public function post() {
        $this->log("Commentaire posté");
    }
}

$article = new Article();
$article->save(); // "LOG: Article sauvegardé"

Méthodes Magiques

Méthodes spéciales (commençant par __) appelées automatiquement par PHP.

composer.json (Le Fichier de Config)

Définit les dépendances du projet.

{
    "name": "ideo-lab/mon-projet",
    "description": "Un projet d'exemple",
    "type": "project",
    "require": {
        "php": ">=8.1",
        "monolog/monolog": "^3.0",
        "guzzlehttp/guzzle": "^7.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^10.0"
    },
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

Commandes

# Initialiser un projet
composer init

# Ajouter une dépendance de prod
composer require monolog/monolog

# Ajouter une dépendance de dev
composer require --dev phpunit/phpunit

# Installer les dépendances (d'après composer.lock)
composer install

# Mettre à jour les dépendances (d'après composer.json)
composer update

Autoloading (PSR-4)

Fini les require_once ! Composer génère un "autoloader".

Grâce à la section autoload du composer.json :

"autoload": {
    "psr-4": {
        "App\\": "src/"
    }
}

Composer sait que App\CRM\Utilisateur se trouve dans src/CRM/Utilisateur.php.

index.php (Le Point d'Entrée)

<?php
// 1. Inclure l'autoloader (LA SEULE INCLUSION NÉCESSAIRE)
require_once __DIR__ . '/vendor/autoload.php';

// 2. Utiliser les classes (locales ou vendor)
use App\CRM\Utilisateur;
use Monolog\Logger;
use Monolog\Handler\StreamHandler;

// 3. Composer charge les fichiers automatiquement
$log = new Logger('ideolab');
$log->pushHandler(new StreamHandler('app.log', Logger::WARNING));

$user = new Utilisateur();

$log->warning('Un utilisateur a été créé.');
?>

Solution : Requêtes Préparées (prepare & execute)

On envoie la "structure" (? ou :placeholder) et les "données" (variables) séparément. Le SGBD les assemble de manière sécurisée.

1. Placeholders (?)

$id_user = $_GET['id'];
$statut = 'actif';

// 1. Préparer
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ? AND statut = ?");

// 2. Exécuter (envoie les données)
$stmt->execute([ $id_user, $statut ]);

$user = $stmt->fetch();

2. Placeholders nommés (:nom) (Recommandé)

$id_user = $_GET['id'];
$statut = 'actif';

$sql = "SELECT * FROM users WHERE id = :id_param AND statut = :statut_param";
$stmt = $pdo->prepare($sql);

$stmt->execute([
    ':id_param' => $id_user,
    ':statut_param' => $statut
]);
$user = $stmt->fetch();

Lire les résultats (SELECT)

$stmt = $pdo->prepare("SELECT * FROM users WHERE statut = ?");
$stmt->execute(['actif']);

// 1. fetch() - Pour 1 seul résultat
$user = $stmt->fetch(); // Retourne un array ou 'false'
if ($user) {
    echo $user['nom'];
}

// 2. fetchAll() - Pour plusieurs résultats
$users = $stmt->fetchAll(); // Retourne un array de arrays
foreach ($users as $user) {
    echo $user['nom'];
}

INSERT, UPDATE, DELETE

$sql = "INSERT INTO users (nom, email) VALUES (:nom, :email)";
$pdo->prepare($sql)->execute([
    ':nom' => 'Nouveau User',
    ':email' => 'new@mail.com'
]);

// Récupérer le dernier ID inséré
$last_id = $pdo->lastInsertId();

// Obtenir le nombre de lignes affectées (UPDATE/DELETE)
$sql = "UPDATE users SET nom = ? WHERE id = ?";
$stmt = $pdo->prepare($sql);
$stmt->execute(['Nom Modifié', 10]);
$nb_lignes = $stmt->rowCount();

Faille : XSS (Cross-Site Scripting)

Risque : Un attaquant injecte du JavaScript (<script>) dans votre page, qui s'exécute chez vos visiteurs (ex: vol de cookies de session).

Exemple faillible : (L'utilisateur met <script>alert(1);</script> dans son nom)

$nom = $_POST['nom']; // Vient de l'utilisateur
// (Sauvegarde en BDD...)
// (Plus tard...)
$nom_bdd = $user['nom'];
echo "<h1>Bienvenue, " . $nom_bdd . "</h1>";
// Le navigateur exécute le script !

Solution : Échapper le HTML à l'affichage (htmlspecialchars)

// Échapper TOUJOURS les données utilisateur avant de les 'echo'
echo "<h1>Bienvenue, " . htmlspecialchars($nom_bdd) . "</h1>";
// Résultat HTML: <h1>Bienvenue, &lt;script&gt;...</h1>
// (Le navigateur affiche le texte, n'exécute pas le script)

Faille : Stockage de Mots de Passe

Risque : Si votre BDD fuite, tous les mots de passe sont en clair (ou facilement réversibles si md5/sha1).

Exemple faillible :

// NE JAMAIS FAIRE ÇA
$pass_md5 = md5($_POST['password']);
$pdo->query("INSERT INTO users (pass) VALUES ('$pass_md5')");

Solution : password_hash & password_verify

Utilise des algorithmes de hachage modernes (ex: bcrypt) avec "sel" (salt) automatique.

// 1. Inscription (Stocker le hash)
$pass_clair = $_POST['password'];
$hash = password_hash($pass_clair, PASSWORD_BCRYPT);
// $hash = "$2y$10$..." (long string de 60+ chars)
$stmt = $pdo->prepare("INSERT INTO users (pass_hash) VALUES (?)");
$stmt->execute([$hash]);

// 2. Connexion (Vérifier le hash)
$pass_clair_login = $_POST['password'];
$hash_bdd = $user['pass_hash'];

if (password_verify($pass_clair_login, $hash_bdd)) {
    // Mot de passe correct !
    $_SESSION['user_id'] = $user['id'];
} else {
    // Mot de passe incorrect
}

Nginx + FPM (Production)

La configuration Nginx (/etc/nginx/sites-available/default) doit savoir quels fichiers envoyer à FPM.

server {
    listen 80;
    server_name ideolab.com;
    root /var/www/html/public; # Racine (souvent 'public')

    # Fichier d'index
    index index.php index.html;
    
    # "Front Controller" (belles URLs)
    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    # C'est la partie clé :
    # Envoyer les scripts .php à FPM
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        
        # Socket UNIX (plus rapide)
        fastcgi_pass unix:/var/run/php/php8.3-fpm.sock;
        
        # (Alternative: TCP)
        # fastcgi_pass 127.0.0.1:9000;
    }
    
    # Interdire l'accès aux .htaccess (sécurité)
    location ~ /\.ht {
        deny all;
    }
}