Rust编程基础

Rust是一门系统编程语言，专注于安全，尤其是并发安全，支持函数式和命令式以及泛型等编程范式的多范式语言。Rust在语法上和C++类似，但是设计者想要在保证性能的同时提供更好的内存安全。

1.下载安装

官网：https://www.rust-lang.org

Windows版本下载(先安装Visual Studio，社区版免费):

https://static.rust-lang.org/rustup/dist/x86_64-pc-windows-msvc/rustup-init.exe

Linux版本下载(Ubuntu为例):

$ sudo apt update
$ sudo apt install build-essential curl vim
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装Windows、Linux差不多，安装出现过程如下选项：

Current installation options:


   default host triple: x86_64-unknown-linux-gnu
     default toolchain: stable (default)
               profile: default
  modify PATH variable: yes

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
>1

我们选择1，默认安装，之后会进行在线安装，离线安装等访问参考官网Get-Started。

在Linux版本，安装成功后需要运行一下命令(Windows不需要此步骤)：

Rust is installed now. Great!

To get started you may need to restart your current shell.
This would reload your PATH environment variable to include
Cargo's bin directory ($HOME/.cargo/bin).

To configure your current shell, run:
source "$HOME/.cargo/env"

即，命令行运行:

source "$HOME/.cargo/env"

2.基础示例

方法1：

$ cargo new hello-rust
$ cargo run
    Compiling hello-rust v0.1.0 (/Users/ag_dubs/rust/hello-rust)
    Finished dev [unoptimized + debuginfo] target(s) in 1.34s
     Running `target/debug/hello-rust`
Hello, world!

Note: 在run之前，也可以使用build, cargo build编译Debug版本, cargo build --release,编译release版本。

方法2(以Linux为例,Windows类似)：

$ vim hello.rs

在hello.rs文件中编写并保存如下内容:

 fn main()
{
    println!("Hello World.");
}

编译:

$ rustc hello.rs
$ ./hello
Hello World.

3. 打印输出

 fn main()
{
    println!("Bob, 18.");
    println!("{}, {}.", "Bob", 18);
    println!("{0}, {1}.", "Bob", 18);
    println!("{Name}, {Age}.", Name = "Bob", Age = 18);
}

4. 数据类型

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

其中isize和usize取决于平台架构，32位处理器是32，64位处理器是64.

5. 注释

// 方式1.

/// 方式2.

/* 方式3. */

/**
 * 方式4.
 * 多行注释.
 */

6. 变量常量

6.1 局部变量

// 不可变变量
let a;
let b = true;
let c: bool = true;
let (x, y) = (1, 2);
a = 1234;

// 可变变量
let mut z = 5;
z = 6;

6.2 全局变量

// 静态变量(不可变)
static Num: i32 = 7;

// 静态变量(可变)
static mut Num: i32 = 8;
Num = 9;

6.3 常量

// 常量
const Num: i32 = 10;

6.4 占位符

// 下划线"_",表示占位符
let a = [4, 5, 6];
let [b, _, c] = a;    // b = 4, c = 6.

7. 其他类型

7.1 数组

let a = [1, 2, 3]; // a[0] = 1, a[1] = 2, a[2] = 3
let mut b = [1, 2, 3];

let c: [int; 3] = [1, 2, 3]; // [类型; 数组长度]

let d: ["my value"; 3]; // ["my value", "my value", "my value"];

let e: [i32; 0] = []; // 空数组

println!("{:?}", a); // [1, 2, 3]

7.2 元组

let a = (1, 1.5, true, 'a', "Hello, world!");
// a.0 = 1, a.1 = 1.5, a.2 = true, a.3 = 'a', a.4 = "Hello, world!"

let b: (i32, f64) = (1, 1.5);

let (c, d) = b; // c = 1, d = 1.5
let (e, _, _, _, f) = a; // e = 1, f = "Hello, world!", _ 作为占位符使用，表示忽略该位置的变量

let g = (0,); // 只包含一个元素的元组

let h = (b, (2, 4), 5); // ((1, 1.5), (2, 4), 5)

println!("{:?}", a); // (1, 1.5, true, 'a', "Hello, world!")

7.3 切片

let a: [i32; 4] = [1, 2, 3, 4];

let b: &[i32] = &a; // 全部
let c = &a[0..4]; // [0, 4)
let d = &a[..]; // 全部

let e = &a[1..3]; // [2, 3]
let e = &a[1..]; // [2, 3, 4]
let e = &a[..3]; // [1, 2, 3]

7.4 字符串

let a = "Hello, world!"; // a: &'static str
let b: &str = "你好, 世界!";
let s1 = "Hello, world!".to_string();
let s2 = String::from("Hello, world!");

8. 函数

// 结构形式
fn <函数名> (<参数>) {<函数体>}

 fn test(x: i32, y: i32) -> i32
{
    return x + y;
}

 fn main()
{
    let val = test(5, 6);

    println!("The value is: {}.", val);
}

9. 条件语句

 形式1：

if...else if...else

let val = 5;

if val < 4 {
    val = 4;
}
else if val < 6 {
    val += 2;
}
else {
    val = 10;
}

形式2：

match

let tshirt_width = 20;

