⚠️ Article 4 — Les erreurs PHP courantes et comment les éviter

Guide complet pour comprendre, corriger et prévenir les erreurs les plus fréquentes en PHP. Syntaxe, exécution, erreurs logiques et bonnes pratiques.

🎯 Objectif

Comprendre les erreurs les plus fréquentes rencontrées en PHP, apprendre à les corriger efficacement et adopter de bonnes pratiques pour les prévenir.

1️⃣ Introduction

Pourquoi les erreurs en PHP sont inévitables

En tant que développeur PHP, vous rencontrerez inévitablement des erreurs, surtout si vous débutez. Ces erreurs font partie du processus d'apprentissage et sont des opportunités d'améliorer votre code.

L'importance de savoir lire les messages d'erreur

Un bon développeur n'est pas celui qui ne fait jamais d'erreurs, mais celui qui sait les comprendre et les corriger rapidement. Les messages d'erreur PHP contiennent des informations précieuses :

Type d'erreur : Syntaxe, avertissement, fatal
Fichier concerné : Où l'erreur s'est produite
Ligne exacte : Localisation précise du problème
Description : Nature de l'erreur

Objectif de cet article

Notre objectif est de vous apprendre à :

Identifier les différents types d'erreurs PHP
Comprendre leurs causes et implications
Résoudre efficacement chaque type d'erreur
Prévenir les erreurs grâce aux bonnes pratiques

2️⃣ Les types d'erreurs en PHP

a. Erreurs de syntaxe

Les erreurs de syntaxe sont les plus courantes chez les débutants. Elles se produisent lorsque le code PHP n'est pas correctement écrit.

                    // ❌ ERREUR : point-virgule manquant

                    <?php

                    $nom = "Jean" // Point-virgule oublié

                    echo $nom;

                    ?>

                    // ✅ CORRECTION

                    <?php

                    $nom = "Jean";

                    echo $nom;

                    ?>

🔧 Comment les corriger :

Vérifiez les points-virgules manquants
Contrôlez les parenthèses, crochets et guillemets fermants
Utilisez un IDE avec coloration syntaxique (VS Code, PhpStorm)
Activez le linter PHP dans votre éditeur

b. Erreurs d'exécution (runtime errors)

Ces erreurs se produisent pendant l'exécution du script, lorsque PHP tente d'effectuer une opération impossible.

                    // ❌ ERREUR : fonction inexistante

                    <?php

                    ma_fonction_inexistante(); // Cette fonction n'existe pas

                    ?>

                    // Message d'erreur :

                    Fatal error: Uncaught Error: Call to undefined function ma_fonction_inexistante()

                    // ✅ CORRECTION

                    <?php

                    function ma_fonction() {

                        echo "Fonction appelée !";

                    }

                    ma_fonction();

                    ?>

c. Erreurs logiques

Les erreurs les plus difficiles à détecter : le script s'exécute sans message d'erreur mais ne produit pas le résultat attendu.

                    // ❌ ERREUR LOGIQUE : condition inversée

                    <?php

                    $age = 25;

                    if ($age = 18) { // = au lieu de ==

                        echo "Majeur";

                    } else {

                        echo "Mineur";

                    }

                    ?>

                    // ✅ CORRECTION

                    <?php

                    $age = 25;

                    if ($age >= 18) {

                        echo "Majeur";

                    } else {

                        echo "Mineur";

                    }

                    ?>

🔍 Solution pour les erreurs logiques :

Utilisez le débogage avec var_dump(), print_r() ou echo pour suivre l'exécution de votre programme et vérifier les valeurs des variables.

d. Warnings et notices

Ces erreurs ne stoppent pas l'exécution du script mais indiquent des problèmes potentiels.

                    // ❌ WARNING : clé de tableau indéfinie

                    <?php

                    $utilisateur = ['nom' => 'Jean'];

                    echo $utilisateur['prenom']; // Clé inexistante

                    ?>

                    // Message : Warning: Undefined array key "prenom"

                    // ✅ CORRECTION

                    <?php

                    $utilisateur = ['nom' => 'Jean'];

                    echo $utilisateur['prenom'] ?? 'Non défini';

                    ?>

3️⃣ Comment afficher et comprendre les erreurs

Configuration dans php.ini

