變量與數(shù)據(jù)類型

常用的三大數(shù)據(jù)結(jié)構(gòu)：

• 動(dòng)態(tài)數(shù)組
• 映射
• 字符串

Rust標(biāo)準(zhǔn)庫(kù)std::collections提供了4種通用的容器類型，其中包含8種數(shù)據(jù)結(jié)構(gòu)。

動(dòng)態(tài)數(shù)組可細(xì)分為普通動(dòng)態(tài)數(shù)組Vec和雙端隊(duì)列VecDeque

映射包括HashMap

字符串包括String等類型

變量和可變性

Rust的變量不同于其他編程語(yǔ)言的變量，其本質(zhì)上是一種綁定語(yǔ)義，即將一個(gè)變量名與一個(gè)值綁定在一起。變量名和值建立關(guān)聯(lián)關(guān)系。

變量默認(rèn)是不可改變的

變量聲明

使用let關(guān)鍵字聲明變量，先聲明后使用

let x :i8 =1
let x = 1 ; // 等價(jià)于 let x: i32 = 1;

變量聲明以let關(guān)鍵字開(kāi)頭，x為變量名，變量名后緊跟冒號(hào)和數(shù)據(jù)類型

Rust編譯器具有變量類型的自動(dòng)推導(dǎo)功能

在可以根據(jù)賦值類型或上下文信息推導(dǎo)出變量類型的情況下，冒號(hào)和數(shù)據(jù)類型可以省略。

變量命名

• 由字母、數(shù)字、下劃線組成
• 字母區(qū)分大小
• 不能以數(shù)字開(kāi)頭，也不能只有下劃線

Rust中下劃線是一種特殊的標(biāo)識(shí)符，其含義是“忽略這個(gè)變量”

變量的可變性

let聲明的變量默認(rèn)是不可變的，在第一次賦值后不能通過(guò)再次賦值來(lái)改變它的值，即聲明的變量是只讀狀態(tài)

在變量名的前面加上mut關(guān)鍵字就是告訴編譯器這個(gè)變量是可以重新賦值的

let mut x = 3;
x = 5;
println!("x: {}",x);

Rust編譯器保證了如果一個(gè)變量聲明為不可變變量，那它就真的不會(huì)變

變量遮蔽

Rust允許在同一個(gè)代碼塊中聲明一個(gè)與之前已聲明變量同名的新變量，新變量會(huì)遮蔽之前的變量，即無(wú)法再去訪問(wèn)前一個(gè)同名的變量，這樣就實(shí)現(xiàn)了變量遮蔽

fn main(){
    let x = 3;
    let x = x+2;
    let x = x*2;
    let x = "Hello, World";
}

變量遮蔽的實(shí)質(zhì)是通過(guò)let關(guān)鍵字聲明了一個(gè)新的變量，只是名稱恰巧與前一個(gè)變量名相同而已，但它們是兩個(gè)完全不同的變量，處于不同的內(nèi)存空間，值可以不同，值的類型也可以不同。

常量

常量是指綁定到一個(gè)標(biāo)識(shí)符且不允許改變的值，一旦定義后就沒(méi)有任何方法能改變其值了

const MAX_NUM : u32 = 1024;

使用const關(guān)鍵字來(lái)聲明常量

常量名通常是大寫字母，且必須指定常量的數(shù)據(jù)類型

常量與不可變變量的區(qū)別主要在于:

• 常量聲明使用const關(guān)鍵字，且必須注明值的類型
• 通過(guò)變量遮蔽的方式可以讓不可變變量的值改變（本質(zhì)上是新的變量，只是同名而已）。但是，常量不能遮蔽，不能重復(fù)定義。
• 不存在內(nèi)層或后面作用域定義的常量去遮蔽外層或前面定義的同名常量的情況。常量一旦定義后就永遠(yuǎn)不可變更和重新賦值。
• 常量可以在任何作用域中聲明，包括全局作用域。在聲明它的作用域中，常量在整個(gè)程序生命周期內(nèi)都有效
• 常量只能被賦值為常量表達(dá)式或數(shù)學(xué)表達(dá)式，不能是函數(shù)返回值，或是其他在運(yùn)行時(shí)才能確定的值。

