当前位置：首页 > news >正文

长治做网站想要注册一个公司网站怎么做

news 2025/9/17 10:04:35

长治做网站,想要注册一个公司网站怎么做,2017最新网站设计风格,网站建设管理后台导航栏不同于 java 中的反射，Rust 没有提供以往意义上的运行时反射，取而代之的是 “编译期反射”，如类型分析、类型转换、类型签名。但即便如此，也已经能对 Rust元编程提供很多助力了。这种操作，主要通过 Any 来实现&…

不同于 java 中的反射，Rust 没有提供以往意义上的运行时反射，取而代之的是 “编译期反射”，如类型分析、类型转换、类型签名。但即便如此，也已经能对 Rust元编程提供很多助力了。

这种操作，主要通过 Any 来实现，Rust 中提供了 Any Trait，所有类型（含自定义类型）都自动实现了该特征；因此，通过它我们可以进行一些类似反射的功能；

实际上，在 Rust 早期版本中是提供了 Reflection 的，但是在 14年移除了相关代码，原因是：

反射打破了原有的封装原则，能任意访问结构体内容，不安全；
反射的存在使得代码过于臃肿，移除后编译器可以简化很多；
反射功能设计的比较弱，开发者对于是否在未来的版本中还拥有反射功能存疑；

另一篇关于Rust为何不引入 Runtime Reflection ，大致信息如下：

不一定非要使用反射来实现， Rust中可以有更好的实现：
派生宏和Trait之间的配合，可以将实现从运行时转移到编译时；
例如，利用过程宏实现编译时反射，以实现依赖注入等功能 - https://github.com/dtolnay/reflect

至于保留 Any 的原因：

在调试范型类型相关代码时，有TypeId会更方便，更容易给出正确的错误提示；
有利于编译器作出代码的优化；

Any源码简读

参看Any源码文档：

作为 &dyn Any (借用的 trait 对象)，具有 is 和 downcast_ref 方法，可测试值是否为给定类型，并对类型的内部值进行引用；作为 &mut dyn Any，还有 downcast_mut 方法，用于获取内部值的 “可变引用” ；

Box<dyn Any> 具有 downcast 方法，该方法尝试转换为 Box<T>；也有称 “类型具象化”。但需注意，&dyn Any 仅限于测试值是否为具体的类型，而不能用于测试类型是否实现了 Trait；

总结就是 std::any 起到的作用有4个：

获得变量的类型 a.type_id()；
判断变量是否是指定的具体类型 a.is::<String>() 或 TypeId::of::<String>() == a.type_id()；
把any转换成指定类型 a.downcast_ref::<String>()；
获取类型的名字 (_: &T) -> String { std::any::type_name::<T>().to_string() }；

下面看一段 Any Trait 部分核心源码，可帮助更好理解 Any：

pub trait Any: 'static {fn type_id(&self) -> TypeId;
}// 获得变量的类型TypeId
// 为所有的T实现了Any
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: 'static + ?Sized> Any for T {fn type_id(&self) -> TypeId { TypeId::of::<T>() }
}// 判断变量是否是指定类型
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is<T: Any>(&self) -> bool {// Get `TypeId` of the type this function is instantiated with.let t = TypeId::of::<T>();// Get `TypeId` of the type in the trait object.let concrete = self.type_id();// Compare both `TypeId`s on equality.t == concrete
}// 把any转换成指定类型
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn downcast_ref<T: Any>(&self) -> Option<&T> {if self.is::<T>() {// SAFETY: just checked whether we are pointing to the correct typeunsafe {Some(&*(self as *const dyn Any as *const T))}} else {None}
}// 获取类型名字
pub const fn type_name<T: ?Sized>() -> &'static str {intrinsics::type_name::<T>()
}#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct TypeId {t: u64,
}

补充说明：

Rust 中，所有拥有静态生命周期的类型都会实现Any，未来可能会考虑加入生命周期是非‘static的情况；
Rust 中，所有类型都有一个全局唯一的标识 TypeId（A TypeId represents a globally unique identifier for a type）；
这些 TypeId 都是通过调用 intrinsic 模块中定义的函数创建的，即 TypeId 的生成是由编译器的实现来决定的！

关于intrinsic 模块：

intrinsic 库函数是指：由编译器内置实现的函数，一般是具有如下特点的函数：

与CPU架构相关性很大，必须利用汇编实现或者利用汇编才能具备最高性能的函数；
和编译器密切相关的函数，由编译器来实现最为合适；
具体实现 - https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/intrinsic.rs

Any基本使用

examples/main.rs

use std::any::{Any, TypeId};struct Person {pub name: String,
}/// 判断是否为指定类型-1
fn is_string(s: &dyn Any) -> bool {TypeId::of::<String>() == s.type_id() // 获取TypeId
}/// 判断是否为指定类型-2
fn check_string(s: &dyn Any) {if s.is::<String>() {println!("It's a string!");} else {println!("Not a string...");}
}/// 转换Any为特定类型
fn print_if_string(s: &dyn Any) {if let Some(ss) = s.downcast_ref::<String>() {println!("It's a string({}): '{}'", ss.len(), ss);} else {println!("Not a string...");}
}/// 获取类型的名字
/// 但需注意, 此方式获取的名字不唯一
///    如 type_name::<Option<String>> 可能返回 Option<String> 或 std::option::Option<std::string::String>
/// 同时, 编译器版本不同、可能返回值不同
fn get_type_name<T>(_: &T) -> String {std::any::type_name::<T>().to_string()
}fn main() {let p = Person { name: "John".to_string() };assert!(!is_string(&p));assert!(is_string(&p.name));check_string(&p);check_string(&p.name);print_if_string(&p);print_if_string(&p.name);println!("Type name of p: {}", get_type_name(&p));println!("Type name of p.name: {}", get_type_name(&p.name));
}

输出如下

Not a string...
It's a string!
Not a string...
It's a string(4): 'John'
Type name of p: 0_any::Person
Type name of p.name: alloc::string::String

Any适用场景

Rust 中的 Any 类似于 Java 中的 Object，可以传入任何拥有静态生命周期的类型；因此，当入参类型复杂，但后续又没有更多功能性操作时，就可以简化入参。例如，打印任何类型的值。

examples/1_print_any.rs

use std::any::Any;
use std::fmt::Debug;#[derive(Debug)]
struct MyType {name: String,age: u32,
}fn print_any<T: Any + Debug>(value: &T) {let value_any = value as &dyn Any;if let Some(string) = value_any.downcast_ref::<String>() {println!("String ({}): {}", string.len(), string);} else if let Some(MyType { name, age }) = value_any.downcast_ref::<MyType>() {println!("MyType ({}, {})", name, age)} else {println!("{:?}", value)}
}fn main() {let ty = MyType {name: "Rust".to_string(),age: 30,};let name = String::from("Rust");print_any(&ty);print_any(&name);print_any(&30);
}