Comprendre systématiquement les erreurs et exceptions en PHP

L'une des raisons pour lesquelles le langage PHP est simple est le mécanisme de gestion des erreurs de PHP. À mesure que le langage PHP devient de plus en plus moderne, des exceptions apparaissent également. Cet article de blog parle simplement d'erreurs et d'exceptions pour faciliter la compréhension du système. De plus, pour toute langue, l'existence d'exceptions est courante, il est donc essentiel d'apprendre une langue et de comprendre le mécanisme d'exception.

Qu'est-ce qu'une erreur

Lorsque le langage PHP rencontre une situation anormale (telle qu'un échec de connexion à la base de données ou une erreur de transfert de paramètres de fonction), certaines erreurs seront signalées en différents types, à l'exception des erreurs E_ERROR et E_CORE_ERROR, d'autres erreurs ne se termineront pas. le programme.

La raison pour laquelle PHP rend les gens simples est que le programme ne signale pas fréquemment les erreurs, donnant aux gens l'illusion d'une écriture fluide et pratique

C'est aussi pour cette raison que. Les programmes PHP sont rigoureux et précis. Les performances sont bien pires. Par exemple, lorsque la requête mysql_fetch_array rencontre une erreur réseau et renvoie FALSE (le programme ne se termine pas), si le programme appelant pense que la requête n'a pas de données correspondantes, alors le programme appelant pense que la requête n'a pas de données correspondantes. Le programme est essentiellement faux.

Grâce à php. Nous pouvons choisir le type d'erreurs à signaler via l'instruction ini error_reporting ou appeler dynamiquement la fonction error_reporting() Grâce à l'instruction display_errors, nous pouvons contrôler si les erreurs sont générées en ligne. . L'instruction error_log peut contrôler la sortie des erreurs dans le journal

Comment utiliser correctement les erreurs

Qu'il s'agisse d'une fonction système ou d'une fonction personnalisée, le cas échéant. Une erreur est rencontrée en interne, comment avertir l'appelant ? Ceci est généralement indiqué par la fonction renvoyant VRAI ou FAUX. Cette méthode de traitement présente plusieurs inconvénients :

● L'appelant sait seulement qu'une erreur s'est produite, mais le les informations d'erreur renvoyées sont trop peu nombreuses et il y a un manque de description du type d'erreur

● Logique de traitement du programme et gestion des erreurs Mélangés ensemble, le code généré sera très flou.

Un peu astuce : la fonction error_get_last() renverra la cause spécifique de la dernière erreur.

Bonne pratique :

Quantity la fonction set_error_handler() pour héberger toutes les erreurs

● La fonction trigger_error () peut déclencher des erreurs personnalisées et peut être utilisée pour remplacer l'instruction return dans la fonction

● Afficher toutes les erreurs dans le journal et définir les types d'erreurs

● Afficher les erreurs aux utilisateurs, comme renvoyer les erreurs aux utilisateurs de manière plus conviviale

● display_errors dans l'environnement de production La commande doit être fermée et l'environnement de développement doit être ouvert par cette commande

L'ancien PHP framework Codeigniter peut apprendre de la manière de gérer les erreurs

function _error_handler($severity, $message, $filepath, $line)
{
    $is_error = (((E_ERROR | E_COMPILE_ERROR | E_CORE_ERROR | E_USER_ERROR) & $severity) === $severity);
    //输出500错误HTTP状态码
    if ($is_error) {
        set_status_header(500);
    }
    //对于不需要处理的错误则直接中断
    if (($severity & error_reporting()) !== $severity) {
        return;
    }
    //将所有的错误记录到日志中
    $_error =& load_class('Exceptions', 'core');
    $_error->log_exception($severity, $message, $filepath, $line);
    //友好的输出所有错误
    if (str_ireplace(array('off', 'none', 'no', 'false', 'null'), '', ini_get('display_errors'))){
        $_error->show_php_error($severity, $message, $filepath, $line);
    }
    //假如致命错误则直接退出
    if ($is_error) {
        exit(1);   
    }
}
set_error_handler('_error_handler');

Qu'est-ce qu'une exception

Exception C'est aussi une erreur Elle a les caractéristiques suivantes :

● Les exceptions peuvent être personnalisées. SPL fournit de nombreux types d'exceptions, et vous pouvez également l'étendre

● L'action la plus courante pour les exceptions est de les intercepter. De cette manière, les développeurs peuvent effectuer un traitement ultérieur en fonction de celles-ci. erreurs spécifiques. Par exemple, ils peuvent renvoyer des invites conviviales à l'utilisateur en fonction du contexte de l'exception. Ou continuer à lever une exception et laisser le programme en amont la gérer. Si l'exception n'est toujours pas interceptée, le programme sera directement terminé.

● Une autre action pour les exceptions consiste à lancer une logique métier via des fonctions et que vous rencontrez des situations inattendues, vous pouvez directement lancer une exception.

● Des exceptions peuvent être levées par le code. couche par couche, si le programme le plus externe ne l'a pas intercepté, le code cessera de s'exécuter directement

● Si l'exception en PHP ne peut pas être interceptée, elle sera écrite dans le journal des erreurs système comme une erreur fatale

Expliquez grâce à un code intuitif :

function inverse($x)
{
    if ($x < 10) {
        throw new Exception(&#39;x<10&#39;);
    } elseif ($x >= 10 and $x < 100) {
        throw new LogicException(&#39;x>=10 and x<100&#39;);
    }
    return $x;
}
try {
    echo inverse(2)."\n";
} catch (LogicException $e) {
    echo &#39;Caught LogicException: &#39;, $e->getMessage(), "\n";
} catch (Exception $e) {
    echo &#39;Caught Exception: &#39;, $e->getMessage(), "\n";
    throw $e;
}

Bonnes pratiques pour les exceptions

● Les exceptions peuvent rendre le code plus clair et permettre aux développeurs de se concentrer sur l'écriture de la logique métier.

● La création d'exceptions extensibles est très technique. L'exception SPL ne suffit-elle pas ?

● La capture d'exceptions ne doit capturer que les exceptions qui peuvent être gérées par cette couche. les exceptions sont gérées par le code en amont.

Exceptions en PHP7

PHP7 encourage l'utilisation d'exceptions pour remplacer les erreurs, mais il est impossible de renverser complètement le mécanisme de gestion des erreurs. Il doit être compatible, il ne peut donc être transféré que lentement.

Mais les exceptions peuvent être utilisées de manière uniforme grâce à des méthodes flexibles

● Exception d'erreur

définie en PHP Une exception d'erreur a été levée. Notez que cette exception et cette exception sont juxtaposées.

Lorsque le mode strict est activé, de nombreuses erreurs en PHP7 sont générées par des exceptions d'erreur. être utilisé uniformément.

declare (strict_types = 1);
function add(int $a, int $b)
{
    return $a + $b;
}
try {
    echo add("3", "4");
}
catch (TypeError $e) { //TypeError继承自Error
    echo $e->getMessage();
}

Quantity ErrorException

ErrorException hérite de Exception.

Nous pouvons convertir toutes les erreurs en ErrorException via la fonction set_error_handler(). Ce sera amusant. L'utilisation unifiée est anormale.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!