选择 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 函数的地址。看整个过程，可能会担心效率，这样做会不会影响程序的性能。
