Go semble pouvoir imprimer directement des structures et des tableaux.
struct MyStruct {
a: i32,
b: i32
}
et
let arr: [i32; 10] = [1; 10];
Vous souhaitez implémenter le trait Debug
sur votre structure. L'utilisation de #[derive(Debug)]
est la solution la plus simple. Ensuite, vous pouvez l'imprimer avec {:?}
:
#[derive(Debug)]
struct MyStruct{
a: i32,
b: i32
}
fn main() {
let x = MyStruct{ a: 10, b: 20 };
println!("{:?}", x);
}
Comme dit mdup , vous pouvez utiliser Debug
, mais vous pouvez également utiliser le trait Display
. Vous pouvez créer une sortie personnalisée:
struct MyStruct {
a: i32,
b: i32
}
impl std::fmt::Display for MyStruct {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "(value a: {}, value b: {})", self.a, self.b)
}
}
fn main() {
let test = MyStruct { a: 0, b: 0 };
println!("Used Display: {}", test);
}
Coquille:
Used Display: (value a: 0, value b: 0)
Pour plus d'informations, vous pouvez consulter la documentation du module fmt
.
En fait juste {:?}
est suffisant.
let a = [1, 2, 3, 4, 5];
let complete = &a[..];
println! ("{:?}", a);
println! ("{:?}", complete);
Comme personne ici ne répond explicitement pour les tableaux, pour imprimer un tableau, vous devez spécifier le {:?}
, également utilisé pour imprimer la sortie de débogage
let val = 3;
let length = 32; // the maximum that can be printed without error
let array1d = [val; length];
let array2d = [array1d; length]; // or [[3; 32]; 32];
let array3d = [array2d; length]; // or [[[3; 32]; 32]; 32];
Cependant, les tableaux où length > 32
se fermera avec une erreur:
let length = 33;
let array1d = [3; length];
println("{:?}", array1d);
error[E0277]: the trait bound `[{integer}; 33]: std::fmt::Debug` is not satisfied
--> src\main.rs:6:22
|
| println!("{:?}", array1d);
| ^^^^^^^ the trait `std::fmt::Debug` is not implemented for `[{integer}; 33]`
Des tableaux plus longs peuvent être imprimés avec l'approche de cette réponse: Implémenter la caractéristique de débogage pour le type de tableau large