在編譯階段就要確定其值

基本數(shù)據(jù)類型

強(qiáng)類型的靜態(tài)編譯語(yǔ)言

Rust的基本數(shù)據(jù)類型有整數(shù)類型、浮點(diǎn)數(shù)類型、布爾類型、字符類型、范圍類型等。

整數(shù)類型

整數(shù)可以分為有符號(hào)整型和無(wú)符號(hào)整型

按照存儲(chǔ)大小，整數(shù)類型可以進(jìn)一步分為1字節(jié)、2字節(jié)、4字節(jié)、8字節(jié)、16字節(jié)

Rust默認(rèn)的整數(shù)類型是i32

isize和usize主要作為數(shù)組或集合的索引類型使用，其長(zhǎng)度依賴于運(yùn)行程序的計(jì)算機(jī)系統(tǒng)。在64位計(jì)算機(jī)系統(tǒng)上，其長(zhǎng)度是64位；在32位計(jì)算機(jī)系統(tǒng)上，其長(zhǎng)度是32位。

• 數(shù)字字面量后使用類型后綴
• 前綴0b、0o和0x表示二進(jìn)制、八進(jìn)制和十六進(jìn)制的數(shù)字

let integer1 : u32 = 17 ; // 類型聲明
let integer2 = 17u32;     // 類型后綴聲明
let integer3 = 17 ;       // 默認(rèn)i32
let integer4 : u32 = 0b1001; // 二進(jìn)制
let integer5 : u32 = 0o21;   // 八進(jìn)制
let integer6 : u32 = 0x11 ;  // 十六進(jìn)制
let integer7 = 50_000;   // 數(shù)據(jù)可讀性分隔符_

Rust允許使用下劃線“_”作為虛擬分隔符來(lái)對(duì)數(shù)字進(jìn)行可讀性分隔

Rust在編譯時(shí)會(huì)自動(dòng)移除數(shù)字可讀性分隔符“_”。

如果某個(gè)變量的值超出了給定的數(shù)值范圍，將會(huì)發(fā)生整型溢出。編譯器將其視為一種錯(cuò)誤。

浮點(diǎn)數(shù)類型

浮點(diǎn)數(shù)分為f32和f64兩類。Rust默認(rèn)的浮點(diǎn)數(shù)類型是f64

• f32: 單精度， 小數(shù)點(diǎn)后至少6位有效數(shù)字
• f64 : 雙精度， 小數(shù)點(diǎn)后至少15位有效數(shù)字

浮點(diǎn)數(shù)支持使用數(shù)字可讀性分隔符“_”

let float1 : f32 = 1.1;  // 類型聲明
let float2  = 2.2f32;  // 類型后綴聲明
let float3 = 3.3  ;  // 默認(rèn)f64類型
let float4 = 11_00.555_01;  // 數(shù)字可讀性分隔符

布爾類型

使用bool來(lái)聲明布爾類型的變量

let t : bool = true;  //顯式類型聲明
let f = false ;       // 隱式類型聲明

字符類型

Rust使用UTF-8作為底層的編碼。

字符類型代表的是一個(gè)Unicode標(biāo)量值（Unicode Scalar Value），包括數(shù)字、字母、Unicode和其他特殊字符。

每個(gè)字符占4個(gè)字節(jié)。

字符類型char由單引號(hào)來(lái)定義

let z = 'z' ;  // 使用單引號(hào)
let hz = '中';

范圍類型

范圍類型常用來(lái)生成從一個(gè)整數(shù)開(kāi)始到另一個(gè)整數(shù)結(jié)束的整數(shù)序列，有左閉右開(kāi)和全閉兩種形式

• （1…5）是左閉右開(kāi)區(qū)間，表示生成1、2、3、4這4個(gè)數(shù)字
• （1…=5）是全閉區(qū)間，表示生成1、2、3、4、5這5個(gè)數(shù)字

