1
2
3
4
5
6

let b1: bool = true;
let b2 = !b1;
let b3 = 1 > 0;
let i = b1 as u8;     // bool -> u8
// let b = i as bool  // u8 -> bool 非法
println!("{} {} {}", b1, b2, b3);    //true, false, true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// int
let big_val = std::i32::MAX; //MAX 是std::i32中定义的常量，表示i32型的最大值，即231-1
let neg_inf = std::f32::NEG_INFINITY; //负无穷大；
let x = big_val + 1;         // 发生异常 panic: arithmetic operation overflowed
// 整形进制
let u07 = 0xFF_u32;          //0x 16进制
let u08 = 0o7777_u32;        //0o 8进制
let u09 = 0b01_10_00_u8;     //0b 2进制
println!("{} {} {}",u07,u08,u09);    //255 4095 24
// as
assert_eq!(  10_i8 as u16,    10_u16); // 正数值由少位数转入多位数
assert_eq!( 2525_u16 as i16, 2525_i16); // 正数值同位数转换
assert_eq!(  -1_i16 as i32,    -1_i32); // 负数少位转多位执行符号位扩展
assert_eq!(65535_u16 as i32, 65535_i32); // 正数少位转多位执行0位扩展（也可以理解为符号位扩展）
//由多位数转少位数，会截掉多位数的高位，相当于多位数除以2^N的取模，其中N是少位数的位数
assert_eq!( 1000_i16 as u8, 232_u8); //1000的二进制是0000 0011 1110 1000，截掉左侧8位，留下右侧8位，是232
assert_eq!(65535_u32 as i16, -1_i16); //65535的二进制,16个0和16个1，截掉高位的16个0，剩下的全是1，全1的有符号补码是-1

//同位数的带符号和无符号相互转化，存储的数字并不动，只是解释的方法不一样
//无符号数，就是这个值；而有符号数，需要用补码来翻译
assert_eq!(-1_i8  as u8, 255_u8);  //有符号转无符号
assert_eq!(255_u8 as i8, -1_i8);  //无符号转有符号
// float
assert_eq!(5f32.sqrt() * 5f32.sqrt(), 5.); // 平方根，此外还有sin()、ln()等诸多数学计算方法
assert_eq!(-3.7f64.floor(),  -4.0);  //向下取整，还有ceil()方法是向上取整，round()方法是四舍五入）
assert_eq!(1.2f32.max(2.2), 2,2); //比较返回最大值，min()方法是取最小值
assert_eq!(-3.7f64.trunc(), -3.0);  //删除小数部分，注意和floor、ceil的区别
assert!((-1. / std::f32::INFINITY).is_sign_negative()); //是否为负值，注意-0.0也算负值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

assert_eq!('*' as i32, 42);    // char -> i32
assert_eq!('ಠ' as u16, 0xca0);
assert_eq!('ಠ' as i8, -0x60); // U+0CA0 被截断为8位带符号整型

//std::char模块中有很多有用的char方法/函数：
assert_eq!('*'.is_alphabetic(), false);  //检查是否是字母
assert_eq!('β'.is_alphabetic(), true);
assert_eq!('8'.to_digit(10),  Some(8));  //检查是否数字
assert_eq!('ಠ'.len_utf8(), 3);  //用utf-8格式表示的话，占据几个字节
assert_eq!(std::char::from_digit(2,  10), Some('2'));  //数字转换为char，第二个参数是进制

// char -> Integer
println!("{}", '我' as i32);     // 25105
println!("{}", '是' as u16);     // 26159
println!("{}", '是' as u8);      // 47，被截断了

// u8 -> char
println!("{}", 97_u8 as char);    // 'a'

// std::char
use std::char;

// digit -> char
println!("{}", char::from_u32(0x2764).unwrap());  // ❤
assert_eq!(char::from_u32(0x110000), None);  // true

println!("{}", char::from_digit(4,10).unwrap());  // '4'
println!("{}", char::from_digit(11,16).unwrap()); // 'b'
assert_eq!(char::from_digit(11,10),None); // true

1
2
3
4
5
6
7
8
9

