入门
+
入门
Hello_World.rs
fn main() {
println!("Hello, World!");
@@ -223,21 +223,22 @@
:- :- item程序项 block块表达式 stmt语句
(注意此选择器不匹配句尾的分号) pat模式 expr表达式 ty类型 ident标识符或关键字 path类型表达式 形式的路径 tttoken 树
(单个 token 或宏匹配定界符 ()、[] 或 {} 中的标记)meta属性，属性中的内容 lifetime生存期 token vis可能为空的可见性限定符 literal匹配 -? 字面量表达式
-结构体
+
结构体
+
结构体是一个使用关键字 struct 定义的标称型(nominal)结构体类型
struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 11 };
let px: i32 = p.x;
结构体是一个使用关键字 struct 定义的标称型(nominal)结构体类型
枚举
-
enum Foo {
- Bar, // 0
- Baz = 123, // 123
- Quux, // 124
+元祖结构体
+struct Color (i32, i32, i32);
+let black = Color(0,0,0);
+
+单元结构体
+不关心该类型的内容, 只关心它的行为。
+struct Solution;
+impl Solution{
+ // ...
}
-
-let baz_discriminant = Foo::Baz as u32;
-assert_eq!(baz_discriminant, 123);
语句与表达式
在 rust 中，语句无需返回值，而表达式总要返回值
@@ -291,7 +292,9 @@查看: 字符串
-数组
+
数组
+
+
这里介绍的是固定长度的数组。rust 中常用的是集合类型 vec 表示的动态数组
┌─────┬─────┬─────┬─────┬─────┬─────┐
| 92 | 97 | 98 | 99 | 98 | 94 |
└─────┴─────┴─────┴─────┴─────┴─────┘
@@ -300,21 +303,7 @@
let array: [i64; 6] = [92,97,98,99,98,94];
-多维数组
-
-
-
j0 j1 j2 j3 j4 j5
- ┌────┬────┬────┬────┬────┬────┐
-i0 | 1 | 2 | 3 | 4 | 5 | 6 |
- ├────┼────┼────┼────┼────┼────┤
-i1 | 6 | 5 | 4 | 3 | 2 | 1 |
- └────┴────┴────┴────┴────┴────┘
--
let array: [[i64; 6] ;2] = [
- [1,2,3,4,5,6],
- [6,5,4,3,2,1]];
-可变数组
let mut array: [i32 ; 3] = [2,6,10];
array[1] = 4;
array[2] = 6;
@@ -326,10 +315,6 @@
let mut slices: &[i64] = &array[0..3]
println!("切片的元素是：{slices:?}");
向量
-
let some_vector = vec![1,2,3,4,5];
-使用 vec! 宏声明向量
元组
let tuple = (1, 'A' , "Cool", 78, true);
Rust 动态数组
-
常用方法
-
+
创建动态数组
+
let v: Vec<i32> = Vec::new();
+// 使用宏
+let v1 = vec![1, 2, 3];
+读取元素
+
let v = vec![1, 2, 3, 4, 5];
+
+let element = &v[100];
+// panic，越界
+let element2 = v.get(100);
+println!("{:?}", element2);
+//None
+遍历数组
+
-
+
-
+
只读取数组中的元素
+
+let v = vec![1, 2, 3]; +for i in &v { + println!("{}", i); +} +
+ -
+
遍历的同时修改数组中的元素
+
+let mut v = vec![1, 2, 3]; +for i in &mut v { + *i += 10 +} +
+
多维数组
+
+
j0 j1 j2 j3 j4 j5
+ ┌────┬────┬────┬────┬────┬────┐
+i0 | 1 | 2 | 3 | 4 | 5 | 6 |
+ ├────┼────┼────┼────┼────┼────┤
+i1 | 6 | 5 | 4 | 3 | 2 | 1 |
+ └────┴────┴────┴────┴────┴────┘
++
let arr = vec![
+ vec![1, 2, 3, 4, 5, 6],
+ vec![6, 5, 4, 3, 2, 1]
+];
+常用方法
+
@@ -446,31 +478,71 @@
-
| - | :- |
|---|---|
len() | 返回 vec 的长度 |
is_empty() | vec 是否为空 |
push(value) | 在 vec 尾部插入元素 |
pop() | 删除并返回 vec 尾部的元素或者返回 None |
insert(index,element) | 在指定索引处插入元素 |
remove(index) | 删除指定索引处的元素并返回被删除的元素，索引越界将 panic 报错退出 |
clear() | 清空 vec |
append(vec) | 将另一个 vec 中的所有元素追加移入 vec 中，移动的 vec 变为空 |
truncate(len) | 将 vec 截断到指定长度,多余的元素被删除 |
retain(f) | 根据给定的函数，保留满足条件的元素 |
drain(range) | 删除 vec 中指定范围的元素,同时返回一个迭代该范围所有元素的迭代器 |
split_off(index) | 切分 vec，索引左边的元素保留在原 vec 中(含索引)，索引右边的元素(不含索引)在返回的 vec 中 |
创建动态数组
-
let v: Vec<i32> = Vec::new();
-// 使用宏
-let v1 = vec![1, 2, 3];
-遍历数组
-
只读取数组中的元素
-let v = vec![1, 2, 3];
-for i in &v {
- println!("{}", i);
+枚举
+
在结构体中使用枚举
+
enum IpAddrKind {
+ V4,
+ V6,
+}
+struct IpAddr {
+ kind: IpAddrKind,
+ address: String,
+}
+
+fn main(){
+ let ip = IpAddr{
+ kind: IpAddrKind::V4,
+ address: String::from("127.0.0.1")
+ };
}
遍历的同时修改数组中的元素
-let mut v = vec![1, 2, 3];
-for i in &mut v {
- *i += 10
+枚举的变体
+
enum IpAddrKind {
+ V4(u8, u8, u8, u8),
+ V6(String),
+}
+
+fn main() {
+ let home = IpAddrKind::V4(127, 0, 0, 1);
+ let loopback = IpAddrKind::V6(String::from("::1"));
}
读取元素
-
let v = vec![1, 2, 3, 4, 5];
-let element = &v[100];
-// panic，越界
-let element2 = v.get(100);
-println!("{:?}", element2);
-//None
+
+enum Message{
+ Quit,
+ Move {x:i32, y:i32},
+ Write(String),
+ ChangeColor(i32, i32, i32),
+}
+fn main(){
+ let q = Message::Quit;
+ let m = Message::Move {x:10, y:20};
+ let w = Message:: Write(String::from("hello"));
+ let c = Message::ChangeColor(10, 20, 30);
+}
+
+模式匹配结构体
+
#[derive(Debug)]
+enum Grade {
+ A,
+ B,
+ C,
+}
+enum Subject {
+ Math(Grade),
+ English(Grade),
+}
+
+fn subject_grade(sub: Subject) {
+ match sub {
+ Subject::Math(grade) => println!("The Math is {:?}", grade),
+ Subject::English(grade) => println!("The Math is {:?}", grade),
+ }
+}
+
+fn main() {
+ subject_grade(Subject::Math(Grade::A));
+}
Rust 运算符
比较运算符
@@ -621,7 +693,7 @@
-
+
| 示例 | 意义 |
|---|---|
c && d | 两者都是真的 (AND) |
c || d | 要么是真的 (OR) |
!c | c 为假 (NOT) |
| 示例 | 意义 |
|---|---|
c && d | 两者都是真的_(AND)_ |
| `c | |
!c | c 为假 (NOT) |
let (c, d) = (true, false);
let and = c && d; // => false
@@ -825,76 +897,73 @@
使用 .. 忽略剩余参数
struct Point {
- x: i32,
- y: i32,
- z: i32,
+ x: i32,
+ y: i32,
+ z: i32,
}
let origin = Point { x: 0, y: 0, z: 0 };
match origin {
- Point { x, .. } => println!("x is {}", x),
+ Point { x, .. } => println!("x is {}", x),
}
使用 _ 忽略部分参数
let hello = ('h', 'e', 'l', 'l', 'o');
match hello {
- (h, _, _, l, o) => {
- println!("char: {}, {}, {}", h, l, o)
- },
+ (h, _, _, l, o) => {
+ println!("char: {}, {}, {}", h, l, o)
+ },
}
匹配命名变量
以下代码，只要给定的 x 是 Some 类型，但 Some 中的值不是 1，都会匹配到 y
let x = Some(10);
match x {
- Some(1) => println!("x = 1"),
- Some(y) => println!("y = {:?}", y),
- _ => println!("None"),
+ Some(1) => println!("x = 1"),
+ Some(y) => println!("y = {:?}", y),
+ _ => println!("None"),
}// y = 10
@ 绑定
@ 运算符允许为一个字段绑定另外一个变量。
let grade = 'A';
+let grade = 'A';
match grade {
- good @ 'A'..='C' => println!("your grade is {}", good),
- _ => println!("Come on"),
+ good @ 'A'..='C' => println!("your grade is {}", good),
+ _ => println!("Come on"),
}
-
-#[derive(Debug)]
+#[derive(Debug)]
struct Point {
- x: i32,
- y: i32,
+ x: i32,
+ y: i32,
}
fn main(){
- let p @ Point {x: px, y: py } = Point {x: 10, y: 23};
- println!("x: {}, y: {}", px, py);
- println!("{:?}", p);
+ let p @ Point {x: px, y: py } = Point {x: 10, y: 23};
+ println!("x: {}, y: {}", px, py);
+ println!("{:?}", p);
}
-
如果使用 |，需要使用 ()，进行多个模式的绑定
match 1 {
- num @ (1 | 2) => {
- println!("{}", num);
- }
- _ => {}
+ num @ (1 | 2) => {
+ println!("{}", num);
+ }
+ _ => {}
}
使用匹配守卫
-
let x = Some(2);
+let x = Some(2);
match x {
- Some(1) => println!("x = 1"),
- Some(y) if y == 2 => println!("y = {:?}", y),
- _ => println!("No match"),
+ Some(1) => println!("x = 1"),
+ Some(y) if y == 2 => println!("y = {:?}", y),
+ _ => println!("No match"),
}// y = 2
-
Rust 函数
函数命名
rust 的函数使用蛇形命名法（snake case）
@@ -902,30 +971,29 @@ println!("Hello, Quick Reference!"); } -参数值
-
+
参数值
rust 需要为函数的参数标明确定的类型
fn another_fn(a:u8, b: &str){
- println!("我是 u8:{}", a);
- println!("我是 &str:{}", b);
+ println!("我是 u8:{}", a);
+ println!("我是 &str:{}", b);
}
fn main(){
- another_fn(10, "hello")
+ another_fn(10, "hello")
}
返回值
-
+
返回值
如果不指定返回值，rust 默认返回 () 类型
// 在 bin 中的入口函数默认返回 ()
fn main(){}
使用 -> 指定返回值，如果表达式在最后一行，无需使用 return
+
使用 -> 指定返回值，如果表达式在最后一行，无需使用 return
fn add(a:i32, b:i32) -> i32 {
- if a + b < 100 {
- return a - b;
- }
- a + b
+ if a + b < 100 {
+ return a - b;
+ }
+ a + b
}
