Français
Français
La gestion des erreurs de programme est cruciale lors du développement d'applications PHP, en particulier en ce qui concerne les opérations impliquant des interactions de base de données. Le mécanisme de gestion des erreurs peut non seulement nous aider à déboguer et à optimiser le code, mais également à améliorer la stabilité et l'expérience utilisateur du programme. PHP fournit de nombreuses façons de gérer les erreurs, où mysqli :: $ errno et trigger_error () sont des outils très utiles.
Dans cet article, nous discuterons de la façon d'utiliser MySQLI :: $ Errno et Trigger_error () pour implémenter un mécanisme d'interruption d'erreur PHP, garantissant que le programme peut être terminé dans le temps et donner des informations d'erreur claires lors de la rencontre de la base de données ou d'autres erreurs sérieuses.
mysqli :: $ errno : il s'agit d'une propriété de la classe mysqli qui enregistre le code d'erreur pour la dernière opération de base de données. Lorsque nous effectuons des opérations de base de données, si une erreur se produit, nous pouvons obtenir un code d'erreur détaillé via mysqli :: $ errno pour nous aider à déterminer le type d'erreur.
Trigger_error () : Il s'agit d'une fonction intégrée PHP pour déclencher des erreurs de niveau utilisateur. Il nous permet de lancer des messages d'erreur dans des situations spécifiques et de contrôler le niveau d'erreurs (par exemple: avertissement, notification ou erreur mortelle).
En l'absence d'un bon mécanisme de gestion des erreurs, les programmes PHP peuvent continuer à s'exécuter lorsque des erreurs de base de données ou d'autres exceptions sont rencontrées, entraînant un comportement imprévisible et même provoquant des erreurs plus graves. Par exemple, lors de l'exécution d'une requête de base de données, si une erreur se produit (telle que le fait de ne pas se connecter à la base de données ou si la requête échoue) et le programme ne parvient pas à interrompre dans le temps, le code ultérieur peut continuer à être exécuté, entraînant une corruption ou une incohérence des données.
Par conséquent, l'utilisation de mysqli :: $ errno et trigger_error () peut effectivement empêcher ces problèmes et terminer l'exécution du programme lorsqu'une erreur se produit pour assurer la stabilité du code.
Voyons comment implémenter un mécanisme d'interruption d'erreur simple à l'aide de mysqli :: $ errno et trigger_error () .
Tout d'abord, nous devons établir une connexion à la base de données et vérifier si elle réussit. Si la connexion échoue, nous pouvons utiliser Trigger_error () pour déclencher une erreur mortelle et abandonner l'exécution du programme.
<?php
// Configuration de la connexion de la base de données
$host = 'localhost';
$username = 'root';
$password = '';
$dbname = 'test';
// Créer une connexion de base de données
$mysqli = new mysqli($host, $username, $password, $dbname);
// Vérifiez si la connexion réussit
if ($mysqli->connect_errno) {
// Échec de la connexion，Déclencher une erreur fatale et interrompre le programme
trigger_error("数据库Échec de la connexion: " . $mysqli->connect_error, E_USER_ERROR);
}
?>
Dans le code ci-dessus, si la connexion de la base de données échoue, $ mysqli-> connect_errno renvoie un code d'erreur non nul et Trigger_error () sera déclenché, publiera le message d'erreur et terminez l'exécution du programme.
En plus de la vérification des erreurs lors de la connexion à la base de données, un traitement d'erreur similaire est requis lors de l'exécution des requêtes SQL. Nous pouvons obtenir le code d'erreur de la requête via mysqli :: $ errno . Si la requête échoue, nous pouvons utiliser Trigger_error () pour interrompre le programme et signaler l'erreur.
<?php
// Exécuter une requête
$query = "SELECT * FROM users";
$result = $mysqli->query($query);
// Vérifiez si la requête est réussie
if ($mysqli->errno) {
// La requête a échoué，Déclencher une erreur et interrompre le programme
trigger_error("SQL La requête a échoué: " . $mysqli->error, E_USER_ERROR);
}
?>
Dans cet exemple, si la requête SQL ne parvient pas à s'exécuter, $ mysqli-> errno renvoie un code d'erreur, Trigger_error () sera appelé et le message d'erreur sera sorti. Cela garantit que s'il y a un problème avec la requête, le programme sera résilié à temps et évitera une nouvelle exécution de code non valide.
Trigger_error () nous permet de définir le niveau d'erreur. Par exemple, nous pouvons choisir de gérer certaines erreurs comme des avertissements ( E_USER_WARNING ) et certaines erreurs critiques (telles que l'échec de la connexion de la base de données) comme des erreurs fatales ( E_USER_ERROR ). De cette façon, les développeurs peuvent contrôler de manière flexible comment gérer les erreurs.
<?php
// Supposons qu'une requête renvoie un ensemble de résultats vide
if ($result->num_rows === 0) {
// Avertissement de déclenchement，Mais la procédure ne se termine pas
trigger_error("avertir: Le résultat de la requête est vide", E_USER_WARNING);
} else {
// Traiter les résultats de la requête
while ($row = $result->fetch_assoc()) {
echo $row['username'];
}
}
?>
Dans cet exemple, si la requête renvoie un ensemble de résultats vides, nous déclenchons un avertissement via Trigger_error () , mais le programme ne s'interrompt pas, mais continue de s'exécuter. Cette approche convient aux situations où la procédure n'a pas besoin d'être résiliée immédiatement.
En utilisant MySqli :: $ Errno et Trigger_error () , nous pouvons créer un mécanisme d'interruption d'erreur efficace pour garantir que les applications PHP peuvent être terminées dans le temps lors de la rencontre d'erreurs graves, d'empêcher les erreurs de se propager et d'améliorer la stabilité du code. En définissant de manière flexible différents niveaux d'erreur avec Trigger_error () , nous pouvons également contrôler la façon dont les erreurs sont gérées pour garantir que le programme peut fournir des informations d'erreur claires lorsque des problèmes surviennent.
Dans le développement réel, une bonne gestion des erreurs peut non seulement aider les développeurs à localiser rapidement les problèmes, mais aussi à garantir que le système montre un comportement attendu lorsque des anomalies se produisent, améliorant l'expérience utilisateur et la robustesse du code.