// 元组定义
let tup1: (i32, f64, u8) = (500, 6.4, 1);
let tup2 = (500, 6.4, 1);
// 元组解构
let (x, y, z) = tup1;
// 索引访问
let five_hundred = tup2.0;
let six_point_four = tup2.1;
let one = tup3.2;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// 具名结构体
struct Point {x: f32,  y: f32}  
// 元组结构体
struct Color(i32, i32, i32);  
// 元组结构体只有一个字段时，称为NewType模式
struct Integer(u32);          
// 单元结构体，没有任何字段的结构体。单元结构体实例就是其本身。
struct Nil;                   

// 结构体实例化
let point: Point = Point { x: 0.3, y: 0.4 };
println!("point coordinates: ({},{})", point.x, point.y); // 访问 point 的字段
// let解绑struct
let Point {x: my_x, y: my_y} = point;

// struct tuple
struct Pair(i32, f32);  //struct tuple
let pair = Pair(1, 0.1);
println!("pair contains {:?} and {:?}", pair.0, pair.1);
let Pair(integer, decimal) = pair;
println!("pair contains {:?} and {:?}", integer, decimal);

// ..操作符，用于更新结构体，会转移字段的所有权。
#[derive(Debug,Copy,Clone)]
struct Book<’a> {    
     name: &’a str,
     isbn:  i32,
     version: i32,
}
let book = Book {
    name: “Rust编程之道”,  isbn: 20181212, version: 1
};
let book2 = Book {version: 2, ..book}; 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 不带参数枚举
enum Number {
    Zero,
    One,
}
// 带参数枚举
enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

enum MyEnum {
    Foo,
    Bar,
}

// enum 格式化输出
impl std::fmt::Display for MyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            MyEnum::Foo => write!(f, "Foo"),
            MyEnum::Bar => write!(f, "Bar"),
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#[repr(C)]
union MyUnion {
    f1: u32,
    f2: f32,
}

let u = MyUnion { f1: 1 }; //union定义
unsafe { u.f1 = 5 };    //union写入是不安全的
let value = unsafe { u.f1 }; //uion读取是不安全的
// union模式匹配
unsafe {
    match u {
        MyUnion { f1: 10 } => { println!("ten"); }
        MyUnion { f2 } => { println!("{}", f2); }
    }
}

1
2
3
4
5
6
7

// 数组定义
let a: [i32; 5] = [1, 2, 3, 4, 5];
let array: [i32; 4] = [42, 10, 5, 2];
// let a = [1,"string"];   //错误，数组元素类型应该相同
let color = ["Red", "Yellow", "Blue"];
let second = a[1];   // 数组元素索引访问
let l = a.len()      // 数组长度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// vector初始化
let v1: Vec<i32> = Vec::new();        //Vec::new()
let v2 = vec![1,2,3];                 //[1,2,3]
let v21 = vec![false; 4];                 //[3,3, 3, 3]
let v3: Vec<_> = (1..5).collect();    //[1,2,3,4]
let v4 = Vec::with_capacity(5);       //预留空间初始化

// vector元素访问
let third: &i32 = &v[2];                //[]运算符
let third: Option<&i32> = v.get(2);     //get()方法

// 遍历
for i in &v { .. } // 获得引用
for i in &mut v { .. } // 获得可变引用
for i in v { .. } // 获得所有权，注意此时Vec的属主将会被转移！！
// 迭代器
for x in xs.iter() {
        println!("> {}", x);
}
// 内置方法
let mut v = vec![11,22];
v.len();                         //v长度(元素数量)
v.is_empty();                    //vec是否为空
v.get(1);                        //get
v.iter();                        //iterator
v.push(33);                      //在尾部插入元素33
v.resize(10, 0);                 //
v.insert(0, 111);                //在索引0处插入111
v.remove(1);                     //删除i元素并返回被删除的元素，索引越界将panic报错退出
v.pop();                         //删除并返回vec尾部的元素，vec为空则返回None
v.append(vec![3, 4]);            //将另一个vec中的所有元素追加移入vec中，移动后另一个vec变为空vec
v.truncate(2);                    //将vec截断2，多余的元素被删除
v.retain(|x| *x > 20);            //保留满足条件的
v.drain(1..=3);                   //删除指定范围的元素，同时返回该范围所有元素的迭代器
v.split_off(2);                   //从index 2处分裂为两个vec
v.clear();                        //清空vec

1
2
3

