PHP

Le langage de programmation côté serveur qui alimente une grande partie du web, offrant simplicité, flexibilité et puissance pour les développeurs.

Retour aux compétences Documentation PHP

Pour les non-initiés

Qu'est-ce que PHP ?

PHP (qui signifie "PHP: Hypertext Preprocessor") est un langage de programmation qui s'exécute sur le serveur web et génère des pages web dynamiques. Si vous visualisez un site web comme une maison, le HTML serait la structure, le CSS la décoration, et PHP serait les systèmes qui font fonctionner la maison : électricité, plomberie, etc.

Créé en 1994, PHP est aujourd'hui l'un des langages les plus utilisés au monde pour le développement web. Il alimente des millions de sites, des blogs personnels aux plus grandes plateformes comme Facebook, Wikipedia ou WordPress (qui représente plus de 40% de tous les sites web).

Pourquoi PHP est-il si populaire ?

Facilité d'apprentissage

PHP est conçu pour être simple à apprendre et à utiliser, même pour les débutants en programmation.

Écosystème riche

Une vaste bibliothèque de fonctions intégrées, des frameworks puissants et une grande communauté de développeurs.

En résumé, PHP est le "couteau suisse" du développement web, offrant une solution efficace et accessible pour créer toutes sortes d'applications, des sites vitrines aux plateformes complexes comme des réseaux sociaux ou des systèmes e-commerce.

Pour les développeurs

Fonctionnement technique

PHP est un langage de programmation interprété, conçu spécifiquement pour le développement web. Il s'exécute côté serveur et génère du HTML qui est ensuite envoyé au navigateur client. PHP peut être intégré directement dans le HTML ou utilisé avec des frameworks modernes comme Symfony suivant le modèle MVC.

Les bases du langage

Syntaxe et fonctionnalités de base

PHP possède une syntaxe inspirée du C et propose un large éventail de fonctionnalités pour manipuler des chaînes, des tableaux, et interagir avec le système de fichiers.

PHP - Notions de base

<?php
// Exemple de script PHP simple
$greeting = "Bonjour";
$name = "Monde";

// Concaténation de chaînes
echo $greeting . " " . $name . "!"; // Affiche: Bonjour Monde!

// Conditions
$heure = date("H");
if ($heure < 12) {
    echo "<p>Bonne matinée!</p>";
} else if ($heure < 18) {
    echo "<p>Bon après-midi!</p>";
} else {
    echo "<p>Bonne soirée!</p>";
}

// Boucles
echo "<ul>";
for ($i = 1; $i <= 5; $i++) {
    echo "<li>Point " . $i . "</li>";
}
echo "</ul>";

// Tableaux
$fruits = ["pomme", "banane", "orange", "fraise"];
echo "<p>J'aime particulièrement les " . $fruits[2] . "s.</p>";

// Tableaux associatifs
$personne = [
    "prenom" => "Marie",
    "nom" => "Dupont",
    "age" => 32,
    "ville" => "Paris"
];

echo "<p>" . $personne["prenom"] . " " . $personne["nom"];
echo " habite à " . $personne["ville"] . ".</p>";

// Fonctions
function calculerTVA($montantHT, $tauxTVA = 20) {
    return $montantHT * (1 + $tauxTVA / 100);
}

$prixHT = 100;
$prixTTC = calculerTVA($prixHT);
echo "<p>Prix TTC : " . $prixTTC . "€</p>";

Programmation orientée objet

Depuis PHP 5, le langage offre un support complet pour la programmation orientée objet, avec des concepts comme l'encapsulation, l'héritage et le polymorphisme.

PHP - Programmation orientée objet

<?php
// Exemple de programmation orientée objet en PHP

/**
 * Classe représentant un produit
 */
class Product {
    private $id;
    private $name;
    private $price;
    private $description;
    private $category;
    
    public function __construct(int $id, string $name, float $price) {
        $this->id = $id;
        $this->name = $name;
        $this->price = $price;
    }
    
    public function getId(): int {
        return $this->id;
    }
    