范圍類型自帶一些方法

• rev方法可以將范圍內(nèi)的數(shù)字順序反轉(zhuǎn)
• sum方法可以對(duì)范圍內(nèi)的數(shù)字進(jìn)行求和

fn main(){
    print!("(1..5):")
    for i in 1..5 {
        print!("{} ",i);
    }
    println!();
    
    print!("(1..=5).rev:");
       for i in (1..=5).rev() {
        print!("{} ",i);
    }
    println!();
    
    let sum :i32 = (1..=5).sum();
    println!("sum(1..=5)={}",sum);
}

//(1..5):1 2 3 4 
//(1..=5).rev:5 4 3 2 1 
//sum(1..=5)=15

復(fù)合數(shù)據(jù)類型

復(fù)合數(shù)據(jù)類型是由其他類型組合而成的類型

Rust的復(fù)合數(shù)據(jù)類型有元組、數(shù)組、結(jié)構(gòu)體、枚舉等。

元組類型

元組類型是由一個(gè)或多個(gè)類型的元素組合成的復(fù)合類型，使用小括號(hào)“()”把所有元素放在一起。元素之間使用逗號(hào)“，”分隔

元組中的每個(gè)元素都有各自的類型，且這些元素的類型可以不同。

元組的長(zhǎng)度固定，一旦定義就不能再增長(zhǎng)或縮短。

如果顯式指定了元組的數(shù)據(jù)類型，那么元素的個(gè)數(shù)必須和數(shù)據(jù)類型的個(gè)數(shù)相同。

可以使用元組名.索引的方式來(lái)訪問(wèn)元組中相應(yīng)索引位置的元素。

當(dāng)元組中只包含一個(gè)元素時(shí)，應(yīng)該在元素后面添加逗號(hào)來(lái)區(qū)分是元素，而不是括號(hào)表達(dá)式

let tup1 :(i8,f32,bool) = (-10,7.7,false);
let tup2 = (7.7,(false,10));
let tup3 = (100,);
println!("{},{}",tup1.0,tup2.1)
// 解構(gòu)賦值
let (x,y,z) = tup1;

數(shù)組類型

由相同類型的元素組合成的復(fù)合類型

使用[T;n] 表示，T代表元素類型，n代表長(zhǎng)度即元素個(gè)數(shù)

// 指定數(shù)組類型，為每一個(gè)元素賦值
let arr:[i32;5] = [1,2,3,4,5];
// 省略數(shù)組類型 --> 編譯器可以從初始值推斷出數(shù)組類型
let arr = [1,2,3,4];
// 省略數(shù)組類型，為所有元素使用默認(rèn)值初始化
let arr = [1;5]; // -> 等價(jià)let arr = [1,1,1,1,1]

可以使用"數(shù)組名[索引]"來(lái)訪問(wèn)數(shù)組中相應(yīng)索引位置的元素，元素的索引從0開(kāi)始計(jì)數(shù)。

動(dòng)態(tài)數(shù)組Vec, Vec是允許增長(zhǎng)和縮短長(zhǎng)度的容器類型，其提供的get方法在訪問(wèn)元素時(shí)可以有效避免索引越界

結(jié)構(gòu)體類型

結(jié)構(gòu)體類型是一個(gè)自定義數(shù)據(jù)類型，通過(guò)struct關(guān)鍵字加自定義命名，可以把多個(gè)類型組合在一起成為新的類型。

結(jié)構(gòu)體中以"name: type"格式定義字段，name是字段名稱，type是字段類型。

字段默認(rèn)不可變，并要求明確指定數(shù)據(jù)類型，不能使用自動(dòng)類型推導(dǎo)功能。

// 指定數(shù)組類型，為每一個(gè)元素賦值
let arr:[i32;5] = [1,2,3,4,5];
// 省略數(shù)組類型 --> 編譯器可以從初始值推斷出數(shù)組類型
let arr = [1,2,3,4];
// 省略數(shù)組類型，為所有元素使用默認(rèn)值初始化
let arr = [1;5]; // -> 等價(jià)let arr = [1,1,1,1,1]

