复合类型

字符串和切片

切片

切片的作用是允许你引用集合中部分连续的元素序列，而不是引用整个集合。

例如：

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

let hello = &s[0..5];  // 切片 [0,5)  等效于&s[..5]
let world = &s[6..11];  // 切片 [6,11) 等效于&s[6..]
// 完整的s，&s[..]

注意，方括号中的数字是字节，如果字符是多字节的（如汉字），这时如果切片没有落在两个字符之间，程序就会崩溃（汉字是三个字节，切片0-2就会崩溃）

字符串的切片类型是 &str，i32数组的切片类型是 &[i32]

这样一段代码：let s = "Hello world!";， s 是个切片类型，实际上代码为：let s: &str = "Hello world!"

字符串

Rust中字符是 Unicode 类型。内存占用从1 - 4 个字节空间。

Rust中常用的字符串类型有 str / String，str硬编码不可变，String可变。

// &str --> String
String::from("Hello world");
"hello world".to_string();

// String --> &str
&s;

操作字符串

let mut s = String::from("Hello ");
// 追加字符串
s.push_str("rust");
// 追加字符
s.push('!');
// 插入字符
s.insert(5, ',');
// 插入字符串
s.insert_str(6, " I like");

// 替换
// replace 适用于 String 和 &str，替换所有，返回一个新字符串，而不是操作原来的字符串
let new_string_replace = string_replace.replace("rust", "RUST");
// replacen 适用于 String 和 &str, 替换指定个数，返回一个新字符串，而不是操作原来的字符串
let new_string_replacen = string_replace.replacen("rust", "RUST", 1);
// replace_range 适用于 String，替换指定范围字符串，操作原来的字符串
string_replace_range.replace_range(7..8, "R");

// 删除
// 均是操作原来的字符串
// pop 删除并返回最后一个字符
let p1 = string_pop.pop();
// remove 删除并返回指定位置字符
string_remove.remove(0);
// truncate 删除指定位置到结尾
string_truncate.truncate(3);
// clear 清空字符串
string_clear.clear();

// 连接
// + += ，右面必须是字符串的切片引用类型，相当于调用std::string add()，返回一个新字符串
let result = string_append + &string_rust;
// format! 
let s = format!("{} {}!", s1, s2);

遍历字符串

// 以 unicode 字符方式遍历字符串
for c in "中国人".chars() {
    println!("{}", c);
}

元组

元组是由多种类型组合到一起形成的，因此它是复合类型，元组的长度是固定的，元组中元素的顺序也是固定的。

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

使用元组：

fn main() {
    let tup = (500, 6.4, 1);
    
	// 模式匹配
    let (x, y, z) = tup;
    println!("The value of y is: {}", y);
    
    // .
    let five_hundred = x.0;
    let six_point_four = x.1;
    
    // 函数
    let s1 = String::from("hello");
    let (s2, len) = calculate_length(s1);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() 返回字符串的长度
    (s, length)
}

结构体

使用

结构体的定义：

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

结构体的创建和使用：

// 每个都需要初始化，顺序可以打乱
let mut user1 = User {
    email: String::from("someone@example.com"),
    username: String::from("someusername123"),
    active: true,
    sign_in_count: 1,
};

// 访问字段，
// **必须要将结构体实例声明为可变的，才能修改其中的字段，Rust 不支持将某个结构体某个字段标记为可变。**
user1.email = String::from("anotheremail@example.com");

// 简化创建
fn build_user(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

// 更新
let user2 = User {
    email: String::from("another@example.com"),
    ..user1  // 注意 username 发生了所有权转移，不能再被user1使用
};

内存排列

struct File {
    name: String,
    data: Vec<u8>,
}

内存结构：

元组结构体

元组结构体的字段没有名称：

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);

使用的使用可以直接用 x,y,z / r,g,b

单元结构体

单元结构体没有任何字段和属性

struct AlwaysEqual;

let subject = AlwaysEqual;

// 我们不关心 AlwaysEqual 的字段数据，只关心它的行为，因此将它声明为单元结构体，然后再为它实现某个特征
impl SomeTrait for AlwaysEqual {

}

结构体的所有权

如果你想在结构体中使用一个引用，就必须加上生命周期，否则就会报错！

生命周期篇再写。

打印

使用 #[derive(Debug)] 来打印结构体信息。

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

dbg!(&struct);
也可以实现 Display 特征打印信息（类似 toString() 方法）

println!("{}",struct);

枚举

使用：

可以向其他语言一样直接使用，也可以为其关联数据信息

// enum PokerSuit {
//   Clubs,
//   Spades,
//   Diamonds,
//   Hearts,
// }

enum PokerCard {
    Clubs(u8),
    Spades(u8),
    Diamonds(u8),
    Hearts(u8),
}

fn main() {
   let c1 = PokerCard::Spades(5);
   let c2 = PokerCard::Diamonds(13);
}

更为复杂的：

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {
    let m1 = Message::Quit;
    let m2 = Message::Move{x:1,y:1};
    let m3 = Message::ChangeColor(255,255,0);
}

使用Option枚举处理空值

在rust中使用Option枚举来处理对象为空的情况（null）：

enum Option<T> {
    Some(T),
    None,
}

使用的使用将值存入 Some<T> 中，这样在使用变量的时候因为不能直接使用 Option，所以需要将值取出来再用。而取出来的时候需要判断值不是Option::None才能用，相当于变相强制进行了判空操作，放置了空指针异常。

数组

在Rust中有两种数组，一种是长度固定吗，速度快的 array，一种是长度动态，性能较低的 vector。

array存储在栈上，vector存储在堆上。

array

使用：

fn main() {
    // 1.定义
    // let a: [i32; 5] = [1, 2, 3, 4, 5];  声明类型
    let a = [1, 2, 3, 4, 5];
    // 重复：5个3
    let a = [3; 5]; 
    // 非基础元素
    // let array = [String::from("rust is good!"); 8];  ×  不能深拷贝
    let array: [String; 8] = std::array::from_fn(|i| String::from("rust is good!"));
    
    // 2.访问
    let first = a[0]; // 获取a数组第一个元素
}

数组切片

创建切片的代价非常小，因为切片只是针对底层数组的一个引用
切片类型[T]拥有不固定的大小，而切片引用类型&[T]则具有固定的大小，因为 Rust 很多时候都需要固定大小数据类型，因此&[T]更有用,&str字符串切片也同理

let a: [i32; 5] = [1, 2, 3, 4, 5];

let slice: &[i32] = &a[1..3];  // 引用

assert_eq!(slice, &[2, 3]);

标签：String,i32,复合,切片,字符串,let,类型,string
From： https://www.cnblogs.com/heymeteor/p/17636470.html