let v = [1, 2, 3, 4];  //定义一个数组；
let s1 = &v[..];       //获取数组的切片引用；
let s = &v[1..3];      //获取数组切片[2,3];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// range结构体定义
pub struct Range<Idx> {
    pub start: Idx,
    pub end: Idx,
}

// range的使用
use std::ops::{Range, RangeInclusive};

assert_eq!((1..5), Range{ start: 1, end: 5 });
// (1..=5)是结构体std::ops::RangeInclusive的一个实例
assert_eq!((1..=5), RangeInclusive::new(1, 5));
// 自带的 sum 方法用于求和
assert_eq!(3+4+5, (3..6).sum());
assert_eq!(3+4+5+6, (3..=6).sum());
(3..6)

// 每个范围都是一个迭代器，可用for 循环打印范围内的元素
for i in (1..5) {
    println!("{}", i);
}
for i in (1..=5) {
    println!("{}", i);
}
// 逆序
for i in (1..=5).rev() {
    println!("{}", i);
}

// 范围操作
let arr = [11, 22, 33, 44, 55];
let s1 = &arr[0..3];    // [11,22,33]
let s2 = &arr[1..=3];   // [22, 33, 44]
let s3 = &arr[..];      // [11, 22, 33, 44, 55]

1
2
3
4
5
6
7
8

//定义
let x = "Hello";                // 字符串字面量
let x: &'static str = "Hello";  //完整形式
//转义
let z = "foo
         bar";
let w = "foo\n      bar";
assert_eq!(z, w);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//新建String
let s1 = String::new();                 //new: 创建空字符串
//&str -> String
let s2 = "string".to_string()            //to_string: 创建非空字符串
let s3 = String::from("string2")         //from: 创建非空字符串
let mut s4 = String::from("foo");
let s5 = String::from("bar");
//raw string
let raw_str = r"Escapes don't work here: \x3F \u{211D}";
assert_eq!(raw_str, "Escapes don't work here: ? ℝ");
let quotes = r#"And then I said: "There is no escape!""#;
println!("{}", quotes);
// 如果希望在字符串中使用 # 号，可以如下使用：
let  delimiter = r###"A string with "# in it. And even "##!"###;
println!("{}", delimiter);
// String -> &str
let str1: &str = s2.as_str();        //
let str2 = &*s2; //String 实现impl Deref<Target=str> for String
let str2 = &s2;  //string -> &str
//更新字符串
s4.push_str("bar");                   //push_str: 添加字符串
s4.push_str(&s2)                      // 这里是&s2 而不是s2
s4.push('l')                          //push: 添加字符
//连接字符串
// let s3 = s1 + "wold";
let s3 = s1 + &s2;   //s1 被移动了，不能继续使用
//格式化字符串
let s = format!("{}-{}-{}", s1, s2, s3);  //format!宏不会获取参数的所有权

// Vec<char> -> String
let s4 = String::from_iter(vec!['a', 'b', 'c'].iter()); //s4 = "abc"

// 字符串slice
let mut s1 = String::from("hello");   //&str -> String
let s2 = "wold";
println!("{}", &s1[..1], &s2[1..2]); // 不要忘了 & 符号

// string -> &[u8]
let u8_bytes = s1.as_bytes();   // &[104, 101, 108, 108, 111],
let chars = s2.chars();     //Chars

s1.chars().nth(2)  // 第2个字符
// 遍历字符
for c in "abcd".chars() {
    println!("{}", c); // a,b,c,d
}
// 遍历byte
for b in "नमस्ते".bytes() {
    println!("{}", b); // 224 164 168 224 ...
}
// 插入
s1.insert(5, ',');   //插入字符
s1.insert_str(6, " I like");  //插入字符串字面量
// 替换
s1.replace("rust", "RUST");       //替换所有子串，返回替换后的新字符串
s1.replacen("rust", "RUST", 1);   //替换1个子串，返回替换后的新字符串
s1.replace_range(7..8, "R");
// 删除
s1.pop();         //删除s1尾部字符；
s1.remove(0);     //删除s1第0个字节的字符, 如果参数不在字符的字节边界，则发生错误；
// 截断
s1.truncate(3);   //截断s1从第3个字节开始到最后的所有字符；
s1.clear();       //清空字符串所有字符；
// 连接
let s2 = s1 + "abc";  //连接字符串字面量；
s1 += "cdf";   //s1为mut