Pour le développement, activez l'affichage des erreurs dans votre fichier php.ini :

                    ; Dans php.ini - Configuration pour le développement

                    display_errors = On

                    display_startup_errors = On

                    error_reporting = E_ALL

                    log_errors = On

                    error_log = "chemin/vers/php_errors.log"

Configuration dans le code PHP

Vous pouvez aussi configurer l'affichage des erreurs directement dans votre code :

                    // En tête de votre script PHP

                    <?php

                    // Pour le développement

                    ini_set('display_errors', 1);

                    ini_set('display_startup_errors', 1);

                    error_reporting(E_ALL);

                    // Pour la production

                    ini_set('display_errors', 0);

                    ini_set('log_errors', 1);

                    ini_set('error_log', '/chemin/vers/errors.log');

                    ?>

Comprendre les niveaux d'erreur

📊 Niveaux d'erreur courants :

E_ERROR : Erreur fatale, arrêt du script
E_WARNING : Avertissement, le script continue
E_NOTICE : Notice, information non critique
E_PARSE : Erreur de syntaxe
E_ALL : Toutes les erreurs et avertissements

Lecture des fichiers de logs

En production, consultez régulièrement les fichiers de logs :

Serveur web (Apache/Nginx logs)
Logs PHP (error_log)
Logs d'application personnalisés

4️⃣ Bonnes pratiques pour éviter les erreurs

Vérification des variables

                    // ✅ BONNES PRATIQUES

                    <?php

                    // Avant d'utiliser une variable

                    if (isset($_POST['email']) && !empty($_POST['email'])) {

                        $email = trim($_POST['email']);

                    } else {

                        $erreurs[] = "L'email est obligatoire";

                    }

                    // Vérification avec opérateur de coalescence null

                    $nom = $_POST['nom'] ?? 'Valeur par défaut';

                    ?>

Validation des entrées utilisateur

                    <?php

                    function validerEmail($email) {

                        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {

                            return false;

                        }

                        return true;

                    }

                    function sanitizerChaine($chaine) {

                        return htmlspecialchars(trim($chaine), ENT_QUOTES, 'UTF-8');

                    }

                    ?>

Gestion des exceptions avec try...catch

                    <?php

                    try {

                        // Code potentiellement problématique

                        $resultat = division(10, 0);

                    } catch (DivisionByZeroError $e) {

                        // Gestion de l'erreur

                        error_log("Division par zéro : " . $e->getMessage());

                        echo "Erreur : Division par zéro impossible";

                    } catch (Exception $e) {

                        // Gestion des autres exceptions

                        error_log("Exception : " . $e->getMessage());

                        echo "Une erreur est survenue";

                    }

                    ?>

💡 Bonnes pratiques supplémentaires :

Décomposez votre code en petites fonctions testables
Documentez votre code avec des commentaires clairs
Utilisez des outils d'analyse statique comme PHPStan ou Psalm
Écrivez des tests unitaires pour valider votre code
Versionnez votre code avec Git

5️⃣ Outils utiles pour le débogage

Fonctions de débogage natives

                    <?php

                    $tableau = ['pomme', 'banane', 'orange'];

                    // Affichage simple

                    echo "<pre>";

                    print_r($tableau);

                    echo "</pre>";

                    // Affichage détaillé avec types

                    echo "<pre>";

                    var_dump($tableau);

                    echo "</pre>";

                    // Journalisation

                    error_log("Valeur de tableau : " . print_r($tableau, true));

                    ?>

Extensions et outils visuels

🛠️ Outils recommandés :

Xdebug : Débogueur puissant avec profilage
Debug Bar : Barre de débogage pour applications web
Ray : Outil de débogage élégant et moderne
Blackfire.io : Profilage des performances

Système de logs personnalisé

                    <?php

                    function logger($message, $niveau = 'INFO') {

                        $timestamp = date('Y-m-d H:i:s');

                        $logMessage = "[$timestamp] [$niveau] $message" . PHP_EOL;

                        // Écriture dans un fichier

                        file_put_contents('logs/app.log', $logMessage, FILE_APPEND | LOCK_EX);

                        // En production, envoyer vers un service de logs

                    }

                    // Utilisation

                    logger("Utilisateur connecté : ID 123");

                    logger("Erreur de connexion base de données", "ERROR");

                    ?>

6️⃣ Erreurs fréquentes en pratique

