2020 Rust 特征 (Trait)

rust.jpeg

选择 rust 的理由

• Rust 有助于您提供代码质量
  • 让我们更加明确地了解性能成本
  • 便于开发人员权衡代码性能利弊
• Rust 更加关注代码的质量和正确性
  • 强调内存安全，除非指定了"unsafe"
  • 强大的类型系统、匹配系统
• 写 Rust 有一种写 kotlin 或者 go 这些高级语言的感觉

特征

组成我们应用通常是两个部分数据和行为，我们编程多半工作就是用行为操作数据。

fn make_true(input:&str) -> String{
    format!("{}!!",input)
}

定义函数 make_true 对字符串进行操作，然后返回字符串，这是对数据的操作。

#[derive(Debug)]
struct Fact {
    text: String
}

fn make_true(input:&Fact) -> Fact{
    Fact{text:format!("{}!!",input.text)}
}

​往往将字符串定义在范围，我们将字符串作为对象 Fact 的属性，然后 make_true 接收 Fact 对象然后对其 text 属性进行操作。

我们希望方法与数据有一定关系，也就是方法属于数据，或者说想要将方法添加到数据上，在其他语言是 method。在 rust 为结构体添加行为很简单，

• 通过关键字 impl 其后添加要添加方法到结构体名称
• 然后写实现

impl Fact {
    fn make_true(&self) -> Fact{
        Fact{text:format!("{}!!",self.text)}
    }
}


fn main(){
   
    let fact = Fact{text:String::from("hello")};
    println!("{:#?}",fact.make_true());
}

上面代码大家疑问最多可能就是 self，为什么我们需要 self

• 通过 self 方法可以访问到数据
• 所以结构体内实现方法，都会得到数据引用作为方法第一个参数，然后来通过 self 引用来访问数据，类似 javascript 和 java 中的 this。
  根据需要可以指定不同 self
• &self 借用、只读版本
• &mut self 可变借用版本
• [mut] self： 所有版本，可以操作修改 self

impl Fact {
    fn make_true(&mut self){
        self.text.push_str("!!");
    }
}

impl Fact {
    fn make_true(mut self) -> Fact{
        self.text.push_str("!!");
        self
    }
}

let fact = Fact{text:String::from("hello")};
let fact_1 = fact.make_true();
println!("{:#?}",fact_1.text);

特征定义

trait 用于定义与其他类型共享功能，这是一种抽象，类似于其他语言(例如 go 语言)中的接口。今天将介绍如何创建 trait 以及其实现和使用，最后会给出基于 trait 实现日志系统。

定义 trait

抽象方式定义共享的行为

pub trait GetInformation {
    fn get_title(&self)-> &String;
    fn get_course(&self)-> u32;
}

使用 trait 关键字来定义特征，然后在其中定义一系列行为，也就是空方法，需要结构体去实现。

pub struct Tut {
    pub title: String,
    pub course: u32,
}

impl GetInformation for Tut {
    fn get_title(&self) -> &String{
        &self.title
    }
    // u32 天然具有 copy 特征
    fn get_course(&self) -> u32{
        self.course
    }
}

定义结构体实现特征 GetInformation 的 get_title 这个结构体就具有 GetInfomation 特征。

fn main() {

    let js_tut = Tut{title:"vue".to_string(),course:10};
    println!("js_tut title = {} course = {}",js_tut.get_title(),js_tut.get_course())
}

在 go 语言我们可以根据行为进行划分类别，只要具有行为结构体就属于某一个按类别进行划分的类别。有时候我们传入结构体，需要具有一定能力。

实现 trait

作为参数输入结构体需要具有一定行为，也就是结构体实现某种特征

fn print_information(tut:impl GetInformation){
    println!("title = {}",tut.get_title());
    println!("age = {}",tut.get_course())
}


fn main() {

    let js_tut = Tut{title:"vue".to_string(),course:10};
    // println!("js_tut title = {} course = {}",js_tut.get_title(),js_tut.get_course())
    print_information(js_tut);

}

默认 Trait 实现

有些时候我们可以通过给出默认方法的实现，也就是给方法提供默认行为。

trait TutInfo {
    fn get_tut_info(&self) -> String{
        String::from("supplied by zidea zone")
    }
}

定义 TutInfo 特征，然后给行为定义默认行为，如果实现特征 TutInfo 没有复写 get_tut_info 方法时就会默认执行 TutInfo 特征默认提供的行为。

impl TutInfo for Tut {

