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

常用的三大數(shù)據(jù)結構：

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

Rust標準庫std::collections提供了4種通用的容器類型，其中包含8種數(shù)據(jù)結構。

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

映射包括HashMap

字符串包括String等類型

變量和可變性

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

變量默認是不可改變的

變量聲明

使用let關鍵字聲明變量，先聲明后使用

let x :i8 =1
let x = 1 ; // 等價于 let x: i32 = 1;

變量聲明以let關鍵字開頭，x為變量名，變量名后緊跟冒號和數(shù)據(jù)類型

Rust編譯器具有變量類型的自動推導功能

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

變量命名

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

Rust中下劃線是一種特殊的標識符，其含義是“忽略這個變量”

變量的可變性

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

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

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

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

變量遮蔽

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

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

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

常量

常量是指綁定到一個標識符且不允許改變的值，一旦定義后就沒有任何方法能改變其值了

const MAX_NUM : u32 = 1024;

使用const關鍵字來聲明常量

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

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

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

在編譯階段就要確定其值

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

強類型的靜態(tài)編譯語言

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

整數(shù)類型

整數(shù)可以分為有符號整型和無符號整型

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

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

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

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

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

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

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

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

浮點數(shù)類型

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

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

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

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

布爾類型

使用bool來聲明布爾類型的變量

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

字符類型

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

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

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

字符類型char由單引號來定義

let z = 'z' ;  // 使用單引號
let hz = '中';

范圍類型

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

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

范圍類型自帶一些方法

• rev方法可以將范圍內的數(shù)字順序反轉
• sum方法可以對范圍內的數(shù)字進行求和

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

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

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

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

元組類型

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

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

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

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

可以使用元組名.索引的方式來訪問元組中相應索引位置的元素。

當元組中只包含一個元素時，應該在元素后面添加逗號來區(qū)分是元素，而不是括號表達式

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

數(shù)組類型

由相同類型的元素組合成的復合類型

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

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

可以使用"數(shù)組名[索引]"來訪問數(shù)組中相應索引位置的元素，元素的索引從0開始計數(shù)。

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

結構體類型

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

結構體中以"name: type"格式定義字段，name是字段名稱，type是字段類型。

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

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

使用"實例名.字段名"形式更改和訪問結構體實例某個字段的值。

結構體實例默認是不可變的，且不允許只將某個字段標記為可變，如果要修改結構體實例必須在實例創(chuàng)建時就聲明其為可變的。

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

fn main(){
    let score = 59;
    let username = "wkk";
    
    let mut student = Student{
        score, // 變量和字段同名，可以簡寫
        name : username,
    };
    
    student.score = 60;
    //結構體更新語法，對除字段name外未顯式設置值的字段以student實例對應字段的值來賦值。
    let student2 = Student {
        name : "yyr",
        ..student
    };
}

特殊結構體：

• 元組結構體

字段只有類型，沒有名稱

struct Color(i32,i32,i32);

• 單元結構體

沒有任何字段的結構體

struct Solution;

枚舉類型

使用enum關鍵字加自定義命名來定義

含若干枚舉值，可以使用“枚舉名::枚舉值”訪問枚舉值。

變量的值限于枚舉值范圍內

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

無參枚舉類型

// #[derive(Debug)] 讓ColorNoParam自動實現(xiàn)Debug trait
// 只有實現(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(){
    //使用這種枚舉值需要傳入實參
    println!("{:?}",ColorParam::Blue(String::from("blue")));
}

容器類型

Rust標準庫std::collections提供了4種通用的容器類型，包含8種數(shù)據(jù)結構

Vec

動態(tài)可變長數(shù)組, 在運行時可以增長或者縮短數(shù)組的長度

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

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

• 創(chuàng)建

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

應該盡可能根據(jù)初始元素個數(shù)以及增長情況來指定合理的容量。

• 修改

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

訪問

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

VecDeque

雙端隊列是一種同時具有棧（先進后出）和隊列（先進先出）特征的數(shù)據(jù)結構，適用于只能在隊列兩端進行添加或刪除元素操作的應用場景

定義在標準庫的std::colllections::VecDeque中，使用前需要顯式導入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 在隊列頭部添加新的元素
v.push_front(1);
// push_back 在尾部添加新元素
v.push_back(2);

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

• 刪除

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

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

• 訪問

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

HashMap

哈希表（HashMap）是基于哈希算法來存儲鍵-值對的集合，其中所有的鍵必須是同一類型，所有的值也必須是同一類型，不允許有重復的鍵

定義在標準庫std::collections 模塊中，使用前要顯式導入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 方法檢查是否有對應值，沒有對應值就插入，有對應值不執(zhí)行操作
// entry方法以鍵為參數(shù)，返回值是一個枚舉類型Entry
// Entry類型的or_insert 方法以值為參數(shù)，在鍵有對應值時不執(zhí)行任何操作，沒有對應值時，將鍵與值組成鍵值對插入
map.entry("zhangsan").or_insert(23);

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

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

• 訪問

// 使用實例名[鍵] 訪問指定鍵值對， 鍵不存在會導致程序錯誤
map["wkk"]

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

字符串

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

字符串常被作為一個整體來關注和使用

常用的字符串有兩種：

• 固定長度的字符串字面量
• 可變長度的字符串對象String

創(chuàng)建

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

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

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

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

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

2.String 的創(chuàng)建

字符串對象String 由Rust 標準庫提供。

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

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

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

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

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

修改

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

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

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

要追加，字符串必須是可變的，使用mut關鍵字

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

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

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

索引非法會導致程序錯誤

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

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

不能對兩個String 類型的字符串使用

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

let s = "hello " + "wkk";

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

對于String 類型 和 &str類型的字符串都適用

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

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

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

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

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

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

• pop

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

• remove

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

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

• truncate

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

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

• clear

刪除字符串中所有字符

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

字符串的訪問

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

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

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

s.len();

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

字面量和運算符

字面量

由文字，數(shù)字或者符號構成的值

可以在字面量后面追加類型后綴進行類型說明：

• 1u8 : 8位無符號整數(shù)
• 1.2f32 32位浮點數(shù)

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

運算符

支持算術運算符、關系運算符、邏輯運算符、位運算符

算術運算符

+ - * / % 

不支持 ++ 和 –

關系運算符

比較兩個值之間的關系，并返回一個布爾類型的值

> < >= <= == != 

邏輯運算符

組合兩個或者多個條件表達式，返回一個布爾類型的邏輯運算結果

&& || !

位運算符

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

& | ^ ! << >>

<< 和 >> 空白位都是補0

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

最新評論