rust 語法概要（只適合不熟悉時快速查閱使用，不適合理解其精髓。未完待續）

注意：本內容只適合快查，不適合理解精髓。精髓請研讀

https://kaisery.github.io/trpl-zh-cn/foreword.html

rust 的核心思想是 由程序員，語法，編譯器 共同 維護 程序內的變量生成，使用，複製，轉移和銷燬。

基本數據類型

i8,i16,i32,i64,i128 //有符號整數

u8,u16,u32,u64,u128 //無符號整數

f32,f64 //浮點數，money估計也要用到此值

char //字符類型

bool:true,false // bool 類型

String //要引用std::string::String //字符串類型

silce //切片，這是個片斷引用

type Name = String; //類型別名，只是個別名不是新類型

類型轉換

as 轉換符 ：

‘c’ as u8

23 as char

i64 as i128; i32 as i64

常量變量

const MAX_POINTS: u32 = 100_000; // 靜態

let x = 5;//綁定變量

let x:u32 = 5;

let mut x = 5;//聲明可變綁定

let mut x:u64 = 5;

let an_integer = 5i32; //經過數據來定義

let y = 3.0_f64; //後綴指定類型

let _noisy_unused_variable = 2u32; // 若是某個值綁定了未使用,會報編譯警告.只要加個前下劃線就不會編譯警告了.

let spaces = " ";//字面值

let spaces = spaces.len();//這是重定義space，而不是設置

let mut spaces = " ";

spaces = ‘3’;//這是變動值內容

let guess: u32 = "42".parse().expect("Not a number!");//這個是轉換+驗證拋錯

下面是字面值（字面量會被編譯到程序中）

Decimal 98_222;

Hex 0xff;

Octal 0o77;

Binary 0b1111_0000;

Byte (u8 only) b'A';

運算符

+-*/% 5大運算，加減乘除餘 整數除 取整，%求餘數，浮點數除就是浮點結果

+=, -=, *=, /=

其餘參考這裏： https://kaisery.github.io/trpl-zh-cn/appendix-02-operators.html

組合結構

let x: (i32, f64, u8) = (500, 6.4, 1); //元組

let x1 = (500i32,"500",500.0f64);

let a = [1, 2, 3, 4, 5]; // 數組

let mut a:[i32;5]=[1,2,3,4,5]; // 可變數組綁定 &a[0]=2後[2,2,3,4,5]

let ys: [i32; 500] = [0; 500]; // i32類型500長度，用0初始化 500長度？

// 數組的定義寫法 變量名:[類型;數組長度]

// 簡化 (1..4) 1-4組合=[1,2,3,4] 但不必定是數組，也多是vector

 

 

打印print 格式化打印

5個打印相關宏 ：format!、format_arg!、print!、println!、write！

兩個 trait: Debug、Display。

print!、println!、就是將 format!的結果輸出到控制檯;

println!("{} days", 31);

println!("{0}, this,is {1}. {1}, this,is {0}", "Alice", "Bob");//我去，this,is被攔截了由於 IS,IS！

println!("{subject} {verb} {object}",object="the lazy dog",subject="the quick brown fox",verb="jumps over");

println!("{} of {:b} people know binary, the other half doesn't", 1, 2);

println!("{number:>width$}", number=1, width=6); // 打印1寬度6

println!("{number:>0width$}", number=1, width=6); //打印1，0寬度6

println!("My name is {0}, {1} {0}", "Bond"); // 沒有{1}對應值，必須加入才能編譯經過

#[allow(dead_code)]

struct Structure(i32);//這個是元組類型結構，用.0 .1訪問成員

fmt::Debug: Uses the {:?} marker. // 實現了Debug特性可用{:?}標記打印信息

fmt::Display: Uses the {} marker. // 實現了display特性可用{}打印信息

println!("This struct `{}` won't print...", Structure(3)); // 注意打印佔位符{} 不是 {:?}，須要Structure實現Display trait

println!("{1:?} {0:?} is the {actor:?} name.", // {1:?} 打印第二個 數組標記法

"Slater",

"Christian",

actor="actor's"); // 打印名字標記法

println!("{:#?}", peter); // 漂亮打印：其實就是參數分行打印，一個參數一行，易讀

impl Display for Structure{ // 這個實現了 Display

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // 這行就是 Display trait的具體方法描述

write!(f, "--({})--", self.0) 這裏是實現：必定不能直接用self，必須用self.0 否則會致使嵌套調用「overflowed its stack」

}

}

函數-方法