使用"實(shí)例名.字段名"形式更改和訪問(wèn)結(jié)構(gòu)體實(shí)例某個(gè)字段的值。

結(jié)構(gòu)體實(shí)例默認(rèn)是不可變的，且不允許只將某個(gè)字段標(biāo)記為可變，如果要修改結(jié)構(gòu)體實(shí)例必須在實(shí)例創(chuàng)建時(shí)就聲明其為可變的。

struct Student {
    name : &'static str,
    score: i32,
}

fn main(){
    let score = 59;
    let username = "wkk";
    
    let mut student = Student{
        score, // 變量和字段同名，可以簡(jiǎn)寫
        name : username,
    };
    
    student.score = 60;
    //結(jié)構(gòu)體更新語(yǔ)法，對(duì)除字段name外未顯式設(shè)置值的字段以student實(shí)例對(duì)應(yīng)字段的值來(lái)賦值。
    let student2 = Student {
        name : "yyr",
        ..student
    };
}

特殊結(jié)構(gòu)體：

• 元組結(jié)構(gòu)體

字段只有類型，沒(méi)有名稱

struct Color(i32,i32,i32);

• 單元結(jié)構(gòu)體

沒(méi)有任何字段的結(jié)構(gòu)體

struct Solution;

枚舉類型

使用enum關(guān)鍵字加自定義命名來(lái)定義

含若干枚舉值，可以使用“枚舉名::枚舉值”訪問(wèn)枚舉值。

變量的值限于枚舉值范圍內(nèi)

根據(jù)枚舉值是否帶有類型參數(shù)，枚舉類型還可以分成無(wú)參數(shù)枚舉類型和帶參數(shù)枚舉類型。

無(wú)參枚舉類型

// #[derive(Debug)] 讓ColorNoParam自動(dòng)實(shí)現(xiàn)Debug trait
// 只有實(shí)現(xiàn)了Debug trait的類型才擁有使用{:?}格式化打印的行為
#[derive(Debug)]
enum ColorNoParam {
	Red,
    Yellow,
    Blue,
}

fn main(){
    let color_no_param = COlorNoParam::Red;
    match color_no_param{
		ColorNoParam :: Red => println!("{:?}",ColorNoParam::Red),
        ColorNoParam :: Yellow => println!("{:?}",ColorNoParam::Yellow),
        ColorNoParam :: Blue => println!("{:?}",ColorNoParam::Blue),
    }
}

帶參枚舉類型

#[derive(Debug)]
enum ColorParam{
    Red(String), //帶有String類型參數(shù)
    Yellow(String),
    Blue(String),
}

fn main(){
    //使用這種枚舉值需要傳入實(shí)參
    println!("{:?}",ColorParam::Blue(String::from("blue")));
}

容器類型

Rust標(biāo)準(zhǔn)庫(kù)std::collections提供了4種通用的容器類型，包含8種數(shù)據(jù)結(jié)構(gòu)

Vec

動(dòng)態(tài)可變長(zhǎng)數(shù)組, 在運(yùn)行時(shí)可以增長(zhǎng)或者縮短數(shù)組的長(zhǎng)度

動(dòng)態(tài)數(shù)組在內(nèi)存中開(kāi)辟了一段連續(xù)內(nèi)存塊用于存儲(chǔ)元素，且只能存儲(chǔ)相同類型的元素。

新加入的元素每次都會(huì)被添加到動(dòng)態(tài)數(shù)組的尾部

• 創(chuàng)建

// 創(chuàng)建空的動(dòng)態(tài)數(shù)組
let mut v: Vec<i32> = Vec::new();
// 創(chuàng)建指定容量的動(dòng)態(tài)數(shù)組
let mut v: Vec<i32> = Vec::with_capacity(10);
// 使用vec!宏在創(chuàng)建動(dòng)態(tài)數(shù)組的同時(shí)進(jìn)行初始化，并且根據(jù)初始值自動(dòng)推斷動(dòng)態(tài)數(shù)組的元素類型
let mut v: Vec<i32> = vec![]; // 沒(méi)有初始值，需要聲明元素類型
let mut v = vec![1,2,3]; // 自動(dòng)推斷元素個(gè)數(shù)
let mut v = vec![0;10]; // 10個(gè)元素，元素的初始值都是0