    public function getName(): string {
        return $this->name;
    }
    
    public function setName(string $name): self {
        $this->name = $name;
        return $this;
    }
    
    public function getPrice(): float {
        return $this->price;
    }
    
    public function setPrice(float $price): self {
        if ($price < 0) {
            throw new InvalidArgumentException("Le prix ne peut pas être négatif");
        }
        $this->price = $price;
        return $this;
    }
    
    public function getDescription(): ?string {
        return $this->description;
    }
    
    public function setDescription(?string $description): self {
        $this->description = $description;
        return $this;
    }
    
    public function getCategory(): ?string {
        return $this->category;
    }
    
    public function setCategory(?string $category): self {
        $this->category = $category;
        return $this;
    }
    
    public function getPriceWithTax(float $taxRate = 20): float {
        return $this->price * (1 + $taxRate / 100);
    }
    
    public function formatPrice(string $currencySymbol = "€"): string {
        return number_format($this->price, 2, ",", " ") . " " . $currencySymbol;
    }
}

// Utilisation de la classe
$product = new Product(1, "Smartphone Galaxy X10", 999.99);
$product->setDescription("Dernier modèle avec écran pliable")
        ->setCategory("Électronique");

echo "Produit: " . $product->getName() . "<br>";
echo "Prix HT: " . $product->formatPrice() . "<br>";
echo "Prix TTC: " . number_format($product->getPriceWithTax(), 2, ",", " ") . " €<br>";
echo "Catégorie: " . $product->getCategory() . "<br>";

Interactions avec les bases de données

PHP offre plusieurs options pour interagir avec les bases de données comme MySQL ou PostgreSQL, PDO (PHP Data Objects) étant l'API la plus moderne et sécurisée.

PHP - Interactions avec les bases de données

<?php
// Exemple d'interaction avec une base de données en PHP (PDO)

// Configuration de la connexion
$host = 'localhost';
$db   = 'ma_boutique';
$user = 'utilisateur';
$pass = 'mot_de_passe';
$charset = 'utf8mb4';

$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES   => false,
];

