Section courante

A propos

Section administrative du site

dbg

 Déboguage
Rust

Syntaxe

macro_rules! dbg {
   () => { ... };
   ($val:expr $(,)?) => { ... };
   ($($val:expr),+ $(,)?) => { ... };
}

Description

Cette macro permet d'afficher une expression avec son nom et sa valeur vers la sortie d'erreur standard, tout en renvoyant la valeur, utile pour le débogage rapide.

Remarques

Affiche et renvoie la valeur d'une expression donnée pour un débogage rapide et simple.

Exemple :

  1. let a = 2;
  2. let b = dbg!(a * 2) + 1;
  3. //      ^-- prints: [src/main.rs:2:9] a * 2 = 4
  4. assert_eq!(b, 5);

La macro utilise l'implémentation Debug du type de l'expression donnée pour afficher la valeur sur stderr, ainsi que l'emplacement source de l'appel de la macro et le code source de l'expression.

L'appel de la macro sur une expression la déplace et en prend possession avant de renvoyer l'expression évaluée inchangée. Si le type de l'expression n'implémente pas Copy et que vous ne souhaitez pas céder la propriété, vous pouvez utiliser dbg!(&expr) pour une expression expr.

La macro dbg! fonctionne exactement de la même manière dans les versions de publication. Ceci est utile pour déboguer des problèmes qui ne surviennent que dans les versions de publication ou lorsque le débogage en mode publication est nettement plus rapide.

Notez que la macro est conçue comme un outil de débogage ; il est donc déconseillé de l'utiliser dans le contrôle de version pendant de longues périodes (sauf pour les tests et autres tâches similaires). La sortie de débogage du code de production est plus efficace avec d'autres fonctionnalités, comme la macro debug! du crate de journal de bord.

Stabilité

Le résultat exact affiché par cette macro ne doit pas être pris en compte et est susceptible d'être modifié ultérieurement.

Panique

Panique si l'écriture sur io::stderr échoue.

Autres exemples

Avec un appel de méthode :

  1. fn foo(n: usize) {
  2.     if let Some(_) = dbg!(n.checked_sub(4)) {
  3.         // ...
  4.     }
  5. }
  6.  
  7. foo(3)

Ceci affiche sur stderr :

[src/main.rs:2:22] n.checked_sub(4) = None

Implémentation factorielle naïve :

  1. fn factorial(n: u32) -> u32 {
  2.     if dbg!(n <= 1) {
  3.         dbg!(1)
  4.     } else {
  5.         dbg!(n * factorial(n - 1))
  6.     }
  7. }
  8.  
  9. dbg!(factorial(4));

Ceci affiche sur stderr :

[src/main.rs:2:8] n <= 1 = false
[src/main.rs:2:8] n <= 1 = false
[src/main.rs:2:8] n <= 1 = false
[src/main.rs:2:8] n <= 1 = true
[src/main.rs:3:9] 1 = 1
[src/main.rs:7:9] n * factorial(n - 1) = 2
[src/main.rs:7:9] n * factorial(n - 1) = 6
[src/main.rs:7:9] n * factorial(n - 1) = 24
[src/main.rs:9:1] factorial(4) = 24

La macro dbg!(..) déplace l'entrée :

  1. /// Un enveloppe autour de «usize» qui, surtout, n'est pas copiable.
  2. #[derive(Debug)]
  3. struct NoCopy(usize);
  4.  
  5. let a = NoCopy(42);
  6. let _ = dbg!(a); // <-- `a` est déplacé ici.
  7. let _ = dbg!(a); // <-- `a` est à nouveau déplacé ; erreur !

Vous pouvez également utiliser dbg!() sans valeur pour afficher le fichier et la ligne dès qu'elle est atteinte.

Enfin, si vous souhaitez utiliser dbg!(..) plusieurs valeurs, il les traitera comme un tuple (et le renverra également) :

  1. assert_eq!(dbg!(1usize, 2u32), (1, 2));

Cependant, un argument unique suivi d'une virgule ne sera toujours pas traité comme un tuple, conformément à la convention consistant à ignorer les virgules de fin lors des appels de macros. Vous pouvez utiliser directement un tuple simple si nécessaire :

  1. assert_eq!(1, dbg!(1u32,)); // virgule de fin ignorée
  2. assert_eq!((1,), dbg!((1u32,))); // 1-tuple


Dernière mise à jour : Mardi, le 5 Août 2025