fn function_name() { ... } // 孤立的叫 函數，

（impl 可理解爲對象，相似class關鍵字） impl的 函數 且首個參數 是&self 的 叫 方法（相似對象方法），impl內首個參數非&self的方法叫 關聯函數（相似這個對象的靜態方法）

impl AveragedCollection { /*具體參見rust的面向對象部分，這裏給出範例主要爲理解impl是什麼*/

pub fn add( &mut self, value: i32) { self.list.push(value); }

pub fn average( &self) -> f64 { self.average/*這是表達式，會返回值和return相似。沒分號哦！*/ }

pub fn func1(i:String) -> String { "...." } // 這個就是靜態方法了

}

fn another_function(x: i32, y: i32)->i32// 多參數單返回值

fn plus_one(x: i32, y: i32) -> (i32,i32)//多參數多返回值

包含語句和表達式的函數體: 語句（Statements）是執行一些操做但不返回值的指令(有分號結尾)。表達式（Expressions）計算併產生一個值（無分號結尾）。

函數調用是一個表達式。宏調用是一個表達式。

控制結構

if number < 5 { //單個if else

} else {

}

if number % 4 == 0 { // 一堆if else if

} else if number % 3 == 0 {

} else if number % 2 == 0 {

} else {

}

let number = if condition { // if賦值，有分號的叫語句，沒分號的叫表達式-含有返回

5 // 這裏是表達式。會返回

} else {

6 // 這裏是表達式。會返回

};

循環

loop { // 玩命的循環

if true { break; } //仍是能退出的

}

while number != 0 { //不玩命的循環

}

for element in a.iter() { // 挨着循環

}

for number in (1..4).rev() { //倒着循環

}

let v = vec![1;10];

for (index, e) in v.iter().enumerate() { //帶索引循環

}

for (pos, e) in v.iter()

函數參數-引用參數

fn calculate_length(s: &String) -> usize // 引用參數

let len = calculate_length(&s1);

// 可變引用函數