let tshirt_size = match tshirt_width {
    16 => "S", // check 16
    17 | 18 => "M", // check 17 and 18
    19 ... 21 => "L", // check from 19 to 21 (19,20,21)
    22 => "XL",
    _ => "Not Available",
};

println!("{}", tshirt_size); // L

10. 循环

10.1 while

let mut a = 1;

while a <= 10 {
    println!("Current value : {}", a);
    a += 1; // Rust不支持++/--自增自减语法
}

10.2 for

for a in 0..10 { // (a = 0; a <10; a++)
    println!("Current value : {}", a);
}

10.3 loop

let mut a = 0;

loop {
    if a == 0 {
        println!("Skip Value : {}", a);
        a += 1;
        continue;
    } else if a == 2 {
        println!("Break At : {}", a);
        break;
    }
    println!("Current Value : {}", a);
    a += 1;
}

// Skip Value : 0
// Current Value : 1
// Break At : 2

11. 运算符

11.1 算数运算符

+, -, *, /, %

let a = 5;

let b = a + 1; // 6
let c = a - 1; // 4
let d = a * 2; // 10
let e = a / 2; // 2 not 2.5
let f = a % 2; // 1

let g = 5.0 / 2.0; // 2.5

11.2 比较运算符

==, =, !=, <, >, <=, >=

let a = 1;
let b = 2;

let c = a == b; // false
let d = a != b; // true
let e = a < b;  // true
let f = a > b;  // false
let g = a <= a; // true
let h = a >= a; // true

let i = true > false; // true
let j = 'a' > 'A'; // true

11.3 逻辑运算符

!, &&, ||

let a = true;
let b = false;

let c = !a; // false
let d = a && b; // false
let e = a || b; // true

11.4 位运算符

&, |, ^, <<, >>

let a = 1;
let b = 2;

let c = a & b; // 0  (01 && 10 -> 00)
let d = a | b; // 3  (01 || 10 -> 11)
let e = a ^ b; // 3  (01 != 10 -> 11)
let f = a << b; // 4  (左移 -> '01'+'00' -> 100)
let g = a >> a; // 0  (右移 -> 01 -> 0)

11.5 赋值运算符

let mut a = 2;

a += 5; // 2 + 5 = 7
a -= 2; // 7 - 2 = 5
a *= 5; // 5 * 5 = 25
a /= 2; // 25 / 2 = 12 not 12.5
a %= 5; // 12 % 5 = 2

a &= 2; // 10 && 10 -> 10 -> 2
a |= 5; // 010 || 101 -> 111 -> 7
a ^= 2; // 111 != 010 -> 101 -> 5
a <<= 1; // '101'+'0' -> 1010 -> 10
a >>= 2; // 101̶0̶ -> 10 -> 2

11.6 类型转换运算符

as

let a = 15;
let b = (a as f64) / 2.0; // 7.5

12. 集合

12.1 新建

let v: Vec<i32> = Vec::new();  // 空集合
// let v = vec![1, 2, 3];  // 含初始值的集合，vec!是为方便初始化Vec提供的宏。

println!("第三个元素 {}", &v[2]); // 3
println!("第100个元素 {}", &v[100]); // panic error

assert_eq!(v.get(2), Some(&3));
assert_eq!(v.get(100), None);

12.2 更新

let v: Vec<i32> = Vec::new();
v.push(5);
v.push(6);
v.push(7);
v.push(8);
v.pop() // 删除最后一个元素

12.3 遍历

let v = vec![100, 32, 57];
for i in &v {
    println!("{}", i);
}

let mut v2 = vec![100, 32, 57];
for i in &mut v2 {
    *i += 50;
}

13. 结构体

struct Site {
    domain: String,
    name: String,
    nation: String,
    found: u32
}

14. 枚举类

#[derive(Debug)]

enum Book {
    Papery, Electronic
}

fn main() {
    let book = Book::Papery;
    println!("{:?}", book); // Papery
}

15. 错误处理

use std::io;
use std::io::Read;
use std::fs::File;

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
}

16. 泛型

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

17. 文件IO

17.1 文件读

use std::fs;

fn main() {
    let text = fs::read_to_string("D:\\text.txt").unwrap();
    println!("{}", text);
}

17.2 文件写

use std::fs;

fn main() {
    fs::write("D:\\text.txt", "FROM RUST PROGRAM")
        .unwrap();
}

18. 面向对象

second.rs
pub struct ClassName {
    field: i32,
}

impl ClassName {
    pub fn new(value: i32) -> ClassName {
        ClassName {
            field: value
        }
    }

    pub fn public_method(&self) {
        println!("from public method");
        self.private_method();
    }

    fn private_method(&self) {
        println!("from private method");
    }
}
main.rs
mod second;
use second::ClassName;

fn main() {
    let object = ClassName::new(1024);
    object.public_method();
}

// from public method
// from private method

19. 并发编程

use std::thread;
use std::time::Duration;

fn spawn_function() {
    for i in 0..5 {
        println!("spawned thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

fn main() {
    thread::spawn(spawn_function);

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

// main thread print 0
// spawned thread print 0
// main thread print 1
// spawned thread print 1
// main thread print 2
// spawned thread print 2