你可以使用std::any::type_name函数。这并不需要一个夜间编译器或外部板条箱，结果是非常正确的:

fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}

fn main() {
    let s = "Hello";
    let i = 42;

    print_type_of(&s); // &str
    print_type_of(&i); // i32
    print_type_of(&main); // playground::main
    print_type_of(&print_type_of::<i32>); // playground::print_type_of<i32>
    print_type_of(&{ || "Hi!" }); // playground::main::{{closure}}
}

注意:如文档中所述，此信息只能用于调试目的:

这是用于诊断用途。字符串的确切内容和格式没有指定，只是尽力描述该类型。

如果你想让你的类型表示在不同的编译器版本中保持相同，你应该使用一个trait，就像phicr的答案一样。

在稳定rust中有一个@ChrisMorgan答案可以获得近似类型(“float”)，在夜间rust中有一个@ShubhamJain答案可以通过不稳定函数获得精确类型(“f64”)。

现在有一种方法可以得到精确的类型(即在f32和f64之间决定)在稳定的rust:

fn main() {
    let a = 5.;
    let _: () = unsafe { std::mem::transmute(a) };
}

结果

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
 --> main.rs:3:27
  |
3 |     let _: () = unsafe { std::mem::transmute(a) };
  |                           ^^^^^^^^^^^^^^^^^^^
  |
  = note: source type: `f64` (64 bits)
  = note: target type: `()` (0 bits)

更新

涡轮鱼的变异

fn main() {
    let a = 5.;
    unsafe { std::mem::transmute::<_, ()>(a) }
}

略短，但可读性稍差。

如果你只是想在交互开发过程中知道变量的类型，我强烈建议在你的编辑器或ide中使用rls (rust语言服务器)。然后，您可以简单地永久启用或切换悬停能力，只需将光标放在变量上。一个小对话框将显示关于变量的信息，包括类型。

您还可以使用println中的变量!("{:?}”,var)。如果没有为该类型实现Debug，则可以在编译器的错误消息中看到该类型:

mod some {
    pub struct SomeType;
}

fn main() {
    let unknown_var = some::SomeType;
    println!("{:?}", unknown_var);
}

(游戏围栏)

虽然很脏，但很管用。

你可以使用std::any::type_name函数。这并不需要一个夜间编译器或外部板条箱，结果是非常正确的:

fn print_type_of<T>(_: &T) {
    println!("{}", std::any::type_name::<T>())
}

fn main() {
    let s = "Hello";
    let i = 42;

    print_type_of(&s); // &str
    print_type_of(&i); // i32
    print_type_of(&main); // playground::main
    print_type_of(&print_type_of::<i32>); // playground::print_type_of<i32>
    print_type_of(&{ || "Hi!" }); // playground::main::{{closure}}
}

注意:如文档中所述，此信息只能用于调试目的:

这是用于诊断用途。字符串的确切内容和格式没有指定，只是尽力描述该类型。

如果你想让你的类型表示在不同的编译器版本中保持相同，你应该使用一个trait，就像phicr的答案一样。

如果你只是想找出一个变量的类型，并愿意在编译时执行，你可能会导致一个错误，并让编译器拾取它。

例如，将变量设置为一个无效的类型:

let mut my_number: () = 32.90;
// let () = x; would work too

error[E0308]: mismatched types
 --> src/main.rs:2:29
  |
2 |     let mut my_number: () = 32.90;
  |                             ^^^^^ expected (), found floating-point number
  |
  = note: expected type `()`
             found type `{float}`

或者调用无效的方法:

let mut my_number = 32.90;
my_number.what_is_this();

error[E0599]: no method named `what_is_this` found for type `{float}` in the current scope
 --> src/main.rs:3:15
  |
3 |     my_number.what_is_this();
  |               ^^^^^^^^^^^^

或访问无效字段:

let mut my_number = 32.90;
my_number.what_is_this

error[E0610]: `{float}` is a primitive type and therefore doesn't have fields
 --> src/main.rs:3:15
  |
3 |     my_number.what_is_this
  |               ^^^^^^^^^^^^

These reveal the type, which in this case is actually not fully resolved. It’s called “floating-point variable” in the first example, and “{float}” in all three examples; this is a partially resolved type which could end up f32 or f64, depending on how you use it. “{float}” is not a legal type name, it’s a placeholder meaning “I’m not completely sure what this is”, but it is a floating-point number. In the case of floating-point variables, if you don't constrain it, it will default to f64¹. (An unqualified integer literal will default to i32.)

参见:

编译器错误消息中的{integer}或{float}是什么?

¹可能仍然有一些让编译器困惑的方法，使它无法在f32和f64之间做出决定;我不确定。它曾经像32.90.eq(&32.90)一样简单，但现在两者都被视为f64，并且可以愉快地进行，所以我不知道。