try {
    // Création de la connexion PDO
    $pdo = new PDO($dsn, $user, $pass, $options);
    
    // ---- LECTURE ----
    // Préparation de la requête SELECT
    $stmt = $pdo->prepare("SELECT id, name, price, category FROM products WHERE category = :category ORDER BY price DESC LIMIT :limit");
    
    // Exécution avec paramètres
    $category = "Électronique";
    $limit = 5;
    $stmt->bindParam(':category', $category, PDO::PARAM_STR);
    $stmt->bindParam(':limit', $limit, PDO::PARAM_INT);
    $stmt->execute();
    
    // Récupération des résultats
    $products = $stmt->fetchAll();
    
    // Affichage des résultats
    echo "<h3>Produits de la catégorie $category:</h3>";
    echo "<ul>";
    foreach ($products as $product) {
        echo "<li>" . htmlspecialchars($product['name']) . " - " . 
             number_format($product['price'], 2, ',', ' ') . " €</li>";
    }
    echo "</ul>";
    
    // ---- ÉCRITURE ----
    // Insertion d'un nouveau produit
    $stmt = $pdo->prepare("INSERT INTO products (name, description, price, category, created_at) 
                          VALUES (:name, :description, :price, :category, NOW())");
    
    $newProduct = [
        'name' => 'Écouteurs sans fil Pro',
        'description' => 'Écouteurs avec réduction active du bruit',
        'price' => 199.99,
        'category' => 'Électronique'
    ];
    
    $stmt->execute($newProduct);
    $newId = $pdo->lastInsertId();
    
    echo "<p>Nouveau produit ajouté avec l'ID: " . $newId . "</p>";
    
    // ---- MISE À JOUR ----
    // Mise à jour d'un produit existant
    $stmt = $pdo->prepare("UPDATE products SET price = :price WHERE id = :id");
    $stmt->execute([
        'id' => $newId,
        'price' => 189.99
    ]);
    
    $affectedRows = $stmt->rowCount();
    echo "<p>Mise à jour effectuée: " . $affectedRows . " ligne(s) modifiée(s).</p>";
    
    // ---- SUPPRESSION ----
    // Suppression d'un produit (commenté pour sécurité)
    /*
    $stmt = $pdo->prepare("DELETE FROM products WHERE id = :id");
    $stmt->execute(['id' => $newId]);
    $affectedRows = $stmt->rowCount();
    echo "<p>Suppression effectuée: " . $affectedRows . " ligne(s) supprimée(s).</p>";
    */
    
    // ---- TRANSACTION ----
    // Utilisation des transactions pour des opérations groupées
    $pdo->beginTransaction();
    
    try {
        // Mise à jour du stock après une vente
        $stmt = $pdo->prepare("UPDATE products SET stock = stock - :quantity WHERE id = :product_id");
        $stmt->execute(['product_id' => 1, 'quantity' => 2]);
        
        // Enregistrement de la vente
        $stmt = $pdo->prepare("INSERT INTO sales (product_id, quantity, sale_date) VALUES (:product_id, :quantity, NOW())");
        $stmt->execute(['product_id' => 1, 'quantity' => 2]);
        
        // Si tout s'est bien passé, on valide la transaction
        $pdo->commit();
        echo "<p>Transaction terminée avec succès!</p>";
    } catch (Exception $e) {
        // En cas d'erreur, on annule tout
        $pdo->rollBack();
        echo "<p>Erreur: " . $e->getMessage() . "</p>";
    }
    
} catch (PDOException $e) {
    throw new PDOException($e->getMessage(), (int)$e->getCode());
}

Création d'APIs REST

PHP peut être utilisé pour créer des APIs RESTful performantes, soit manuellement soit à l'aide de frameworks comme Symfony ou Laravel.

PHP - Création d'une API REST

<?php
// Exemple d'API REST en PHP

// Headers pour une API REST
header('Content-Type: application/json');
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE');
header('Access-Control-Allow-Headers: Content-Type, Authorization');

// Si la requête est OPTIONS (pré-vérification CORS), on s'arrête ici
if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
    exit(0);
}

// Configuration de la connexion à la BDD
$pdo = new PDO('mysql:host=localhost;dbname=api_db;charset=utf8mb4', 'user', 'password', [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
]);

// Récupérer le point de terminaison et l'ID demandés depuis l'URL
$uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$uri = explode('/', $uri);

// L'endpoint est le 3ème segment de l'URI (ex: /api/products)
$endpoint = isset($uri[2]) ? $uri[2] : null;
// L'ID est le 4ème segment (ex: /api/products/5)
$id = isset($uri[3]) ? (int) $uri[3] : null;

// Récupérer la méthode HTTP
$method = $_SERVER['REQUEST_METHOD'];

// Gestion du routage basique pour l'endpoint "products"
if ($endpoint === 'products') {
    switch ($method) {
        case 'GET':
            if ($id) {
                // GET /api/products/{id}
                getProduct($pdo, $id);
            } else {
                // GET /api/products
                getProducts($pdo);
            }
            break;
        case 'POST':
            // POST /api/products
            createProduct($pdo);
            break;
        case 'PUT':
            // PUT /api/products/{id}
            if ($id) {
                updateProduct($pdo, $id);
            } else {
                http_response_code(400);
                echo json_encode(['error' => 'ID manquant pour la mise à jour']);
            }
            break;
        case 'DELETE':
            // DELETE /api/products/{id}
            if ($id) {
                deleteProduct($pdo, $id);
            } else {
                http_response_code(400);
                echo json_encode(['error' => 'ID manquant pour la suppression']);
            }
            break;
        default:
            http_response_code(405);
            echo json_encode(['error' => 'Méthode non autorisée']);
            break;
    }
} else {
    http_response_code(404);
    echo json_encode(['error' => 'Endpoint non trouvé']);
}

