Quelle est l'utilisation du symbole @ en PHP?
J'ai vu des utilisations de @ devant certaines fonctions, telles que:
$fileHandle = @fopen($fileName, $writeAttributes);
Quelle est l'utilisation de ce symbole?
Il supprime les messages d'erreur - voir Opérateurs de contrôle d'erreur dans le manuel PHP.
Cela supprime les erreurs.
Voir Opérateurs de contrôle d'erreur dans le manuel:
PHP supporte un opérateur de contrôle d'erreur: l'arobase (@). Lorsque ajouté à une expression en PHP, tous les messages d'erreur pouvant être générés par cette expression seront ignorés.
Si vous avez défini une fonction de gestionnaire d’erreurs personnalisée avec set_error_handler () , elle sera toujours appelée, mais ce gestionnaire d’erreurs personnalisé peut (et devrait) appeler error_reporting () qui retournera 0 déclenché, l'erreur était précédée d'un @ ...
Le symbole @ est le contrôle d'erreur opérateur (alias l'opérateur "silence" ou "arrêt"). PHP supprime tous les messages d'erreur (avis, avertissement, fatal, etc.) générés par l'expression associée. Cela fonctionne comme un opérateur unaire, par exemple, il a une priorité et une associativité. Ci-dessous quelques exemples:
@echo 1 / 0;
// generates "Parse error: syntax error, unexpected T_ECHO" since
// echo is not an expression
echo @(1 / 0);
// suppressed "Warning: Division by zero"
@$i / 0;
// suppressed "Notice: Undefined variable: i"
// displayed "Warning: Division by zero"
@($i / 0);
// suppressed "Notice: Undefined variable: i"
// suppressed "Warning: Division by zero"
$c = @$_POST["a"] + @$_POST["b"];
// suppressed "Notice: Undefined index: a"
// suppressed "Notice: Undefined index: b"
$c = @foobar();
echo "Script was not terminated";
// suppressed "Fatal error: Call to undefined function foobar()"
// however, PHP did not "ignore" the error and terminated the
// script because the error was "fatal"
Que se passe-t-il exactement si vous utilisez un gestionnaire d'erreurs personnalisé au lieu du gestionnaire d'erreurs standard PHP:
Si vous avez défini une fonction de gestionnaire d’erreurs personnalisée avec set_error_handler () alors il sera toujours appelé, mais cette coutume Le gestionnaire d'erreurs peut (et devrait) appeler error_reporting () qui le fera renvoie 0 lorsque l'appel qui a déclenché l'erreur a été précédé d'un @.
Ceci est illustré dans l'exemple de code suivant:
function bad_error_handler($errno, $errstr, $errfile, $errline, $errcontext) {
echo "[bad_error_handler]: $errstr";
return true;
}
set_error_handler("bad_error_handler");
echo @(1 / 0);
// prints "[bad_error_handler]: Division by zero"
Le gestionnaire d'erreurs n'a pas vérifié si le symbole @ était en vigueur. Le manuel suggère ce qui suit:
function better_error_handler($errno, $errstr, $errfile, $errline, $errcontext) {
if(error_reporting() !== 0) {
echo "[better_error_handler]: $errstr";
}
// take appropriate action
return true;
}
Notez également que, même si les erreurs sont masquées, tout gestionnaire d’erreurs personnalisé (défini avec set_error_handler) sera toujours exécuté!
Comme déjà quelques réponses précédentes: L'opérateur @ supprime toutes les erreurs en PHP, y compris les avis, les avertissements et même les erreurs critiques.
BUT: S'il vous plaît, n'utilisez vraiment pas l'opérateur @ du tout.
Pourquoi?
Eh bien, parce que lorsque vous utilisez l'opérateur @ pour la suppression des erreurs, vous ne savez pas du tout par où commencer quand une erreur se produit. J'ai déjà eu du plaisir avec le code hérité, où certains développeurs utilisaient assez souvent l'opérateur @. Particulièrement dans des cas tels que les opérations sur les fichiers, les appels réseau, etc. Ce sont tous des cas où de nombreux développeurs recommandent l'utilisation de l'opérateur @, étant donné que cela est parfois hors de portée lorsqu'une erreur se produit ici (par exemple, une API tierce pourrait être inaccessible, etc. .).
Mais à quoi sert-il de ne pas l'utiliser? Regardons de deux points de vue:
En tant que développeur:Lorsque @ est utilisé, je ne sais absolument pas par où commencer. S'il existe des centaines, voire des milliers d'appels de fonction avec @, l'erreur pourrait ressembler à tout le monde. Pas de débogage raisonnable possible dans ce cas. Et même s'il ne s'agit que d'une erreur de tierce partie, alors tout va bien et vous avez terminé rapidement. ;-) En outre, il est préférable d’ajouter suffisamment de détails au journal des erreurs pour permettre aux développeurs de décider facilement si une entrée de journal doit être vérifiée ou si elle n’est qu’une défaillance tierce qui échappe à la portée du développeur.
En tant qu'utilisateur:Les utilisateurs ne s'inquiètent pas du tout de la raison d'une erreur. Les logiciels sont là pour leur permettre de travailler, de terminer une tâche spécifique, etc. Ils ne se soucient pas de savoir si c'est la faute du développeur ou un problème de tierce partie. En particulier pour les utilisateurs, je recommande fortement de consigner toutes les erreurs, même si elles sont hors de portée. Peut-être remarquerez-vous qu'une API spécifique est fréquemment hors ligne. Que pouvez-vous faire? Vous pouvez parler à votre partenaire API et s’ils ne sont pas en mesure de le maintenir stable, vous devriez probablement chercher un autre partenaire.
En bref: Vous devez savoir qu’il existe quelque chose comme @ (la connaissance est toujours bonne), mais juste ne l’utilisez pas . De nombreux développeurs (en particulier ceux qui déboguent du code provenant d’autres) seront très reconnaissants.
Supposons que nous n'ayons pas utilisé l'opérateur "@", notre code ressemblerait à ceci:
$fileHandle = fopen($fileName, $writeAttributes);
Et si le fichier que nous essayons d'ouvrir n'est pas trouvé? Il affichera un message d'erreur.
Pour supprimer le message d'erreur, nous utilisons l'opérateur "@" tel que:
$fileHandle = @fopen($fileName, $writeAttributes);
Si l'ouverture échoue, une erreur de niveau E_WARNING est générée. Vous pouvez utiliser @ pour supprimer cet avertissement.
@ supprime les messages d'erreur.
Il est utilisé dans les extraits de code tels que:
@file_get_contents('http://www.exaple.com');
Si le domaine " http://www.exaple.com " n'est pas accessible, une erreur s'affichera, mais avec @ rien ne s'affiche.
PHP supporte un opérateur de contrôle d'erreur: l'arobase (@). Lorsque ajouté à une expression en PHP, tous les messages d'erreur pouvant être générés par cette expression seront ignorés.
Si vous avez défini une fonction de gestionnaire d'erreur personnalisée avec set_error_handler(), elle sera toujours appelée, mais ce gestionnaire d'erreur personnalisé peut (et devrait) appeler error_reporting() qui renverra 0 lorsque l'appel qui a déclenché l'erreur a été précédé d'un @.
<?php
/* Intentional file error */
$my_file = @file ('non_existent_file') or
die ("Failed opening file: error was '$php_errormsg'");
// this works for any expression, not just functions:
$value = @$cache[$key];
// will not issue a notice if the index $key doesn't exist.
?>
Remarque:-
1) L'opérateur @ ne fonctionne que sur les expressions.
2) Une règle simple est la suivante: si vous pouvez prendre la valeur de quelque chose, vous pouvez y ajouter l’opérateur @. Par exemple, vous pouvez l'ajouter aux variables, aux appels de fonction et d'inclusion, aux constantes, etc. Vous ne pouvez pas ajouter de préfixe aux définitions de fonction ou de classe, ni aux structures conditionnelles telles que if et foreach, etc.
Attention:-
Actuellement, le préfixe d'opérateur de contrôle d'erreur "@" va même désactiver rapport d'erreurs pour les erreurs critiques qui termineront le script exécution. Entre autres choses, cela signifie que si vous utilisez "@" pour supprime les erreurs d'une certaine fonction et soit elle n'est pas disponible ou a été mal typé, le script mourra là sans no indication de pourquoi.
Il est peut-être intéressant d’ajouter ici quelques astuces concernant l’utilisation du @ dont vous devez être conscient, pour une description complète, consultez cet article: http://mstd.eu/index.php/2016/06/30/ php-rapid-fire-ce-que-est-le-symbole-utilisé-pour-en-php/
Le gestionnaire d'erreurs est toujours activé, même si le symbole @ est ajouté, cela signifie simplement qu'un niveau d'erreur de 0 est défini. Il doit être traité de manière appropriée dans un gestionnaire d'erreurs personnalisé.
Si vous préférez inclure avec @, toutes les erreurs dans le fichier include seront définies sur 0
@ supprime le message d'erreur émis par la fonction. fopen génère une erreur lorsque le fichier ne se ferme pas. Le symbole @ permet de déplacer l'exécution vers la ligne suivante, même si le fichier n'existe pas. Ma suggestion serait de ne pas utiliser cela dans votre environnement local lorsque vous développez un code PHP.