//字符串切片
let s = String::from("Hello word");
let hello = &s[0..5];       // hello: &str
let word = &s[6..11];       // word: &str

//
use utf8_slice;
let s = "The 🚀 goes to the 🌑!";
let rocket = utf8_slice::slice(s, 4, 5);  // 结果是 "🚀"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

//引入hashmap包
use std::collections::HashMap

//new
let mut scores = HashMap::new();        //new
let solar_distance = HashMap::from([    //from
    ("Mercury", 0.4),
    ("Venus", 0.7),
    ("Earth", 1.0),
    ("Mars", 1.5),
]);

scores.insert(String::form("Blue"), 10);    //插入
scores.insert(String::from("Yellow"), 50);

let teams = vec![String::from("Blue"), String::from("Yellow")];
let initial_scores = vec![10, 50];
// zip, 合并k-v
let scores: HashMap<_,_> = teams.iter().zip(initial_scores.iter()).collect();

let score = scores.get(String::form("Blue")); //get

//遍历
for (key, value) in &scores {
  println!("{}: {}", key, value);
}

// entry
// or_insert 方法会返回这个键的值的一个可变引用（&mut V）
scores.entry(String::from("Yellow")).or_insert(50);         //如果存在就忽略，如果不存在就插入
*scores.entry(String::from("Yellow")).or_insert(10) += 10;  //更新
scores2.entry(String::from("Yellow")).or_default().push(50);  //string->vec<i32> 插入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

use std::collections::HashSet;
// Type inference lets us omit an explicit type signature (which
// would be `HashSet<String>` in this example).
let mut books = HashSet::new();

// Add some books.
books.insert("A Dance With Dragons".to_string());
books.insert("To Kill a Mockingbird".to_string());
books.insert("The Odyssey".to_string());
books.insert("The Great Gatsby".to_string());

// Check for a specific one.
if !books.contains("The Winds of Winter") {
    println!("We have {} books, but The Winds of Winter ain't one.",
             books.len());
}

// Remove a book.
books.remove("The Odyssey");

// Iterate over everything.
for book in &books {
    println!("{book}");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

use std::collections::BTreeMap;

// new方法
let mut movie_reviews = BTreeMap::new();
// insert
movie_reviews.insert("Office Space",       "Deals with real issues in the workplace.");
movie_reviews.insert("Pulp Fiction",       "Masterpiece.");
movie_reviews.insert("The Godfather",      "Very enjoyable.");
movie_reviews.insert("The Blues Brothers", "Eye lyked it a lot.");

// from 
let solar_distance = BTreeMap::from([
    ("Mercury", 0.4),
    ("Venus", 0.7),
    ("Earth", 1.0),
    ("Mars", 1.5),
]);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

use std::collections::BTreeSet;

// 类型推断允许我们省略显式类型签名（它
// 在这个例子中将是 `BTreeSet<&str>`）。
let mut books = BTreeSet::new();

// 添加一些书籍。
books.insert("A Dance With Dragons");
books.insert("To Kill a Mockingbird");
books.insert("The Odyssey");
books.insert("The Great Gatsby");

// 检查一个特定的。
if !books.contains("The Winds of Winter") {
    println!("We have {} books, but The Winds of Winter ain't one.",
             books.len());
}
books.remove("The Odyssey");  // 删除一本书。

// 遍历所有内容。
for book in &books {
    println!("{book}");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

use std::collections::BinaryHeap;

let mut heap = BinaryHeap::new();
let heap2 = BinaryHeap::from([1, 5, 2]);  //

assert_eq!(heap.peek(), None);
heap.push(93);
heap.push(80);
heap.push(48);
assert_eq!(heap.peek(), Some(&93));

use std::cmp::Reverse;

let mut heap = BinaryHeap::new();

// 在 `Reverse` 中包装值
heap.push(Reverse(1));
heap.push(Reverse(5));
heap.push(Reverse(2));

// 如果我们现在弹出这些分数，它们应该以相反的顺序返回。
assert_eq!(heap.pop(), Some(Reverse(1)));
assert_eq!(heap.pop(), Some(Reverse(2)));
assert_eq!(heap.pop(), Some(Reverse(5)));
assert_eq!(heap.pop(), None);

1

type Kilometers = i32;