cisen
commented
5 years ago 语法
基础数据类型
有符号整形：i8，i16，i32，i64和isize（指针大小） 无符号整形：u8，u16，u32，u64和usize（指针大小） 浮点类型：f32，f64（与IEEE-754单双精度数字相对应。） 字符类型是Unicode值，像‘a’,'α' 和 '∞' （4 字节长） bool类型非true即否 单元类型()，同时值也为（） 数组，例如[1, 2, 3] 元组，例如(1, true)
常用类型转化
| x类型\至类型 | i32 | u32 | f64 | String |
|---|---|---|---|---|
| i32 | n/a | x as u32 | x as f64 | x.to_string() |
| u32 | x as u32 | n/a | x as f64 | x.to_string() |
| f64 | x as i32 | x as u32 | n/a | x.to_string() |
| String* | x.parse().unwrap() | x.parse().unwrap() | x.parse().unwrap() | n/a |
*可以看到i32, u32, f64（i代表init，u代表dobble，f代表float） 到String类型是同一个函数，这样的话，如何来确定要转换至的具体类型？就是类型推导！当然，如果rust无法通过上下文推导出类型，就需要给出提示，例如x.parse::
- 每一种类型都有自己的属性方法，比如f32，u32.floor函数
&str/String/collections::string::String
| x类型\至类型 | String | &str |
|---|---|---|
| String | n/a | &*x |
| &str | x.to_string() | n/a |
Vec
| x类型\至类型 | Vec |
&[T] | Box<[T]> |
|---|---|---|---|
| Vec |
n/a | &x[..] | x.into_boxed_slice() |
| &[T] | x.to_vec() | n/a | Box::new(*x) |
| Box<[T]> | x.to_vec() | &*x | n/a |
- vec的index是usize
箭头 ->
- 生命函数的返回值的类型
双冒号 ::
- 表示命名空间，这与C++相同，一般父子关系获取
#号
-
[foo] 作用于下一个项，在这就是struct声明。
-
![bar] 作用于包含它的项，在这是mod声明。否则，它们是一样的。它们都以某种方式改变它们附加到的项的意义。
:单冒号
-
继承，可以继承
trait Foo { fn foo(&self); // default method fn bar(&self) { println!("We called bar."); } }
// inheritance trait FooBar : Foo { fn foobar(&self); }
## 指针`*` ` &` `ref` `ref mut`
- 为什么要有这些指针符号？
- - 因为可以不用管cpu是多少位的，也就是寄存器是多少位的，也就是不用管栈是多大的
- &相等与定义了一个新的变量，只是这个变量是一个指针，而且这个变量的生命周期跟宿主是独立的
### `*`
- 解除引用，表示获取地址（指针）指向的值
```rust
fn test_ref(){
let mut num = 5;
// 指针的地址值
let num_ref = &mut num;
// 获取该指针指向的地址的值
*num_ref = 100;
println!("{} sizeof &i32 {}", num, std::mem::size_of::<&i32>())
// output 100 sizeof &i32:8
}&
- 获取该值的地址，就是获得（创建）指针
ref
- 跟取地址符号
[]一样，只是它可以防止等号的左边 就是有时候不方便 用 & 的地方，可以用 ref ref 在=号左边let a = &3_u8 ; let ref b = 3_u8; assert_eq!(*a,*b);
?问号
- 好像是为了简化Result的写法，省略了一个match
// 什么是问号操作符? // 参考: https://doc.rust-lang.org/book/second-edition/ch09-02-recoverable-errors-with-result.html // 参考: https://stackoverflow.com/questions/42917566/what-is-this-question-mark-operator-about
// 由于Rust中没有Exception异常处理的语法, // Rust只有panic报错, 并且panic不允许被保护, 因为没有提供 try 这种语法. // Rust的异常处理是通过 Result 的 Ok 和 Err 成员来传递和包裹错误信息. // 然而错误信息的处理一般都是要通过match来对类型进行比较, 所以很多时候 // 代码比较冗余, 通过?符号来简化Ok和Err的判断.
// 下面的例子提供了一个不使用?符号 以及 一个使用?符号的样例代码.
fn halves_if_even<'a >(i: i32) -> Result<i32, &'a str> { // 取数值的二分之一.
if i % 2 == 0 {
Ok(i/2)
} else {
Err("error")
}
}
fn not_use_question_mark() {
let a = 10; // 把这里改成 9 就会报错.
let half = halves_if_even(a);
let half = match half {
Ok(item) => item,
Err(e) => panic!(e),
};
assert_eq!(half, 5);
}
fn use_question_mark<'a >() -> Result<i32, &'a str> { // 这里必须要返回Result
let a = 10;
let half = halves_if_even(a)?; // 因为?要求其所在的函数必须要返回Result
assert_eq!(half, 5);
Ok(half)
}
fn main() {
not_use_questionmark();
let = use_question_mark();
}
## 数据类型
- [i是有符号，u是无符号](https://rustlang-cn.org/office/rust/book/common-programming-concepts/ch03-02-data-types.html#%E6%A0%87%E9%87%8F%E7%B1%BB%E5%9E%8B)
## 模块系统
- [使用`pub`, `use`, `as`导出和引入模块](https://rustlang-cn.org/office/rust/book/packages-crates-and-modules/ch07-02-modules-and-use-to-control-scope-and-privacy.html#%E6%A8%A1%E5%9D%97%E7%B3%BB%E7%BB%9F%E7%94%A8%E6%9D%A5%E6%8E%A7%E5%88%B6%E4%BD%9C%E7%94%A8%E5%9F%9F%E5%92%8C%E7%A7%81%E6%9C%89%E6%80%A7)
- 默认会加载`main.rs`, `lib.rs`
## impl
- 是为了在struct、enum或者trait对象添加方法
- https://rustcc.gitbooks.io/rustprimer/content/quickstart/function-method.html
## trait
- **trait+impl相当于TS的interface+泛型，比如可以实现text跟button共享drow函数。struct+impl相当于interface，只能实现smallbutton，middlebutton。**
- trait是多个函数的集合，可以根据参数静态派发（编译前知道是那个函数）指定函数。怎么解析呢？
```rust
trait Hash {
fn to_hash(&self) -> u64;
}
impl Hash for bool {
fn to_hash(&self) -> u64 {
if *self {
1
} else {
0
}
}
}
impl Hash for i64 {
fn to_hash(&self) -> u64 {
&self as u64
}
}
// T是泛型
fn print_to_hash<T: Hash>(t: T) {
// t会根据数据类型调用不同的to_hash方法
println!("hash {}", t.to_hash());
}- 我们知道rust是没有继承这个机制的，rust的多态是通过trait来实现的。trait定义的方法可以被不同的对象实现。
- trait是用来描述impl接口的
- 注意看这里
- http://wiki.jikexueyuan.com/project/rust-primer/trait/overview.html
- https://rustlang-cn.org/office/rust/book/generics/ch10-02-traits.html
- trait是rust唯一的接口抽象方式
- 简单来说，trait是对类型行为的抽象
- 使用trait是因为rust贯彻组合优于继承和面向接口编程的编程思想
- 孤儿规则（一致性原理）
- 继承
trait Base {} trait Child : Base {}
宏调用
- http://wiki.jikexueyuan.com/project/rust-primer/macro/macro.html
- 在函数后面加!号，比如
hello!(22) - 宏声明：
macro_rules! macro_name { macro_body }
#[inline]
- https://rustcc.gitbooks.io/rustprimer/content/attr-and-compiler-arg/attribute.html
- https://doc.rust-lang.org/reference/attributes.html#attributes
- https://doc.rust-lang.org/reference/attributes/codegen.html#the-inline-attribute
- 只是将声明当前函数会被copy到调用者的函数里面，而不是通过引用调用。是直接copy整个函数给调用者调用
label
你也许会遇到这样的情形，当你有嵌套的循环而希望指定你的哪一个 break 或 continue 该起作用。就像大多数语言，默认 break 或 continue 将会作用于当前层的循环。当你想要一个 break 或 continue 作用于一个外层循环，你可以使用标签来指定你的 break 或 continue 语句作用的循环。 如下代码只会在 x 和 y 都为奇数时打印他们：
'outer: for x in 0..10 {
'inner: for y in 0..10 {
if x % 2 == 0 { continue 'outer; } // continues the loop over x
if y % 2 == 0 { continue 'inner; } // continues the loop over y
println!("x: {}, y: {}", x, y);
}
}字符串
str 和 String
- str不可变，String可变
数组 array
- 数组目前只支持固定长度，就是分配前就知道数组元素个数。动态长度的数组请使用Vec
- 数组是同一类型的数据的集合
泛型
- 泛型的理解
- 通常使用T来代表一个泛型
- Option
经过特殊处理，可以直接使用Some（T）或者None来表示 struct Duck; struct Pig; // trait可以作为一个类型，传给泛型限制 trait Fly { fn fly(&self) -> bool, } // 给Duck实现具体的fly方法（注意impl下面的fly是方法不是函数） // 这里其实就是多态 impl Fly for Duck { fn fly(&self) -> bool { return true; } } impl Fly for Pig { fn fly(&self) -> bool { return false; } } // 泛型，静态分发，限制fly_static的参数类型必须是包含fly函数的 fn fly_static<T: Fly>(s: T) -> bool { s.fly(); } // 动态分发，这里&Fly是一种动态类型，表示拥有fly行为 // 这里根泛型的区别是，1. 调用方法不同，2. 底层调用原理不同 fn fly_dyn(s: &Fly) -> bool { s.fly() } fn main() { let pig = Pig; assert_eq!(fly_static::<Pig>(pig), flase); let duck = Duck; assert_eq!(fly_static::<Duck>(duck), true); assert_eq!(fly_dyn(&Pig), false); assert_eq!(fly_dyn(&Duck), true); }
## `#[derive(Debug)]`打印调试内容
- [trait](https://rustlang-cn.org/office/rust/book/structs/ch05-02-example-structs.html#%E9%80%9A%E8%BF%87%E6%B4%BE%E7%94%9F-trait-%E5%A2%9E%E5%8A%A0%E5%AE%9E%E7%94%A8%E5%8A%9F%E8%83%BD)
## 返回值
- `{}`表示[语句](https://rustlang-cn.org/office/rust/book/common-programming-concepts/ch03-03-how-functions-work.html#%E5%8C%85%E5%90%AB%E8%AF%AD%E5%8F%A5%E5%92%8C%E8%A1%A8%E8%BE%BE%E5%BC%8F%E7%9A%84%E5%87%BD%E6%95%B0%E4%BD%93)，如果最后一句没带分号就是返回值
- **[最后一句带分号，不带差别很大](https://rustlang-cn.org/office/rust/book/common-programming-concepts/ch03-03-how-functions-work.html#%E5%85%B7%E6%9C%89%E8%BF%94%E5%9B%9E%E5%80%BC%E7%9A%84%E5%87%BD%E6%95%B0)**
## 引用和借用
- https://segmentfault.com/a/1190000002902858
## 内存管理(stack 和Box)
- http://wiki.jikexueyuan.com/project/rust/the-stack-and-the-heap.html
- http://wiki.jikexueyuan.com/project/rust/box-syntax-and-patterns.html
- https://www.bookstack.cn/read/rust-by-example-cn/src-std-box.md
- https://doc.rust-lang.org/stable/std/boxed/
### Box
- 用于分配堆内存
## 闭包
- https://rustcc.gitbooks.io/rustprimer/content/closure/syntax.html
- 其实可以不使用闭包。函数也是rust的第一等公民，函数作为参数给其他函数使用时类型是`fn()->type`
- rust中闭包根函数的最重要区别是：闭包可以读取外部变量，函数不可以读取函数外部的变量。这跟js是不一样的。rust中，闭包是匿名函数，但是定义根函数完全不一样
## 保留字
### match
- 相当于switch
- https://blog.csdn.net/teamlet/article/details/51001314
- http://wiki.jikexueyuan.com/project/rust-primer/match/match.html
- https://rustcc.gitbooks.io/rustprimer/content/quickstart/control-flow.html
- https://rustcc.gitbooks.io/rustprimer/content/quickstart/control-flow.html
```rust
let x = 5;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
4 => println!("four"),
5 => println!("five"),
_ => println!("something else"),
}let day = 5;
match day {
0 | 6 => println!("weekend"),
1 ... 5 => println!("weekday"),
_ => println!("invalid"),
}其中|用于匹配多个值，...匹配一个范围 (包含最后一个值)，并且_在这里是必须的， 因为match强制进行穷尽性检查 (exhaustiveness checking)，必须覆盖所有的可能值。 如果需要得到|或者...匹配到的值，可以使用@绑定变量：
let x = 1;
match x {
e @ 1 ... 5 => println!("got a range element {}", e),
_ => println!("anything"),
}&self:Self
- Self是trait和struct的隐藏类型，代表当前类型，self代表当前类型的接收者
- 写法
self:Self -> Self self: &Self -> &Self Self: &mut Self -> &mut Self
enum 枚举
- 第一个枚举成员的默认值为整型的0，后续枚举成员的值在前一个成员上加1
- 枚举的每个值可以带key，比如QuoteExpansion就是key，值是1
pub enum FileName { // 真实文件名，值是0 Real(RealFileName), /// Call to `quote!`. QuoteExpansion(u64), /// Command line. Anon(u64), /// Hack in `src/librustc_ast/parse.rs`. // FIXME(jseyfried) MacroExpansion(u64), ProcMacroSourceCode(u64), /// Strings provided as `--cfg [cfgspec]` stored in a `crate_cfg`. CfgSpec(u64), /// Strings provided as crate attributes in the CLI. CliCrateAttr(u64), /// Custom sources for explicit parser calls from plugins and drivers. Custom(String), DocTest(PathBuf, isize), /// Post-substitution inline assembly from LLVM InlineAsm(u64), }
vec
- 列表
- https://blog.csdn.net/wowotuo/article/details/74853084
- https://blog.csdn.net/wowotuo/article/details/74998171
loop
- 对于无限循环，Rust有一个专用的关键字loop。 如果需要提前退出循环，可以使用关键字break或者continue， 还允许在循环的开头设定标签 (同样适用于for循环)
if/let，while/let
- 总结就是简化版的match，只抓取需要的一种情况
- http://wiki.jikexueyuan.com/index.php/project/rust/if-let.html
let x = Some(5); match x { Some(_) => {do_something();}, None => {} } let x = Some(5); if let Some(_) = x { do_something() }范式：
if let pattern = expression { do_something() } else { other() } while let pattern = expression { do_something() }
if let 语法让我们以一种不那么冗长的方式结合 if 和 let，来处理只匹配一个模式的值而忽略其他模式的情况。考虑示例 6-6 中的程序，它匹配一个 Option
let some_u8_value = Some(0u8);
match some_u8_value {
Some(3) => println!("three"),
_ => (),
}示例 6-6：match 只关心当值为 Some(3) 时执行代码
我们想要对 Some(3) 匹配进行操作但是不想处理任何其他 Some
不过我们可以使用 if let 这种更短的方式编写。如下代码与示例 6-6 中的 match 行为一致：
# let some_u8_value = Some(0u8);
if let Some(3) = some_u8_value {
println!("three");
}if let 获取通过等号分隔的一个模式和一个表达式。它的工作方式与 match 相同，这里的表达式对应 match 而模式则对应第一个分支。
使用 if let 意味着编写更少代码，更少的缩进和更少的样板代码。然而，这样会失去 match 强制要求的穷尽性检查。match 和 if let 之间的选择依赖特定的环境以及增加简洁度和失去穷尽性检查的权衡取舍。
换句话说，可以认为 if let 是 match 的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值。
可以在 if let 中包含一个 else。else 块中的代码与 match 表达式中的 _ 分支块中的代码相同，这样的 match 表达式就等同于 if let 和 else。回忆一下示例 6-4 中 Coin 枚举的定义，其 Quarter 成员也包含一个 UsState 值。如果想要计数所有不是 25 美分的硬币的同时也报告 25 美分硬币所属的州，可以使用这样一个 match 表达式：
# #[derive(Debug)]
# enum UsState {
# Alabama,
# Alaska,
# }
#
# enum Coin {
# Penny,
# Nickel,
# Dime,
# Quarter(UsState),
# }
# let coin = Coin::Penny;
let mut count = 0;
match coin {
Coin::Quarter(state) => println!("State quarter from {:?}!", state),
_ => count += 1,
}或者可以使用这样的 if let 和 else 表达式：
# #[derive(Debug)]
# enum UsState {
# Alabama,
# Alaska,
# }
#
# enum Coin {
# Penny,
# Nickel,
# Dime,
# Quarter(UsState),
# }
# let coin = Coin::Penny;
let mut count = 0;
if let Coin::Quarter(state) = coin {
println!("State quarter from {:?}!", state);
} else {
count += 1;
}如果你的程序遇到一个使用 match 表达起来过于啰嗦的逻辑，记住 if let 也在你的 Rust 工具箱中。
pub enum RealFileName {
Named(PathBuf),
// 对于非虚拟化路径（即已映射到本地主机文件系统上适当位置的libstd路径），
Devirtualized {
// 具体到某操作系统的真正路径
local_path: PathBuf,
/// build artifacts.
// 虚拟路径
virtual_name: PathBuf,
},
}
pub fn into_local_path(self) -> PathBuf {
match self {
// 如果匹配到RealFileName::Named, 或者RealFileName::Devirtualized 则取出p
RealFileName::Named(p)
| RealFileName::Devirtualized { local_path: p, virtual_name: _ } => p,
}
}匿名函数
匿名函数 Rust使用闭包 (closure) 来创建匿名函数：
let num = 5;
let plus_num = |x: i32| x + num;其中闭包plus_num借用了它作用域中的let绑定num。如果要让闭包获得所有权， 可以使用move关键字：
let mut num = 5;
{
let mut add_num = move |x: i32| num += x; // 闭包通过move获取了num的所有权
add_num(5);
}
// 下面的num在被move之后还能继续使用是因为其实现了Copy特性
// 具体可见所有权(Owership)章节
assert_eq!(5, num);Rust标准库 std
std::io
io::stdin()
- 输入
- 可以使用
ctrl+D/Z结束输入
std::io::Write;
- https://doc.rust-lang.org/std/macro.write.html
- 作用是格式化一段数据为buffer二进制
- 第一个参数时待格式化的字符串，第二参数或者后面的都是格式化的工具比如正则
- 该函数返回值是一个stream，也会修改原来的变量的值字符串
let mut w = Vec::new(); // w 将变成“Hello world!” aa 是一个stream let aa = write!(&mut w, "Hello {}!", "world");
std::io::Cursor
- 在内存中模拟文件的读写，一般用于非生产环境，用于提升效率
std::fmt (format的缩写)
- https://doc.rust-lang.org/std/fmt/
- 该库主要用于格式化和打印字符串
- format/write/println都支持正则匹配{}
write!
- https://doc.rust-lang.org/std/fmt/#write
- 触发将字符串转化为stream，为了提升性能，减少格式化转化的中间变量而直接输出stream
- 实际上这个宏就是std::io::Write函数，只是它是某些特殊场景的下的
- 该函数返回值是一个stream，也会修改原来的变量的值字符串
let mut w = Vec::new(); // w 将变成“Hello world!” aa 是一个stream let aa = write!(&mut w, "Hello {}!", "world");
std::thread
Rust 通过 spawn 函数提供了创建本地操作系统（native OS）线程的机制，该函数的参数是一个转移闭包（moving closure）。 Rust默认会开4个线程，新开的线程另算。
use std::thread;
static NTHREADS: i32 = 10;
// 这是主（`main`）线程
fn main() {
// 提供一个 vector 来存放所创建的子线程（children）。
let mut children = vec![];
for i in 0..NTHREADS {
// 启动（spin up）另一个线程
children.push(thread::spawn(move || {
println!("this is thread number {}", i)
}));
}
for child in children {
// 等待线程到结束。返回一个结果。
let _ = child.join();
}
}
std::option::Option.expect和
- https://doc.rust-lang.org/std/option/enum.Option.html#method.expect
- https://doc.rust-lang.org/std/option/enum.Option.html#method.unwrap
- unwrap: 如果 Result 值是 Ok，返回 Ok 中的值，如果是 Err会自动调用 panic!。
- expect: 可以在参数中自定义要显示的错误信息，并在自动调用 panic! 时，显示在错误信息中，有助于追踪 panic 的根源。
default 默认类型
- https://doc.rust-lang.org/std/default/trait.Default.html
- 表示默认值。不用使用变量名就可以获取到变量的默认值
Option
- https://rustcc.gitbooks.io/rustprimer/content/error-handling/option-result.html
- Some，当有一个 Some 值时，我们就知道存在一个值，而这个值保存在 Some 中，具体是什么还不确定。
- option主要是为了避免开发中Null值的问题
- option也是一种枚举
Rust 并没有很多其它语言中有的空值功能。不过它确实拥有一个可以编码存在或不存在概念的枚举。这个枚举是 Option
enum Option<T> {
Some(T),
None,
}空值（Null） 是一个值，它代表没有值。在有空值的语言中，变量总是这两种状态之一：空值和非空值。
Option
如果使用 None 而不是 Some，需要告诉 Rust Option
let some_number = Some(5);
let some_string = Some("a string");
let absent_number: Option<i32> = None; // 这里必须声明类型当有一个 Some 值时，我们就知道存在一个值，而这个值保存在 Some 中。当有个 None 值时，在某种意义上它跟空值是相同的意义：并没有一个有效的值。
Option
let x: i8 = 5;
let y: Option<i8> = Some(5);
let sum = x + y; // error no implementation for `i8 + Option<i8>`当在 Rust 中拥有一个像i8这样类型的值时，编译器确保它总是有一个有效的值。我们可以自信使用而无需判空。只有当使用Option
错误处理
- http://wiki.jikexueyuan.com/project/rust-primer/error-handling/option-result.html
- panic， 报错，暂停当前线程
- Option， 是类型系统，多种类型选一个
- Result， Result是Option的更通用的版本，比起Option结果为None它解释了结果错误的原因
-
- 没错和Option一样，事实上它们拥有很多类似的方法，不同的是，Result包括了错误的详细描述，这对于调试人员来说，这是友好的。
-
- 比如
Result::Ok(val)Result::Err-- Result<T, E>的泛型T表示OK函数的参数类型，E表示错误函数的参数类型
- 比如
学习rust的朋友可能经常看到Result和Option，虽然不一定直接看到他们本身，但是他们的方法还是常见的，比如:xxx.ok().expect(“…”); 这个xxx一般就是某个函数返回的Result类型了，下面就详细的讲解下他们的来源
现在看看rust book里的那个guess game，有这么一段： http://doc.rust-lang.org/book/guessing-game.html
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin().read_line(&mut guess)
.ok()
.expect("Failed to read line");
println!("You guessed: {}", guess);
}前面几行都好理解，我们看看10～12行的几个ok,expect到底是什么
理解这些内容最好的方法就是看源代码，不过大家别慌，不是要你从头开始啃rust所有源码，只需要有针对性的看就可以了 大家记住下面这个常用的链接，这儿可以查到rust的所有源代码，可以搜索，反应速度非常快： https://doc.rust-lang.org/std/
1、io::stdin() 现在从头开始，先看io::stdin()这个是什么
这个网页的最上方就是输入框了，我们一步步来，先输入 io::stdin 注意：不要加后面括号 下面就是搜索的结果，可以看到第二行就是我们要找的函数（第一行是结构体，我们要找的是函数）
点击进去就可以查看源代码了，这个函数声明很简单，只是返回了一个Stdin的结构体
如果想看源代码就点右上角的那个src，见上图右上角红色框
我们现在不需要去看源代码了，现在看看Stdin的介绍就可以了，看图上左边的红色框里的Stdin是可以点击的，点进去然后找到read_line方法：
fn read_line(&mut self, buf: &mut String) -> Result
Locks this handle and reads a line of input into the specified buffer.
For detailed semantics of this method, see the documentation on BufRead::read_line. 1 2 3 4 5 上面是read_line的介绍，我们不去关心他的实现过程了，先看看他返回的类型是：
Result
type Result
A type for results generated by I/O related functions where the Err type is hard-wired to io::Error.
This typedef is generally used to avoid writing out io::Error directly and is otherwise a direct mapping to std::result::Result. 1 2 3 4 5 上面的介绍部分说的是io::Result其实是为了书写方便定义的，他用io::Error类型替代了std::result::Result<T,Error>里的Error类型
这样io::Result比std::result::Result更加具体化了，那么写起来也相对简单了，他只可能返回io::Error类型的错误
因为这儿io::Result只是个类型定义，所以我们要去看std::result::Result的源代码，搜索过程就不详述了，具体看源码：
pub enum Result<T, E> { /// Contains the success value
[stable(feature = "rust1", since = "1.0.0")]
Ok(T),
/// Contains the error value
#[stable(feature = "rust1", since = "1.0.0")]
Err(E)} 1 2 3 4 5 6 7 8 9 上面就是定义了，可以看到他是个enum，有OK和Err类型，分别对应了Result泛型里的类型T和E，std::result::Result里并没有限制E和T的类型，但是io::Result就把E的类型限制成了io::Error，这个大家注意下就好
说了这么多我们再看看问题
io::stdin().read_line(&mut guess)
.ok()
.expect("Failed to read line");
1
2
3
刚才我们确认了read_line返回的是io::Result
pub fn ok(self) -> Option<T> {
match self {
Ok(x) => Some(x),
Err(_) => None,
}
}1
2
3
4
5
6
3、Option
可以看到ok函数返回的是Option
其实这个函数非常简单，就是一个match，如果没有出错用Option::Some把我们要的数据用包装下返回；如果出错了就返回Option::None
这样皮球又提到了Option去了…我们再继续查Option:
pub enum Option
继续看这个代码，ok()返回的是Option，那么expect肯定就是Option的方法了
io::stdin().read_line(&mut guess) .ok() .expect("Failed to read line"); 1 2 3 继续看Option源代码，看他方法的实现：
pub fn expect(self, msg: &str) -> T {
match self {
Some(val) => val,
None => panic!("{}", msg),
}
}1
2
3
4
5
6
终于看到想要的返回类型了：T，这个就是我们最终要的数据了，看read_line返回的是io::Result
可以看到这个函数也是个match，如果是Some能匹配了就把他携带的数据返回；如果是None类型说明这个Option根本就没携带数据，也就是前面的Result出错了，所以会调用panic!宏把你传递进去的字符串打印出来并且退出程序。
4、其他写法 现在绕了一大圈终于找到T了，其实ok().expect(…);这种只是偷懒的写法，出错了直接打印你的字符串就退出程序了。当然有更偷懒的，看std::result::Result的代码：
pub fn unwrap(self) -> T {
match self {
Ok(t) => t,
Err(e) =>
panic!("called Result::unwrap() on an Err value: {:?}", e)
}
}
1
2
3
4
5
6
7
那么代码就可以写成下面这样就可以了：
io::stdin().read_line(&mut guess).unwrap(); 1 这个是非常不建议的用法，除非你非常肯定read_line不可能出错
虽然这个read_line结果我们并没有使用，但是还是需要处理一下，不然Result没有处理编译器会给警告的
处理result最直接和直观的方法就是直接match，不需要通过Option中转了：
match io::stdin().read_line(&mut guess) { Ok(size)=>xxxx, Err(e)=>xxx, } 1 2 3 4 xxx处换成你自己的代码就可以了
shark2202
总结
C:\Users\cisen\AppData\Local\Temp入门
rustup override set stable/nightlyrustup update stablerustup component add clippyrustup override set 1.50.0,rustup override set 1.50.0-nightlyrustup override set nightly-2020-12-23rustup target add wasm32-unknown-unknownrustup self uninstall为什么
优点
缺点
相关文章