    // add code here
}

let js_tut_info = js_tut.get_tut_info();
println!("tut info = {}",js_tut_info);

Trait 边界

trait 边界指定泛型是任何拥有特定行为的类型。

fn print_information_two<T:GetInformation>(tut:T){
    println!("title = {}",tut.get_title());
    println!("age = {}",tut.get_course());
}

这里就是使用特征边界(trait bound)来定义函数接受参数需要具有一定约束（要求结构体必须实现某种方法），所以约束就是要求结构体需要具有一定能力。

也可以指定多个特征边界(train_bound), 来约束对象具有多个行为。其实语法还是比较好理解，一门新语言带来很多新的特性，但是并不能改变你编程和设计程序能力。只是便于你对程序设计的实现。

trait GetTitle {
    fn get_title(&self) -> &String;
}

trait GetCourse {
    fn get_course(&self) -> u32;
}

impl GetTitle for Tut {
    fn get_title(&self)->&String{
        &self.title
    }
}

impl GetCourse for Tut {
    fn get_course(&self) -> u32{
        self.course
    }
}

fn print_information_three<T:GetTitle+GetCourse>(tut:T){
    println!("title = {}",tut.get_title());
    println!("age = {}",tut.get_course());
}

还有一种特征边界的写法，通过 where 对泛型进行限制，

fn print_information_five<T>(tut:T) where T:GetCourse + GetTitle{

    println!("title = {}",tut.get_title());
    println!("age = {}",tut.get_course());
}

接下来，也可以特征边界( trait bound) 来约束函数的返回值类型。

fn get_tut() -> impl GetTitle {
    Tut{
        title:String::from("react"),
        course:20
    }
}

这里需要补充一下这里 get_tut 返回值是 trait 类型，我们不能通过条件来返回不同都实现 GetTitle 的不同结构体，这样会报错

let reactTut = get_tut();
println!("title of react tut = {}",reactTut.get_title());

Trait 对象

在我们所熟悉的面向对象编程语言中，对象包含数据和行为。创建对象便可调用其方法(行为)进行操作。在 rust 我们将数据保存在 enums 或是 structs ,而行为写作 trait 里，也就是将数据和行为分开。Trait 对象行为更像传统的对象。Trait 对象可以包含数据和行为，但是又不同于传统对象。

• 系统日志信息
• 日志需要可配置
• 在开发版提供详细信息，而在发布版提供简要的信息
  定义 Logger 结构体，添加输出不同级别日志信息

#[derive(Debug)]
struct Loggger {
}

impl Logger{
    fn error(&self, message:&str){}
    fn warn(&self, message:&str){}
    fn info(&self, message:&str){}
    fn debug(&self, message:&str){}
}

上面定义了不同级别的日志输出 error, warn, info 和 debug 级别日志输出

根据日志输出形式又定义不同类型日志输出

• FilerLogger
• PrintLogger
• NullLogger
• ExternalServiceLoagger

trait Loggger {
    fn error(&self, message:&str);
    fn warn(&self, message:&str);
    fn info(&self, message:&str);
    fn debug(&self, message:&str);
}

#[derive(Debug)]
struct PrintLogger {
}

impl Loggger for PrintLogger {

    fn error(&self, message:&str){
        println!("ERROR：{} ",message)
    }
    fn warn(&self, message:&str){
        println!("ERROR：{} ",message)
    }
    fn info(&self, message:&str){
        println!("ERROR：{} ",message)
    }
    fn debug(&self, message:&str){
        println!("ERROR：{} ",message)
    }
}

​这里我们定义特征 Logger，让不同日志输出类型都去实现 Logger 特征，这样他们就是不同类型却具有相同行为的类别

pub fn log_example(logger:&Logger){
    logger.info("runing example code ..");
    logger.info("done example code");
}

这里 &Logger 也称为Trait 对象，在 Trait 对象中包含

• 一个指向一个基本类型（可能是 PrintLogger 也可能是 FileLogger)

• 指针指向虚拟方法表(vtable)
  这些都是由编译器实现的

  
  Trait 对象

在 Trait 对象是包含一个指向堆上数据指针，以这种形式来保存数据，当堆上值大小变化不会影响到 Trait 对象，这样更利于分配内存给对象。

 logger.info("runing example code ..");

在上面语句编译器会先从 vtable 中加载 info 函数地址，然调用到 info 函数的地址。看整个过程，可能会担心效率，这样做会不会影响程序的性能。

vtable