應(yīng)該盡可能根據(jù)初始元素個(gè)數(shù)以及增長(zhǎng)情況來(lái)指定合理的容量。

• 修改

// 使用push方法在動(dòng)態(tài)數(shù)組尾部添加新元素
v.push(1);
// 使用數(shù)組名[索引] 獲取元素
v[1] = 5;
// 使用pop方法刪除并返回動(dòng)態(tài)數(shù)組的最后一個(gè)元素，如果數(shù)組為空返回None
v.pop();
// remove方法刪除并返回動(dòng)態(tài)數(shù)組指定索引的元素，同時(shí)后面的所有元素向前移動(dòng)一位
// 索引越界將導(dǎo)致程序錯(cuò)誤
v.remove(1);

訪問(wèn)

//使用索引訪問(wèn)
v[2];
// 使用get方法以索引作為參數(shù)訪問(wèn)
v.get(1);
// 遍歷
for i in v {
    print!("{}",i);
}
// 可變引用
for i in &mut v {
    *i += 50;
    print!("{}",i);
}

VecDeque

雙端隊(duì)列是一種同時(shí)具有棧（先進(jìn)后出）和隊(duì)列（先進(jìn)先出）特征的數(shù)據(jù)結(jié)構(gòu)，適用于只能在隊(duì)列兩端進(jìn)行添加或刪除元素操作的應(yīng)用場(chǎng)景

定義在標(biāo)準(zhǔn)庫(kù)的std::colllections::VecDeque中，使用前需要顯式導(dǎo)入std::collections::VecDeque;

• 創(chuàng)建

// 創(chuàng)建空的VecDeque
let mut v : VecDeque<u32> = VecDeque::new();
// 創(chuàng)建指定容量的VecDeque
let mut v : VecDeque<u32> = VecDeque :: with_capacity(10);

• 修改

// push_front 在隊(duì)列頭部添加新的元素
v.push_front(1);
// push_back 在尾部添加新元素
v.push_back(2);

// 使用索引修改元素
v[1] = 5;

• 刪除

// pop_front 刪除并返回隊(duì)列的頭部元素
v.pop_back();
// pop_back 刪除并返回尾部元素
v.pop_front();

// remove 刪除并返回隊(duì)列指定索引的元素，同時(shí)后面的所有元素向左移動(dòng)一位
// 索引越界返回None
v.remove(1);

• 訪問(wèn)

// 使用索引訪問(wèn)
v[0];
// 使用get方法以索引作為參數(shù)訪問(wèn)元素
v.get(0);

HashMap

哈希表（HashMap）是基于哈希算法來(lái)存儲(chǔ)鍵-值對(duì)的集合，其中所有的鍵必須是同一類型，所有的值也必須是同一類型，不允許有重復(fù)的鍵

定義在標(biāo)準(zhǔn)庫(kù)std::collections 模塊中，使用前要顯式導(dǎo)入std::collection::HashMap

• 創(chuàng)建

// 創(chuàng)建空的HashMap
let mut map: HashMap<&str,i32> = HashMap::new();
// 創(chuàng)建指定容量
let mut map: HashMap<&str,i32> = HashMap::with_capacity(10);

修改

// insert 執(zhí)行插入或者更新
// 鍵不存在，執(zhí)行插入并返回None
// 鍵存在，執(zhí)行更新，并返回舊值
let zhangsan = map.insert("zhangsan",16);

