Rust - 安装环境、基本类型、流程控制、函数、模块、泛型、所有权

安装环境、基本类型

学习Rust语言是公司同事最先开始提议的，准备用接下来的项目试试水，Rust是一个强类型编译型语言，比较偏向底层，所以开启了Rust的探索之旅。

环境准备阶段

安装Rust环境

安装命令：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

source $HOME/.cargo/env //设置环境变量

rustc --version //查看安装版本

Cargo

Cargo 是 Rust 的构建系统和包管理器。Rust 开发者常用 Cargo 来管理 Rust 工程和获取工程所依赖的库。

Cargo 就是Vue里面的npm，php里的composer。

cargo run [项目名称]
cargo build

生成的目录结构如下：

.
|-- Cargo.lock
|-- Cargo.toml
|-- src
|   `-- main.rs
`-- target
    |-- CACHEDIR.TAG
    `-- debug
        |-- build
        |-- deps
        |   |-- stark-2c1445affc8ccd97
        |   `-- stark-2c1445affc8ccd97.d
        |-- examples
        |-- incremental
        |-- stark
        `-- stark.d

数据类型概述

类型是对二进制数据的一种约束行为。类型比起二进制数据，有许多优势：

减少开发者心智负担
安全、容易优化

常见的类型分类：

静态类型：在编译器对类型进行检查
动态类型：在运行期对类型进行检查
强类型：不允许隐式类型转换
弱类型：允许隐式类型转换

Rust是强类型语言。

Rust基本数据类型

1.Rust的变量

创建变量使用let关键字
变量默认是不可变的，关键字前面加mut转换为可变变量
常量使用const关键字定义
隐藏属性

2.基础数据类型

Rust是一门静态编程语言，所有变量的类型必须在编译期就被明确规定。

整数：Rust有12种不同类型的整数

对于未明确标明的类型的整数，Rust默认采用i32
isize和usize根据系统不同而有不同的长度

长度	有符号	无符号
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
128-bit	i128	u128
arch	isize	usize

 fn main() {
    let number :i8 = 32;
    println!("{}",number);
}

浮点数型: Rust 与其它语言一样支持 32 位浮点数（f32）和 64 位浮点数（f64）。默认情况下，64.0 将表示 64 位浮点数，因为现代计算机处理器对两种浮点数计算的速度几乎相同，但 64 位浮点数精度更高。

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
}

布尔值：布尔型用 bool 表示，值只能为 true 或 false。大小为一个字节。

fn main() {
    let t = true;
    let f: bool = false;
}

字符型：字符型用 char 表示。Rust的 char 类型大小为 4 个字节，代表 Unicode标量值，这意味着它可以支持中文，日文和韩文字符等非英文字符甚至表情符号和零宽度空格在 Rust 中都是有效的 char 值。

注意： Rust 中字符串和字符都必须使用 UTF-8 编码，否则编译器会报错。

复合类型

元组

元组用一对 ( ) 包括的一组数据，可以包含不同种类的数据：

fn main() {
    let a: i32= 10;
    let b = 'A';
    //创建一个元组
    let mytuple:(i32,char) = (a,b);
    // 从元组中读取一个值
    println!("{},{}",mytuple.0,mytuple.1);
    //解封装
    let(c , d) = mytuple;
    println!(" {} , {} ",c , d);
}

数组

数组用一对 [ ] 包括的同类型数据。Rust语法规定，每个数组的类型必须相同。Rust的数组中不同于其他一些语言中的数组，具有固定长度。

数组下标以0开始，同时Rust存在越界检查。

fn main() {
    //初始化数组
    let myarray: [u32;5] = [1,2,3,4,5];
    println!("myarray[1] = {}",myarray[1]);

    //数组越界
    //let index = "5".parse::<usize>().unwrap();
    //println!("myarray[5]={}",myarray[index]);

    let mut mybuffer: [u32;32 * 1024] = [10;32*1024];
    println!("mybuffer[1024] = {}", mybuffer[1024]);

    //修改数组的值
    mybuffer[1024] = 13;
    println!("mybuffer[1024] = {}", mybuffer[1024]);
}

切片

切片（Slice）是对数据值的部分引用。切片这个名字往往出现在生物课上，我们做样本玻片的时候要从生物体上获取切片，以供在显微镜上观察。

fn main() {
    //切片可以切数组
    let myarray: [u32;5] = [1,2,3,4,5];
    let slice = &myarray[0..3];
    println!("slice[0] = {}, slice.length = {} ",slice[0],slice.len());
    //切片还可以切字符串
    
    let s = String::from("broadcast");
    let part1 = &s[0..5];
    let part2 = &s[5..9];
    println!("{}={}+{}", s, part1, part2);
}

Slice没有自己去存储数据，截取的都是引用数据。

结构体

结构体是多种不同数据类型的组合。它与元组类似，但区别在于我们可以为每个成员命名，可以使用struct关键字三种类型的结构。

元组结构
经典的C结构
无字段的单元结构

结构体使用驼峰命名。

//元组结构
struct Pair(i32,f32);

//经典的C结构
struct Peison {
    name:String,
    age:u8
}

fn main() {
 let pair = Pair(10,4.2);
 let person = Peison{
     name: String::from("stark"),
     age:32
 };

 println!("pair.0 = {}",pair.0);
 println!("person.name = {}, person.age = {}",person.name,person.age);
}

引用派生属性，打印结构体。

#[derive(Debug)]


struct Peison {
    name:String,
    age:u8
}

fn main() {
 let person = Peison {
     name: String::from("stark"),
     age:32
 };

 println!("{:?}",person);

}

枚举

枚举类在 Rust 中并不像其他编程语言中的概念那样简单，但依然可以十分简单的使用：

#[derive(Debug)]

enum IPAddr {
    IPv4(u8,u8,u8,u8),
    IPv6(u8,u8,u8,u8,u8,u8,u8,u8,u8,u8,u8,u8),
}

fn main() {
    let localhost :IPAddr = IPAddr::IPv4(127,0,0,1);
    match localhost {
        IPAddr::IPv4(a,b,c,d) => {
            println!("{},{},{},{}",a,b,c,d);
        }
        _ => {}
    }
}

Rust - 流程控制、函数

if else

Rust的if的布尔条件不用括号括起来。if所有分支返回的类型必须相同。

fn main() {
    let number = 3;
    if number < 5 {
        println!("条件为 true");
    } else {
        println!("条件为 false");
    }
}

loop、while

Rust提供了loop一个关键字来表示无限循环。while是根据条件进行循环。

fn main() {
    let s = ['R', 'U', 'N', 'O', 'O', 'B'];
    let mut i = 0;
    loop {
        let ch = s[i];
        if ch == 'O' {
            break;
        }
        println!("\'{}\'", ch);
        i += 1;
    }
}

for range

Rust的 for in 语法可以用来遍历一个迭代器，有多种方法可以创建一个迭代器，最简单也是最常见的方式：

a..b:这里将创建一个a，但不包含b的，步长为1的迭代器
a..=b:这里将创建一个a，且包含b的，步长为1的迭代器

fn main() {
    for i in 0..5 {
        println!("i value is {}",i);
    }
    
    println!("-------------");    

    for i in 0..=5 {
        println!("i value is {}",i);
    }
}

for in 语法第二个重要的使用场景是遍历数组，但这首先将数组转化为一个迭代器，可以通过.iter()或者.iter_mut实现，区别是在于后者是可变的。

fn main() {
    let mut myarray = [1,2,3];
    for i in myarray.iter(){
        println!("i value is {} ",i);
    }

    for  i in myarray.iter_mut() {
        *i *= 2;
    }

    for i in myarray.iter(){
        println!("i value is {} ",i);
    }
}

遍历关联数组：

fn main() {
    let myarray = ["a","b","c"];
    for i in myarray.iter(){
        println!("i value is {} ",i);
    }
}

match / if_let / while_let

在Rust 中没有 switch 语句，matcher 就是 switch 的一个变形，但比其他语言中的 switch 更强大!

let x = 5;

match x {
    1 => println!("one"),
    2 => println!("two"),
    3 => println!("three"),
    4 => println!("four"),
    5 => println!("five"),
    _ => println!("something else"),
}

函数与方法

函数

函数定义以fn为关键字，它的参数是带类型注释的，就像变量一样，如果函数返回值，则必须在箭头->之后指定返回类型。

fn sum_number(n:u64) -> u64 {
    if n < 2 {
        n
    }else{
        n+1
    }
}

fn main() {
    println!("sumNumber is {}",sum_number(10))
}

函数与闭包

Rust的闭包是一种匿名函数，它可以从它的上下文中捕获变量的值，闭包使用 ||-> 语法定义，闭包可以保存在变量中。

fn main() {
    let time3 = |n:u32| -> u32 { n * 3 };
    println!("time3 is {}",time3(10));
}

move关键字可以从闭包环境中捕获值，它最常用的场景是将主线程中的一个变量传递到了子线程中。

use std::thread;
fn main() {
    let hi = "hi,stark";
    thread::spawn(move || {
        println!("stark value {}",hi);
    }).join();
}

高阶函数 / 发散函数

在数学和计算机科学里，高阶函数至少满足一个条件的函数：

接收一个或多个函数作为输入
输出一个函数

在数学中它们叫做算子或泛函，高阶函数是函数式编程中一个重要概念。

fn action(method:fn(u32,u32)->u32,a: u32,b: u32) -> u32 {
    method(a,b);
}

fn add(a:u32,b:u32) ->  u32 {
    a + b 
}

fn sub(a:u32,b:u32) ->  u32 {
    a - b 
}

fn main() {
  println!("{}",action(add,10,20))
}

发散函数

发散函数指的是永远不会被返回，它们的返回值标记!,这是一个空类型。

Rust - 使用模块、泛型、所有权

Rust项目的代码组织包含以下三个基本概念：

Package（包）
Crate（箱）
Module（模块）

Package

Package 用于管理一个或多个Crate，创建一个Package的方式是使用cargo new stark命令：

[root@b0b5a9371ce4 stark]# tree
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

Create

Create是Rust最小单元，既Rust是编译器是以Create为最小单元进行编译的。Create在一个范围内将相关的功能组合在一起，并最终通过编译器生成一个库文件或者是二进制文件。

Module

Module允许我们将一个Create中的代码组织成独立的代码块，以便增强可读性和代码复用，同时Module还控制代码的可见性，将代码分为公开和私有两种属性，定义一个模块的关键字是mod

Module的可见性

Rust中的模块内部的代码、结构体、函数默认是私有的，但是可以通过pub关键字来改变他们的可见性，通过选择性的对外可见性来隐藏模块内部的实现细节。

比较常见的三种pub写法：

pub 成员对模块可见
pub(self) 成员对模块内的子模块可见
pub(crate) 成员对整个crate可见

mod mod1 {
    pub const MESSAGE :&str = "Hello,world";
}
fn main() {
  println!("{}",mod1::MESSAGE)
}

Module的引入

在文件开头使用mod 文件路径;,第二种可以映射到一个文件夹，但文件夹中要存在mod.rs,该文件夹可作为一个模块。

结构体的可见性

结构体的字段和方法默认是私有的，通过加上pub修饰语可使得结构体中的字段和方法可以在定义结构体外访问。要注意，与结构体同一个模块和代码的访问结构体中的字段和方法并不要求该字段是可见的。

use 绑定模块成员

使用use绑定类库，as可以指定别名。

使用super与self简化模块路径

除了使用完整路径访问模块内成员，还可以使用super与self关键字相对路径对模块进行访问。

super ：上层模块
self ：当前模块

泛型

Rust中未指定参数类型的概念叫泛型。

函数参数的泛型

pub fn sum_number<T: std::ops::Add<Output = T>>(a:T,b:T) -> T {
    return a+b;
}

结构体中的泛型

struct Point<T> {
    x:T,
    y:T
}

struct Line<T> {
    x: Point<T>,
    y: Point<T>
}

fn main() {
  println!("{}",cc::MESSAGE);
  println!("{}",cc::sum_number(10,20));

  let pointx = Point{x:0,y:0};
  let pointy = Point{x:10,y:10};
  let line = Line {x:pointx, y:pointy};

  println!("{},{},{}",line.x.x,line.x.y,line.y.x);
}

Rust内存管理

所有权是Rust这门语言的核心概念，Rust最以为豪的内存安全就建立在所有权之上。

Rust采用了一种中间的方案RALL，它兼具GC的易用性和安全性，同时又有极高的性能。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5MlOioAW-1649511656829)(https://note.youdao.com/yws/res/17856/WEBRESOURCE1759d05270a5a0ada71aa6cc869b2c73)]

rust所有权

Rust中每个值都绑定有一个变量，称为该值的所有者。
每个值只有一个所有者，而且每个值都有它的作用域。
一但当这个值离开作用域，这个值占用的内存将被回收。

fn main() {
    let s2:String;
    {
        let s1 = String::from("Hello,world");
        s2 = s1;
        //println!("s1 value {}",s1);
        //value borrowed here after move
    }
    println!("s2 value {}",s2);
}

借用

在有些时候，我们希望使用一个值而不拥有这个值，这种需求在函数调用的时候特别常见。

fn echo(s:String){
    println!("{}",s);
}
fn main() {
    let s = String::from("hello.world");
    echo(s);
    println!("{}",s);
}

Rust一个变量只有一个所有权。

fn echo(s:&String){
    println!("{}",s);
}
fn main() {
    let s = String::from("hello.world");
    echo(&s);
    println!("{}",s);
}

不可变引用与可变引用

默认情况下，引用是不可变的，如果希望修改引用的值，需要使用&mut。

fn change(s: &mut String){
    s.push_str("chenged!")
}
fn main() {
    // 要借用的变量s也需要是可变的变量
    let mut s = String::from("hello.world");
    change(&mut s);
    println!("{}",s);
}

同一时间内，至多有一个可变引用。

fn main() {
    let mut s = String::from("hello.world");
    let s1_ref = &mut s;
    let s2_ref = &mut s;
    println!("{}",s1_ref);
    println!("{}",s2_ref);
}

生命周期注解

生命周期注解不会改变之前生命周期的长短，它还是原来的生命周期，注解是给编译器看的，拥有相同的生命周期注解，生命周期都是一样的。

fn bigger (str1:&str,str2:&str) -> &str {
    if str1 > str2 {
        str1
    }else{
        str2
    }
}
fn main() {
    println!("{}",bigger("a","b"));
}

结构体当中的生命周期注释

#[derive(Debug)]

struct Person {
    name: String
}

fn main() {
   let p = Person{ name:String::from("zhangyu") };
   println!("{:?}",p );
}

标签：u8,println,let,fn,模块,泛型,main,Rust
From： https://blog.51cto.com/u_14851133/6084399