panic

Syntaxe

Description

Cette macro permet de provoquer une panique (arrêt brutal du processus léger courant) avec un message personnalisé.

Remarques

Permet d'indiquer la panique dans le processus léger en cours.

Cela permet à un programme de se terminer immédiatement et de fournir un retour à l'appelant.

Cette macro est idéale pour affirmer des conditions dans le code d'exemple et les tests. panic! est étroitement liée à la méthode unwrap des énumérations Option et Result. Les deux implémentations appellent panic! lorsqu'elles sont définies sur les variantes None ou Err.

Lorsque vous utilisez panic!(), vous pouvez spécifier une charge utile de type chaîne construite à l'aide de la syntaxe de formatage. Cette charge utile est utilisée lors de l'injection de panic dans le processus léger Rust appelant, provoquant ainsi le panique complet du processus léger.

Le comportement du hook std par défaut, c'est-à-dire le code exécuté directement après l'appel de panic, consiste à afficher la charge utile du message sur stderr avec les informations de fichier/ligne/colonne de l'appel panic!(). Vous pouvez surcharger le hook panic avec std::panic::set_hook(). À l'intérieur du hook, une panique est accessible via un &dyn Any + Send, qui contient soit une chaîne &str, soit une chaîne pour les appels panic!() classiques. (Le fait qu'un appel particulière contienne la charge utile de type &str ou String n'est pas spécifié et peut changer.) Pour paniquer avec une valeur d'un autre type, panic_any peut être utilisé.

Voir également la macro compile_error! pour générer des erreurs lors de la compilation.

Quand utiliser panic! vs Result ?

Le langage Rust propose deux systèmes complémentaires pour la construction/représentation, le signalement, la propagation, la réaction et l'élimination des erreurs. Ces responsabilités sont collectivement appelées « gestion des erreurs ». panic! et Result sont similaires dans le sens où ils constituent l'interface principale de leurs systèmes de gestion des erreurs respectifs ; cependant, la signification que ces interfaces attribuent à leurs erreurs et les responsabilités qu'elles assument au sein de leurs systèmes respectifs diffèrent.

La macro panic! permet de construire des erreurs représentant un bug détecté dans votre programme. Avec panic!, vous fournissez un message décrivant le bug, et le langage construit ensuite une erreur avec ce message, la signale et la propage pour vous.

Result, quant à lui, permet d'encapsuler d'autres types représentant soit le résultat réussi d'un calcul (Ok(T), soit un type d'erreur représentant un mode d'échec d'exécution anticipé de ce calcul (Err(E). Result est utilisé avec des types définis par l'utilisateur représentant les différents modes d'échec d'exécution anticipés que le calcul associé pourrait rencontrer. Result doit être propagé manuellement, souvent à l'aide de l'opérateur ? L'opérateur et le trait Try doivent être signalés manuellement, souvent à l'aide du trait Error.

Mise en oeuvre actuelle

Si le processus léger principal panique, il arrêtera tous vos processus légers et votre programme avec le code 101.

Éditions

Le comportement des macros de panique a changé au fil des éditions.

2021 et versions ultérieures

Dans Rust 2021 et versions ultérieures, panic! requiert toujours une chaîne de format et les paramètres de format applicables, et est identique dans core et std. Utilisez std::panic::panic_any(x) pour panic avec une charge utile arbitraire.

2018 et 2015

Dans les éditions de Rust antérieures à 2021, std::panic!(x) avec un seul paramètre utilise directement cet argument comme charge utile. Ceci est vrai même si l'argument est une chaîne littérale. Par exemple, panic!("problem: {reason}") panic avec une charge utile de "problem: {reason}" (une chaîne &'static).

core::panic!(x) avec un seul argument requiert que x soit de type &str, mais se comporte autrement comme std::panic!. En particulier, la chaîne n'a pas besoin d'être un littéral et n'est pas interprétée comme une chaîne de format.

Exemples