// 使用entry 和 or_insert 方法檢查是否有對(duì)應(yīng)值，沒(méi)有對(duì)應(yīng)值就插入，有對(duì)應(yīng)值不執(zhí)行操作
// entry方法以鍵為參數(shù)，返回值是一個(gè)枚舉類型Entry
// Entry類型的or_insert 方法以值為參數(shù)，在鍵有對(duì)應(yīng)值時(shí)不執(zhí)行任何操作，沒(méi)有對(duì)應(yīng)值時(shí)，將鍵與值組成鍵值對(duì)插入
map.entry("zhangsan").or_insert(23);

// iter_mut 方法會(huì)返回由所有鍵值對(duì)的可變引用組成的迭代器
for( _, val ) in map.iter_mut() {
    *var += 2; // 所有的值都加2
}

// remove 刪除并返回指定鍵值對(duì)的值，不存在返回None
let result = map.remove("wkk");

• 訪問(wèn)

// 使用實(shí)例名[鍵] 訪問(wèn)指定鍵值對(duì)， 鍵不存在會(huì)導(dǎo)致程序錯(cuò)誤
map["wkk"]

// 使用get 方法，以鍵作為參數(shù)訪問(wèn)指定的鍵值對(duì)，存在返回值，不存在返回None
map.get("wkk");

字符串

字符串的本質(zhì)是一種特殊的容器類型，是由零個(gè)或多個(gè)字符組成的有限序列。

字符串常被作為一個(gè)整體來(lái)關(guān)注和使用

常用的字符串有兩種：

• 固定長(zhǎng)度的字符串字面量
• 可變長(zhǎng)度的字符串對(duì)象String

創(chuàng)建

1.&str的創(chuàng)建

內(nèi)置的字符串類型是str, 通常以引用的形式&str出現(xiàn)。

字符串字面量&str是字符的集合，代表的是不可變的UTF-8 編碼的字符串的引用，創(chuàng)建后無(wú)法再追加內(nèi)容或者更改內(nèi)容

// 使用雙引號(hào)創(chuàng)建字符串字面量
let s1 = "hello,wkk";

// 使用as_str方法將字符串對(duì)象轉(zhuǎn)換為字符串字面量
let str = String::from("hello,wkk");
let s2 = str.as_str();

2.String 的創(chuàng)建

字符串對(duì)象String 由Rust 標(biāo)準(zhǔn)庫(kù)提供。

創(chuàng)建后可以為其追加內(nèi)容或者更改內(nèi)容。

本質(zhì)是一個(gè)字段為Vec<u8> 類型的結(jié)構(gòu)體，把字符內(nèi)容放在堆上，由指向堆上字節(jié)序列的指針(as_ptr方法)、記錄堆上字節(jié)序列的長(zhǎng)度(len方法)和堆分配容量(capacity) 3部分組成。

// 創(chuàng)建空的字符串對(duì)象
let mut s = String::new();

// 根據(jù)指定的字符串字面量創(chuàng)建字符串對(duì)象
let s = String::from("wkk");

// 使用to_string 方法將字符串字面值轉(zhuǎn)換為字符串對(duì)象
let str = "wkk";
let s = str.to_string();

修改

1.使用push方法在字符串后面追加字符，使用push_str方法在字符串后追加字符串字面量

都是在原字符串上追加，不會(huì)返回新的字符串

let mut s = String::from("wkk");
s.push('R');
s.push_str("111");

要追加，字符串必須是可變的，使用mut關(guān)鍵字

2.使用insert方法在字符串中插入字符，使用insert_str方法在字符串中插入字符串字面量

第1個(gè)參數(shù)是插入位置的索引，第2個(gè)參數(shù)是插入字符或者字符串字面量

都是在原字符串上插入，并不是返回新的字符串

索引非法會(huì)導(dǎo)致程序錯(cuò)誤

s.insert(5,',');
s.insert_str(7,"Rust ");

3.使用 “+” 或者"+="運(yùn)算符將兩個(gè)字符串連接成一個(gè)新的字符串，要求運(yùn)算符的右邊必須是字符串字面量

不能對(duì)兩個(gè)String 類型的字符串使用

連接與追加的區(qū)別在于，連接會(huì)返回新的字符串，而不是在原字符串上的追加