fn change(some_string: &mut String) {

let mut s = String::from("hello");

change( &mut s);

slice 切片

let s = String::from("hello world"); // 這裏是初始化一個字符串，詳細請看String

&s[起點索引值..終點索引值] start..end 語法表明一個以 start 開頭並一直持續到但不包含 end 的 range。

let hello = &s[0..5];// 注意 字符串 時 這裏取的是字節， utf-8不能這樣取！必死！

let world = &s[6..11];// 數組的話ok

let hello = &s[0..=4];// 若是須要包含 end，可使用 ..= 不用等號就是不含4號，加等號含有4號

let slice = &s[0..2]; // 開頭開始取

let slice = &s[..2]; // 開頭開始取，省了0

let len = s.len();

let slice = &s[3..len]; //3到結尾

let slice = &s[3..]; //3到結尾

let slice = &s[0..len]; //全取

let slice = &s[..]; //全取

fn first_word(s: &String) -> &str {

&s[..] // 表達式，返回slice

}

fn first_word(s: &String) -> &str {//這裏（不可變）借用s，返回slice引用，有借鑑 let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } } &s[..]//用表達式返回，有借鑑。某值的不可變引用時，就不能再獲取一個可變引用。 }

let s = "Hello, world!";

這裏 s 的類型是 &str：它是一個指向二進制程序特定位置的 slice。這也就是爲何字符串字面值是不可變的； &str 是一個不可變引用。

字符串接入，字符串+操做

let mut s = String::from("lo"); // 初始化一個字符串 可修改的 s.push('l');//push接入 let s1 = String::from("Hello, "); let s2 = String::from("world!"); let s3 = s1 + &s2; // +接入 // 多個字符串組合 let s1 = String::from("tic"); let s2 = String::from("tac"); let s3 = String::from("toe"); let s = s1 + "-" + &s2 + "-" + &s3; //行但笨 let s = format!("{}-{}-{}", s1, s2, s3); // 女子 // 異類字符 slice let hello = "Здравствуйте"; let s = &hello[0..4];// 必須雙數，取得字節（這裏要注意utf8）！ for c in "Здравствуйте".chars() { //取得字面字符 println!("{}", c); } for b in "Здравствуйте".bytes() { //取得字節 println!("{}", b); }

字符串相等性對比：

str::eq(str1, str2) 對比二者必須是 String或者 str 類型

不排除還有其餘對比方式

引用和借用（rust的重點，精髓，關鍵）

&s1 語法容許咱們建立一個 指向 值 s1 的引用，可是並不擁有它。

fn calculate_length( s: &String) -> usize { // 借用 將獲取引用做爲函數參數稱爲 借用（borrowing）

嘗試修改借用的變量，（默認）不容許修改引用的值。除了一些特別的狀況，好比標準庫基本類型字符類型char.encode_utf8()方法

可變借用一個樣例：

pub fn unicode_utf8(ustr: &String) -> Vec<u8> {//借用來的參數ustr let mut utf8_str: Vec<u8> = Vec::new(); for c in ustr.chars() {//循環每一個字符 let len = c.len_utf8();//獲取其utf8長度 let mut cb:[u8; 4] = [0u8; 4];//可變的引用，取0-4個字節 {// 這裏構成一個做用域，用於隔離另外一個（後面一個）引用借用 let cb_a = &mut cb[..len];//從cb中建立一個可修改引用借用， let r = c.encode_utf8(cb_a);//將可修改引用借用給encode_utf8函數，內部有不安全代碼 println!("r = {:?}", r); }//做用域後cb_a已經失效了，這個引用借用被釋放了 let cb_b = &cb[..len];//再來個引用借用，可是這裏不須要修改了。 for b in cb_b { utf8_str.push(b.clone());//循環將encode_utf8修改的內容裝到vec中。 } } return utf8_str;//返回將unicode轉換utf8編碼後的byte數組vec }

多個不可變引用是沒有問題。不能在擁有不可變引用的 同時擁有可變引用。

在任意給定時間，只能 擁有以下中的一個：

一個可變引用。

任意數量的不可變引用。

引用必須老是有效的。

全部權要點（rust的重點，精髓，關鍵） ★★★★★

棧上數據 拷貝，有兩個值；

堆上數據，使用全部權 移動（move），而不是淺拷貝。

let s1 = String::from("hello");

let s2 = s1;//解讀爲 s1 被 移動 到了 s2 中，這以後s1沒法再使用，全部權轉移到s2上了

let s1 = String::from("hello");

let s2 = s1.clone();//這裏深拷貝了s1的數據。因此s1和s2均可以使用，出現兩個全部權者

fn takes_ownership(some_string: String) //這種方法定義表示輸入參數全部權轉移到函數內部了

fn takes_ownership(some_string: &String) //這種方法定義表示輸入參數全部權被借用進來了

對於基本棧類型 fn makes_copy(some_integer: i32)//這裏參數是拷貝進來的，另外創建了全部權

fn gives_ownership(input: String) -> String { //這裏接收一個全部權，再返回數據將函數內部全部權轉移到外部

let (s2, len) = calculate_length(s1);//此方法傳入s1全部權，處理後返回全部權到s2，還有其餘返回(len)。元組返回處理全部權。可是有些羅嗦

引用（references）借用 & 符號就是 引用，它們容許你使用值但不獲取其全部權。

fn calculate_length(s: &String) -> usize {//輸入參數借用外部數據，可是不獲取其全部權。獲取引用做爲函數參數稱爲 借用（borrowing）（不容許修改引用/借用 ）

與使用 & 引用相反的操做是 解引用（dereferencing），它使用解引用運算符，*。

fn change(some_string: &mut String) {...//可變借用

let mut s = String::from("hello");//定義可變綁定

change(&mut s);//可變借用到函數內部（ 一次只有一個可變借用（可使用大括號隔離多個可變借用 ））

{ let r1 = &mut s;} // r1 在這裏離開了做用域，因此咱們徹底能夠建立一個新的引用 let r2 = &mut s;

也 不能在擁有不可變引用的同時擁有可變引用。

懸垂引用（Dangling References）在函數內部建立，返回其指針，可是函數結束其全部者會被釋放

fn dangle() -> &String { // dangle 返回一個字符串的引用 離開做用域並被丟棄。其內存被釋放。危險！

解決方法是直接返回String。fn no_dangle() -> String {...

 

總結經常使用方法：

String 轉移 (輸入)

&String 借用（輸入）

解決懸垂引用錯誤的方法是 返回 全部權（不是返回地址） -> String 全部權轉移出來（函數輸出）

slice不可變借用

做用域隔離{}

全部權幾個要點

1. Rust 中的每個值都有一個被稱爲其 全部者（owner）的變量。
2. 值有且只有一個全部者。
3. 當全部者（變量）離開做用域，這個值將被丟棄。

struct 結構體

struct User { //定義

username: String,

sign_in_count: u64,

active: bool,

}

let user1 = User { //初始化賦值，相似json的結構

username: String::from("someusername123"),//後面省略

};

let mut user1 = User { //實例一個可變的結構體變量

username: String::from("someusername123"),//後面省略

};// 實例可變，字段可變，實例不可變，字段就不可變。

user1.username = String::from("another"); //賦值

變量與字段同名時的字段初始化簡寫語法（結構體語法糖）

有 字段 let username

User {

username,//這個就是直接 字段名和屬性名同樣直接簡化賦值

active: true,

sign_in_count: 1,

}

let user2 = User {

username: String::from("anotherusername567"),

active: user1.active,

sign_in_count: user1.sign_in_count,

};

可簡化爲

let user2 = User {

username: String::from("anotherusername567"),

..user1

};

結構體數據的全部權

首先username: &str, 這樣的寫法會被編譯器否定

須要生命週期輔助

結構-方法語法

#[derive(Debug)] //這個讓結構體可被打印出來

struct Rectangle {

width: u32,

height: u32,

}

impl Rectangle { // 方法語法，在impl中叫方法，孤立的叫函數

fn area(&self) -> u32 { //注意self 和py相似

self.width * self.height

}

}

let rect1 = Rectangle { width: 30, height: 50 };

rect1.area() //用變量.成員調用

關聯函數（associated functions）

不加&self 就是關聯函數，相似靜態函數。加&self相似對象函數(只在 impl（impl可理解爲對象）中 )

impl Rectangle {

fn square(size: u32) -> Rectangle {

Rectangle { width: size, height: size }

}

}

Rectangle::square(100) //關聯函數訪問

枚舉，每一個值可不一樣類型

enum Message {

Quit,

Move { x: i32, y: i32 }, // 匿名結構體

Write(String),

ChangeColor(i32, i32, i32), //元組

}

Message::ChangeColor //訪問方法

enum Option<T> { //官方一個結構用於返回錯誤和正常結果

Some(T),

None,

}

#[derive(Debug)] // So we can inspect the state in a minute

enum UsState {

Alabama,

// ... etc

}

enum Coin {

Dime,

Quarter(UsState),//這個枚舉類型是另外一個枚舉

}

match coin { // match語法

Coin::Dime => 10, // 直接返回（表達式）

Coin::Quarter(state) => { // 含有函數體

println!("State quarter from {:?}!", state);

25

},

// _ => (), // 通配符匹配，匹配全部剩餘項目

}

// 只匹配一個其餘忽略

let some_u8_value = Some(0u8);

match some_u8_value {

Some(3) => println!("three"),

_ => (),

}

// 只匹配一個其餘忽略 簡化寫法

if let Some(3) = some_u8_value {

println!("three");

} else { ... }

// 這是一組寫法，值得學習

fn plus_one(x: Option<i32>) -> Option<i32> {

match x {

None => None, //空返回

Some(i) => Some(i + 1), //有結果返回

}

}

let five = Some(5);

let six = plus_one(five);

let none = plus_one(None);

pub

pub //控制可見 在 fn impl mod 前面

模塊引用（1.31後有變化）

模塊目錄mymod/lib.rs中註冊同級別模塊（文件），lib.rs文件中（pub mod xmod;）==（指向）同目錄mod名（xmod.rs）

 

extern crate my_library; // 先進入模塊名 同下文的 a

a::series::of::nested_modules(); //完整路徑模塊引用樣例，相似靜態方法

use a::series::of;//use樣例，到of這個級別。以後就能夠經過of引用此結構如下的內容

of::nested_modules(); // use 簡短 引用路徑

use a::series::of::nested_modules;//這是到最後一個級別，直接use到此函數

nested_modules(); // 最深到函數

use TrafficLight::{Red, Yellow}; // 引入多個

let red = Red;

let yellow = Yellow;

let green = TrafficLight::Green;//也能夠直接全路徑引用，只是仍是要完整路徑引入

// * 語法，這稱爲 glob 運算符（glob operator）

use TrafficLight::*; // 全引入

::client::connect(); // 開頭雙冒表從根模塊引用開始

super::client::connect(); // super表上一級模塊開始引用，是上一級不是根！

#[cfg(test)]

mod tests {

use super::client; //在mod內部 super上一級 引入，少些好多super

#[test]

fn it_works() {

client::connect();

}

}

use mymod::mymod2::mymod3 as mm3; // use as 語法use別名 我就說確定有相似的！

注意: 默認好象是不引用std的,有用到std的地方須要在開始 use std;

集合 vcetor

默認引入，無需use

let v: Vec<i32> = Vec::new();

let v = vec![1, 2, 3];

v.push(5); //push進去

v.push(6);

let third: &i32 = &v[2]; // 用索引訪問

let third: Option<&i32> = v.get(2); // get加索引訪問，注意返回類型 超界處理良好

let v = vec![100, 32, 57]; //遍歷1

for i in &v {

println!("{}", i);

}

let mut v = vec![100, 32, 57]; // 可變動遍歷

for i in &mut v {

*i += 50; // 使用 += 運算符以前必須使用解引用運算符（*）獲取 i 中的值。

}

// 枚舉 的 vector 感受好複雜哦！！！

enum SpreadsheetCell {

Int(i32),

Float(f64),

Text(String),

}

let row = vec![

SpreadsheetCell::Int(3),

SpreadsheetCell::Text(String::from("blue")),

SpreadsheetCell::Float(10.12),

];

HashMap

use std::collections::HashMap; // 要use

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);

scores.insert(String::from("Yellow"), 50);

// 這是個雜交組合法，要use std::collections::HashMap;

let teams = vec![String::from("Blue"), String::from("Yellow")];

let initial_scores = vec![10, 50];

let scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect(); //這裏雜交組合兩個vector

// 插入值 全部權轉移

let field_name = String::from("Favorite color");

let field_value = String::from("Blue");

let mut map = HashMap::new();

map.insert(field_name, field_value); // 這裏插入後兩個值全部權被轉移到map內部了

訪問map

let score = scores.get(&team_name);

for (key, value) in &scores { //遍歷

println!("{}: {}", key, value);

}

scores.insert(String::from("Blue"), 25); // 覆蓋

scores.entry(String::from("Blue")).or_insert(50); //沒有就插入，有跳過

// 找到一個鍵對應的值並根據舊的值更新它

let text = "hello world wonderful world";

let mut map = HashMap::new();

for word in text.split_whitespace() {

let count = map.entry(word).or_insert(0);

*count += 1; // 爲了賦值必須首先使用星號（*）解引用 count

}

異常 拋錯

[profile] //cargo.toml 配置

panic = 'abort'

[profile.release] // 這是發佈模式

panic = 'abort'

panic!("crash and burn");// 拋錯語句

設置 RUST_BACKTRACE 環境變量來獲得一個 backtrace backtrace 是一個執行到目前位置全部被調用的函數的列表。（怎麼設置？還不曉得）

enum Result<T, E> { //可恢復的錯誤 的 枚舉

Ok(T),

Err(E),

}

let f = File::open("hello.txt");

let f = match f { // 用match處理成功和失敗

Ok(file) => file,

Err(error) => {

panic!("There was a problem opening the file: {:?}", error)

},

};

// 一個錯誤處理範例 這個範例嵌套了 match

use std::fs::File; use std::io::ErrorKind; fn main() { let f = File::open("hello.txt"); let f = match f { Ok(file) => file, Err(ref error) if error.kind() == ErrorKind::NotFound => { match File::create("hello.txt") { Ok(fc) => fc, // 成功的處理 Err(e) => { panic!( "Tried to create file but there was a problem: {:?}", e // 表達式返回了e ) }, } }, Err(error) => { panic!( "There was a problem opening the file: {:?}", error ) }, }; }

let f = File::open("hello.txt").unwrap(); // unwrap幫調用panic! 宏 可是沒法體現具體錯誤

let f = File::open("hello.txt").expect("Failed to open hello.txt"); // expect能夠體現不一樣的錯誤，更好

傳播錯誤

fn read_username_from_file() -> Result<String, io::Error>{ // 返回參數是「標準庫結果」

let f = File::open("hello.txt");

let mut f = match f {

Ok(file) => file,

Err(e) => return Err(e), // 返回錯誤

};

let mut s = String::new();

match f.read_to_string(&mut s) {

Ok(_) => Ok(s),

Err(e) => Err(e),

}

簡化的錯誤傳播

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)

}

let mut s = String::new();

File::open("hello.txt")?.read_to_string(&mut s)?; //鏈式方法調用

Ok(s)

? 只能被用於返回值類型爲 Result 的函數

泛型

struct Point<T> { //單泛型

x: T,

y: T,

}

struct Point<T, U> { // 多泛型

x: T,

y: U,

}

enum Option<T> { //單泛型枚舉

Some(T),

None,

}

enum Result<T, E> { //多枚舉泛型

Ok(T),

Err(E),

}

impl<T> Point<T> { //泛型方法定義

fn x(&self) -> &T {

&self.x

}

}

impl Point<f32> { // 特定類型方法定義

fn distance_from_origin(&self) -> f32 {

(self.x.powi(2) + self.y.powi(2)).sqrt()

}

}

impl<T, U> Point<T, U> { // 雙泛型 方法定義，方法中還有泛型

fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {

Point {

x: self.x,

y: other.y,

}

}

}

trait 相似接口 定義共享行爲

pub trait Summarizable { // 定義trait

fn summary(&self) -> String;

}

impl Summarizable for NewsArticle { // 爲類型NewsArticle 實現這個trait

fn summary(&self) -> String {

format!("{}, by {} ({})", self.headline, self.author, self.location)

}

}

impl Summarizable for Tweet { // 爲類型 Tweet實現 Summarizable trait

fn summary(&self) -> String {

format!("{}: {}", self.username, self.content)

}

}

限制是：只能在 trait 或對應類型位於咱們 crate 本地的時候爲其實現 trait。換句話說，不容許對外部類型實現外部 trait。例如，不能在 Vec 上實現 Display trait，由於 Display 和 Vec 都定義於標準庫中。

pub trait Summarizable { // 默認實現

fn summary(&self) -> String {

String::from("(Read more...)")

}

}

impl Summarizable for NewsArticle {} // 空impl 塊，直接使用默認trait行爲

pub trait Summarizable { // 默認實現能夠調用未實現的 方法

fn author_summary(&self) -> String; // 這個行爲 由 實現trait者去定義

fn summary(&self) -> String {

format!("(Read more from {}...)", self.author_summary()) // 調用author_summary，而後再調用特定行爲

}

}

Trait Bounds 應該就是約束，實現約束，泛型實現trait約束

pub fn notify<T: Summarizable>(item: T) {

println!("Breaking news! {}", item.summary());

}

fn some_function<T: Display + Clone, U: Clone + Debug>(t: T, u: U) -> i32 { //多個約束

fn some_function<T, U>(t: T, u: U) -> i32 // where方式多個約束

where T: Display + Clone,

U: Clone + Debug

{

生命週期註解語法

生命週期註解並不改變任何引用的生命週期的長短。只是個註解

&i32 // a reference

&'a i32 // a reference with an explicit lifetime

&'a mut i32 // a mutable reference with an explicit lifetime

它只是個變量生命週期的標註，經過標註來識別生命週期範圍，實際不影響變量生命週期

let s: &'static str = "I have a static lifetime."; // 靜態生命週期，全程序週期，字符串字面值自帶

「 生命週期也是泛型」 - 這句話讓我直接炸裂！我艸，我說呢！寫在<>內！

問題：泛型的生命週期呢？是否是要直接定義在泛型類型定義中？

多個生命週期定義只能經過泛型類型，或者結構體類型來定義？

生命週期也存在約束（where）？

fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str { //這裏其實是永遠都不能編譯的？除非用方法語法？

 

測試

cargo test // 項目目錄內運行此命令 就提取測試來運行了

#[cfg(test)] //測試模塊 屬性註解。屬性（attribute）是關於 Rust 代碼片斷的元數據

mod tests {

use super::*; // 引用要測試的模塊 爲哈是super ，要測試的模塊同級別

#[test] //測試方法 屬性註解

fn it_works() {

assert_eq!(2 + 2, 4); // 測試 斷言宏

}

}

assert! 宏由標準庫提供，參數bool，false 時 assert! 調用 panic! 宏 拋錯

assert_eq! 相等斷言宏 和 assert_ne! 不相等斷言宏

assert_eq! 和 assert_ne! 宏在底層分別使用了 == 和 !=。被比較的值必需實現了 PartialEq 和 Debug trait。

能夠直接在結構體或枚舉上添加 #[derive(PartialEq, Debug)] 註解。

let result = greeting("Carol");

assert!(result.contains("Carol")); // 斷言結果中含有「Carol」

assert!(

result.contains("Carol"),

"Greeting did not contain name, value was `{}`", result // 這裏相似重載函數，打印出明確信息

);

#[test]

#[should_panic] // 這裏表示「應該拋錯」 纔是對的

#[should_panic(expected = "Guess value must be less than or equal to 100")] //出錯信息包含expected的字符串就經過

#[ignore] // 忽略此測試

fn greater_than_100() {

Guess::new(200);

}

運行測試

cargo test -- --test-threads=1 // 單線程運行測試

cargo test -- --nocapture // 測試會輸出函數中打印的內容，就是說不截獲（並丟棄）屏幕輸出

cargo test one_hundred // 運行 含有「one_hundred」的測試

cargo test -- --ignored // 只運行忽略的測試

Rust 社區傾向於根據測試的兩個主要分類來考慮問題：單元測試（unit tests）與 集成測試（integration tests）

測試模塊的 #[cfg(test)] 註解告訴 Rust 只在執行 cargo test 時才編譯和運行測試代碼，而在運行 cargo build 時不這麼作。

非pub函數能夠測試

集成測試

目錄中建立tests目錄下放測試代碼文件。

extern crate adder; // 須要導入指定模塊

#[test]

fn it_adds_two() {

assert_eq!(4, adder::add_two(2));

}

測試目錄文件結構和模塊同樣，但子目錄不被測試提取

tests/integration_test.rs // 文件中test 註解會被測試提取

tests/common/mod.rs // 文件中不會被測試提取，測試系統不考慮子模塊的函數。可是上級測試方法能夠調用子級

 

編寫一個命令行程序

use std::env; // 環境變量功能

fn main() {

let args: Vec<String> = env::args().collect(); // 解析參數

let query = &args[1]; // 提取參數，爲啥不是[0]，[0]是二進制文件路徑"target/debug/exename"

let filename = &args[2];

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

}

注意 std::env::args 在其任何參數包含無效 Unicode 字符時會 panic。若是你須要接受包含無效 Unicode 字符的參數，使用 std::env::args_os 代替。這個函數返回 OsString 值而不是 String 值。

use std::env;

use std::fs::File; // std::fs::File 來處理文件

use std::io::prelude::*; // 而 std::io::prelude::* 則包含許多對於 I/O（包括文件 I/O）有幫助的 trait

let mut f = File::open(filename).expect("file not found"); // 讀取文件

let mut contents = String::new();

f.read_to_string(&mut contents) // 文件內容讀取到字符串變量

.expect("something went wrong reading the file");

let query = args[1].clone(); // 簡單無腦的clone有必定好處，能夠不用管生命週期

impl Config {

fn new(args: &[String]) -> Result<Config, &'static str> { // 靜態週期 字符串

if args.len() < 3 {

return Err("not enough arguments");

}

let query = args[1].clone(); // clone

let filename = args[2].clone();

Ok(Config { query, filename }) // 返回Config結構

}

}

use std::process;//進程

let config = Config::new(&args).unwrap_or_else(| err| { // 注意 |err| 和閉包有關 將Err內部值傳給閉包err參數

println!("Problem parsing arguments: {}", err); // 這就是閉包參數err，看起來相似 委託參數相似c#的(err)=>{...}

process::exit(1); //退出進程

});

line.to_lowercase().contains(&query) // 轉換小寫並檢查是否含有&query

env::var("CASE_INSENSITIVE").is_err(); // 獲取環境變量 powershell中設置環境變量：$env.CASE_INSENSITIVE=1

eprintln!("{:?}", &str1) // 標準錯誤輸出宏

閉包（closures）

c#叫委託，c叫函數指針 ( 最好不要亂叫 省得被大神噴！)

代碼特徵就是 || 兩個豎，兩個豎線之間是參數列表。

let 閉包名 = |v1:type, v2:type| -> type {.........................}

相似：c#的 var fn = (v1, v2) => { ....; return i32; } //這個寫法就是類比一下，方便理解。

（一個方法或函數 在機器碼中就是 以某個內存地址開頭的一組機器碼數據，）

use std::thread; // 線程

use std::time::Duration; // 時間差

fn simulated_expensive_calculation(intensity: u32) -> u32 {

thread::sleep(Duration::from_secs(2)); // 睡2秒 這個值得記住

0

}

let expensive_closure = |num, strx| { // 定義一個閉包 委託 函數指針（別瞎叫）

println!("calculating slowly..{}..", strx);

thread::sleep(Duration::from_secs(2));

num

};

let expensive_closure = |num: u32, strx:String| -> u32 {

println!("calculating slowly..{}..", strx);

thread::sleep(Duration::from_secs(2));

num

};

fn add_one_v1 (x: u32) -> u32 { x + 1 } // 這是一組對比，下面的和這個fn一致

let add_one_v2 = |x: u32| -> u32 { x + 1 }; // 指定參數類型返回類型

let add_one_v3 = |x| { x + 1 }; // 不指定類型只寫函數體

let add_one_v4 = |x| x + 1 ; // 連大括號都去掉了

閉包沒法同時進行兩次類型推斷

let example_closure = |x| x;

let s = example_closure(String::from("hello")); // 不拋錯

let n = example_closure(5); // 拋錯 類型不對，已經 被推斷過了。

存放了閉包和一個 Option 結果值的 Cacher 結構體的定義

struct Cacher<T>

where T: Fn(u32) -> u32 // T就是個閉包，T 的 trait bound 指定了 T 是一個使用 Fn 的閉包。

{

calculation: T,

value: Option<u32>,

}

fn main() { // 內部函數

let x = 4;

fn equal_to_x(z: i32) -> bool { z == x } // 這裏 報錯 不能使用 x 函數不能上下文用外部值，閉包能夠

let equal_to_x = |z| z == x; // 這就能夠，捕獲其環境並訪問其被定義的做用域的變量

let y = 4;

assert!(equal_to_x(y));

}

若是你但願強制閉包獲取其使用的環境值的全部權，能夠在參數列表前使用 move 關鍵字。這個技巧在將閉包傳遞給新線程以便將數據移動到新線程中時最爲實用。

fn main() {

let x = vec![1, 2, 3];

let equal_to_x = move |z| z == x; // x 被移動進了閉包，由於閉包使用 move 關鍵字定義。閉包獲取了 x 的全部權，main 再也不容許使用 x 。去掉 println! 便可。

println!("can't use x here: {:?}", x); // x不可用了

let y = vec![1, 2, 3];

assert!(equal_to_x(y));

}

 

迭代器（iterator）

負責遍歷序列中的每一項和決定序列什麼時候結束的邏輯。

let v1 = vec![1, 2, 3];

let v1_iter = v1. iter();

for val in v1_iter {

println!("Got: {}", val);

}

trait Iterator { 迭代器都實現了這個trait特性

type Item;

fn nex t(&mut self) -> Option<Self::Item>; // methods with default implementations elided

}

let mut v1_iter = v1.iter(); // v1_iter 須要是可變的

assert_eq!(v1_iter.next(), Some(&1)); //next以後處理結果

若是咱們須要一個獲取 v1 全部權並返回擁有全部權的迭代器，則能夠調用 into_iter 而不是 iter。

若是咱們但願迭代可變引用，則能夠調用 iter_mut 而不是 iter。

調用 next 方法的方法被稱爲 消費適配器（consuming adaptors）

let v1_iter = v1.iter();

let total: i32 = v1_iter.sum(); // 調用 sum 以後再也不容許使用 v1_iter 由於調用 sum 時它會獲取迭代器的全部權。

let v1: Vec<i32> = vec![1, 2, 3];

let v2: Vec<_> = v1.iter().map(|x| x + 1).collect(); // 閉包+1後返還給Vec<...> v2

// collect 方法。這個方法消費迭代器並將結果收集到一個數據結構中。

 

宏--結構比較複雜較難理解

兩種宏：

聲明式宏（ declarative macro ）來進行元編程（metaprogramming）；

過程式宏（ procedural macro ）來自定義 derive traits | 更像函數（一種過程類型）

 

導入

#[macro_use] // 告訴編譯器讀取全部模塊下的宏，這裏就能區分重名

extern crate serde;

一個宏定義（聲明式宏）

#[macro_export] // 定義 宏 體

macro_rules! strfrom { // 定義宏名 strfrom ，這個宏是將 一個字符串數組 加空格 組合成一個String

( $( $x:expr ),* ) => { // 單邊模式 ( $( $x:expr ),* ) 表示 要匹配 *（0個或多個）個$x:expr模式

{

let mut temp_str = String::from(""); //建立一個字符串變量

$( // 宏替換的塊

temp_str.push_str($x); // 提早換的具體操做

temp_str.push(' ');

)* // 0個或者多個宏替換塊

temp_str // 表達式返回

}

};

}

 

下面是過程式宏

過程宏接收 Rust 代碼做爲輸入，在這些代碼上進行操做，而後產生另外一些代碼做爲輸出，而非像聲明式宏那樣匹配對應模式而後以另外一部分代碼替換當前代碼。

有三種類型的過程宏，不過它們的工做方式都相似。

其一，其定義必須位於一種特殊類型的屬於它們本身的 crate 中。這麼作出於複雜的技術緣由，未來咱們但願可以消除這些限制。

其二，使用這些宏需採用相似示例 19-37 所示的代碼形式，其中 some_attribute 是一個使用特定宏的佔位符。