// Fonction pour récupérer tous les produits
function getProducts($pdo) {
    try {
        $stmt = $pdo->prepare('SELECT * FROM products');
        $stmt->execute();
        $products = $stmt->fetchAll();
        
        echo json_encode([
            'data' => $products,
            'meta' => [
                'total' => count($products)
            ]
        ]);
    } catch (PDOException $e) {
        http_response_code(500);
        echo json_encode(['error' => 'Erreur serveur: ' . $e->getMessage()]);
    }
}

// Fonction pour récupérer un produit par son ID
function getProduct($pdo, $id) {
    try {
        $stmt = $pdo->prepare('SELECT * FROM products WHERE id = ?');
        $stmt->execute([$id]);
        $product = $stmt->fetch();
        
        if ($product) {
            echo json_encode(['data' => $product]);
        } else {
            http_response_code(404);
            echo json_encode(['error' => 'Produit non trouvé']);
        }
    } catch (PDOException $e) {
        http_response_code(500);
        echo json_encode(['error' => 'Erreur serveur: ' . $e->getMessage()]);
    }
}

// Fonction pour créer un produit
function createProduct($pdo) {
    try {
        // Récupération des données envoyées
        $data = json_decode(file_get_contents('php://input'), true);
        
        // Validation minimale
        if (!isset($data['name']) || !isset($data['price'])) {
            http_response_code(400);
            echo json_encode(['error' => 'Données incomplètes']);
            return;
        }
        
        $stmt = $pdo->prepare('INSERT INTO products (name, description, price, category) VALUES (?, ?, ?, ?)');
        $stmt->execute([
            $data['name'],
            $data['description'] ?? null,
            $data['price'],
            $data['category'] ?? null
        ]);
        
        $id = $pdo->lastInsertId();
        
        http_response_code(201);
        echo json_encode([
            'data' => array_merge(['id' => $id], $data),
            'message' => 'Produit créé avec succès'
        ]);
    } catch (PDOException $e) {
        http_response_code(500);
        echo json_encode(['error' => 'Erreur serveur: ' . $e->getMessage()]);
    }
}

// Les fonctions updateProduct et deleteProduct suivraient le même modèle

Écosystème et outils

Composer - Gestionnaire de dépendances pour PHP, équivalent à npm pour JavaScript
PHP-FPM - Process manager FastCGI pour PHP, optimisant les performances
PHPUnit - Framework de tests unitaires pour PHP
Xdebug - Extension pour le débogage, le profilage et l'analyse de code
PHP_CodeSniffer - Outil de vérification de la qualité du code
Packagist - Dépôt principal des packages PHP

Frameworks populaires

Laravel - Le framework PHP le plus populaire, connu pour son élégance et sa simplicité
Symfony - Framework robuste et flexible, souvent utilisé pour des applications d'entreprise
CodeIgniter - Framework léger avec une empreinte minimale
Yii - Framework hautes performances pour les applications web modernes
CakePHP - Framework simple et rapide pour le développement web
Laminas (anciennement Zend Framework) - Collection de packages professionnels

Avantages et inconvénients

Avantages

Courbe d'apprentissage douce
Large support sur les hébergeurs web
Grande communauté et documentation
Intégration facile avec HTML
Écosystème riche de bibliothèques

Inconvénients

Inconsistances historiques dans la syntaxe
Performances limitées par rapport aux langages compilés
Risques de sécurité si mal utilisé
Typage faible (amélioré dans PHP 7+)

Applications concrètes

Cas d'usage

Systèmes de gestion de contenu (CMS)

PHP est à la base des CMS les plus populaires comme WordPress, Drupal et Joomla, permettant de créer et gérer des sites web sans connaissances techniques approfondies.

E-commerce

Des plateformes comme Magento, WooCommerce et PrestaShop utilisent PHP pour créer des boutiques en ligne complètes avec gestion des produits, paniers et paiements.

APIs RESTful

PHP moderne avec des frameworks comme Laravel et Symfony est largement utilisé pour créer des APIs performantes qui alimentent des applications web et mobiles.

Applications d'entreprise

PHP est utilisé pour développer des systèmes de gestion interne, des CRM, des ERP et autres applications métier critiques grâce à sa facilité d'intégration avec les bases de données.