let s = "hello " + "wkk";

4.對(duì)于較為復(fù)雜的帶有格式的字符串連接，可以使用格式化宏format!

對(duì)于String 類型 和 &str類型的字符串都適用

let s = format!("{}-{}-{}",s1,s2,s3);

5.replace 和 replacen() 方法將字符串中指定的子串替換為另一個(gè)字符串。

replace 接收兩個(gè)參數(shù)，第1個(gè)參數(shù)為要被替換的子串，第2個(gè)參數(shù)為新的字符串，會(huì)替換所有匹配的子串。

replacen 方法除了上述兩個(gè)參數(shù)外，還接受第3個(gè)參數(shù)來(lái)指定替換的個(gè)數(shù)

let s1 = s.replace("aa","77");
let s2 = s.replace("aa","77",1);

6.適用pop , remove , truncate 和 clear 方法刪除字符串中的字符

• pop

刪除并返回字符串的最后一個(gè)字符，返回類型為Option<char>, 如果字符串為空，返回None

• remove

刪除并返回字符串中指定位置的字符，參數(shù)是該字符的起始索引位置。

remove方法是按字節(jié)處理字符串的，如果給定的索引位置不是合法的字符邊界，將會(huì)導(dǎo)致程序錯(cuò)誤。

• truncate

刪除字符串中從指定位置開(kāi)始到結(jié)尾的全部字符，參數(shù)是起始索引位置。

truncate 也是按照字節(jié)處理字符串，如果給定的索引位置不是合法的字符邊界，會(huì)導(dǎo)致程序錯(cuò)誤。

• clear

刪除字符串中所有字符

s.pop();
s.remove(9);
s.truncate(9);
s.clear();

字符串的訪問(wèn)

• 字符串是UTF-8 編碼的字節(jié)序列，不能直接使用索引來(lái)訪問(wèn)字符
• 字符串操作可以分為按字節(jié)處理和按字符處理兩種方式，按字節(jié)處理使用bytes方法返回字節(jié)迭代的迭代器，按字符處理使用chars方法返回按字符迭代的迭代器。

len 方法獲取以字節(jié)為單位的字符串長(zhǎng)度

UTF-8 中字母1字節(jié)，特殊字符2字節(jié)，漢字3字節(jié)，不同字符的長(zhǎng)度是不一樣的。

s.len();

// 按字節(jié)遍歷
let bytes = s.bytes();
for b in bytes {
    print!("{} |",b);
}
// 按字符遍歷
let chars = s.chars();
for c in chars{
    print!("{} |",c);
}

字面量和運(yùn)算符

字面量

由文字，數(shù)字或者符號(hào)構(gòu)成的值

可以在字面量后面追加類型后綴進(jìn)行類型說(shuō)明：

• 1u8 : 8位無(wú)符號(hào)整數(shù)
• 1.2f32 32位浮點(diǎn)數(shù)

單元類型，單元類型的值叫做單元值，以()表示，一個(gè)函數(shù)無(wú)返回值，實(shí)際上是以單元值作為函數(shù)的返回值了。

運(yùn)算符

支持算術(shù)運(yùn)算符、關(guān)系運(yùn)算符、邏輯運(yùn)算符、位運(yùn)算符

算術(shù)運(yùn)算符

+ - * / % 

不支持 ++ 和 –

關(guān)系運(yùn)算符

比較兩個(gè)值之間的關(guān)系，并返回一個(gè)布爾類型的值

> < >= <= == != 

邏輯運(yùn)算符

組合兩個(gè)或者多個(gè)條件表達(dá)式，返回一個(gè)布爾類型的邏輯運(yùn)算結(jié)果

&& || !

位運(yùn)算符

對(duì)二進(jìn)制格式的數(shù)據(jù)進(jìn)行操作

& | ^ ! << >>

<< 和 >> 空白位都是補(bǔ)0

到此這篇關(guān)于Rust變量與數(shù)據(jù)類型的文章就介紹到這了,更多相關(guān)Rust變量與數(shù)據(jù)類型內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！