Connexion à la base de données

                    // ❌ MAUVAISE GESTION

                    <?php

                    $pdo = new PDO("mysql:host=localhost;dbname=ma_base", "user", "pass");

                    // Si la connexion échoue, erreur fatale

                    ?>

                    // ✅ BONNE GESTION

                    <?php

                    try {

                        $pdo = new PDO(

                            "mysql:host=localhost;dbname=ma_base",

                            "user",

                            "pass",

                            [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]

                        );

                    } catch (PDOException $e) {

                        error_log("Erreur connexion BDD : " . $e->getMessage());

                        echo "Service temporairement indisponible";

                        exit();

                    }

                    ?>

Inclusion de fichiers

                    // ❌ CHEMIN RELATIF PROBLÉMATIQUE

                    <?php

                    include('config.php'); // Peut échouer selon le contexte

                    ?>

                    // ✅ CHEMIN ABSOLU RECOMMANDÉ

                    <?php

                    $racine = $_SERVER['DOCUMENT_ROOT'];

                    include($racine . '/includes/config.php');

                    // Ou avec __DIR__ (PHP 5.3+)

                    include(__DIR__ . '/config.php');

                    ?>

Gestion des sessions

                    // ❌ MAUVAISE GESTION DES SESSIONS

                    <?php

                    // session_start() appelé après output

                    echo "Début de page";

                    session_start(); // Erreur : headers déjà envoyés

                    ?>

                    // ✅ BONNE GESTION

                    <?php

                    // session_start() toujours en premier

                    session_start();

                    $_SESSION['user_id'] = 123;

                    ?>

                    <!DOCTYPE html>

                    <html>

                    <!-- Contenu HTML -->

🚨 Autres erreurs courantes :

Variables globales mal utilisées : Préférez l'injection de dépendances
Problèmes d'encodage : Utilisez UTF-8 systématiquement
Gestion des timezones : Configurez date_default_timezone_set()
Cookies mal sécurisés : Utilisez les flags HttpOnly et Secure

7️⃣ Conclusion

✅ Récapitulatif des principaux points :

Erreurs de syntaxe : Vérifiez la ponctuation et utilisez un IDE
Erreurs d'exécution : Gérer les exceptions et vérifier l'existence des fonctions
Erreurs logiques : Utilisez le débogage pas à pas
Warnings et notices : Ne les ignorez pas, corrigez-les
Configuration : Activez l'affichage des erreurs en développement
Outils : Utilisez Xdebug, var_dump() et les systèmes de logs

Bonnes pratiques à adopter dès maintenant

Configurez correctement l'environnement de développement
Validez systématiquement les entrées utilisateur
Utilisez try...catch pour gérer les exceptions
Écrivez des logs pour tracer les erreurs
Testez votre code dans différents scénarios
Documentez les cas d'erreur connus

🚀 Prochain article

Dans notre prochain tutoriel, nous plongerons dans la programmation orientée objet (POO) en PHP !

👉 "Introduction à la programmation orientée objet (POO) en PHP"

Découvrez les classes, objets, héritage, encapsulation et polymorphisme pour écrire un code plus structuré et réutilisable.

Questions Fréquentes sur les Erreurs PHP

Comment désactiver l'affichage des erreurs en production ?

En production, configurez display_errors = Off dans le php.ini et utilisez log_errors = On pour enregistrer les erreurs dans un fichier de log. Vous pouvez aussi utiliser ini_set('display_errors', 0) dans votre code.

Quelle est la différence entre une exception et une erreur en PHP ?

Les exceptions sont des objets qui peuvent être attrapés et gérés avec try/catch, tandis que les erreurs sont des problèmes plus graves qui peuvent arrêter l'exécution du script. Depuis PHP 7, la plupart des erreurs fatales sont converties en exceptions Error.

Comment déboguer un script PHP qui ne produit aucun message d'erreur ?

Vérifiez d'abord que l'affichage des erreurs est activé. Utilisez error_reporting(E_ALL) et ini_set('display_errors', 1). Si le problème persiste, utilisez var_dump() ou error_log() pour tracer l'exécution.

Qu'est-ce qu'un "fatal error" et comment l'éviter ?

Une erreur fatale arrête l'exécution du script. Les causes courantes incluent l'appel de fonctions inexistantes, les inclusions de fichiers manquants ou les problèmes de mémoire. Utilisez des vérifications conditionnelles (function_exists(), file_exists()) et gérez les exceptions.