Rust基本数据类型-字符串

一、字符串是什么，怎么用

1、字符串是什么

先说明一下，在Rust中，字符是UniCode编码占4个字节，字符串类型的字符是UTF-8编码的，字节大小为1～3。

字符串类型在Rust中，可以分为&Str和String类型

&Str类型是不可修改的字符串

String 则是一个可增长、可改变且具有所有权的 UTF-8 编码字符串

2、字符串怎么用

（1）字符串不能取下标

fn main() {
  let s1 = String::from("hello");
  let h = s1[2]; 
}
1
2
3
4
5

这样会报错，因为字符串编码是可变长编码，通过简单的下标，很难界定你输入的下标是否正确切割了字符

 --> src/main.rs:4:14
  |
4 |   let h = s1[2];
  |              ^ `String` cannot be indexed by `{integer}`
  |
  = help: the trait `Index<{integer}>` is not implemented for `String`
  = help: the following other types implement trait `Index<Idx>`:
            <String as Index<RangeFull>>
            <String as Index<std::ops::Range<usize>>>
            <String as Index<RangeFrom<usize>>>
            <String as Index<RangeTo<usize>>>
            <String as Index<RangeInclusive<usize>>>
1
2
3
4
5
6
7
8
9
10
11
12

（2）字符串切片

如果我们就是想获得字符串的一部分，我们可以通过字符串切片来获取，但是我们的下标要注意，要整好取得字符字节大小的整数。

fn main() {
  let hello = "中国人";

  let s = &hello[0..3];
  println!("{}",s);
}
1
2
3
4
5
6

   Compiling world_hello v0.1.0 (/Users/guilinhuang/Desktop/RustProject/world_hello)
    Finished release [optimized] target(s) in 0.21s
     Running `target/release/world_hello`
中
1
2
3
4

（3）字符串追加内容

在字符串尾部可以使用 push() 方法追加字符 char，也可以使用 push_str() 方法追加字符串字面量。这两个方法都是在原有的字符串上追加，并不会返回新的字符串。由于字符串追加操作要修改原来的字符串，则该字符串必须是可变的，即字符串变量必须由 mut 关键字修饰

fn main() {
    let mut s = String::from("Hello ");//mut关键字修饰，使得s拥有的值可以被修改

    s.push_str("rust");
    println!("追加字符串 push_str() -> {}", s);

    s.push('!');
    println!("追加字符 push() -> {}", s);
}
1
2
3
4
5
6
7
8
9

追加字符串 push_str() -> Hello rust
追加字符 push() -> Hello rust!
1
2

（4）字符串插入

1. 由于字符串插入操作要修改原来的字符串，则该字符串必须是可变的，即字符串变量必须由 mut 关键字修饰
2. 插入位置要求是字符的整数字节位置

fn main() {
    let mut s = String::from("Hello rust!");
    s.insert(5, ',');
    println!("插入字符 insert() -> {}", s);
    s.insert_str(6, " I like");
    println!("插入字符串 insert_str() -> {}", s);
}
1
2
3
4
5
6
7

插入字符 insert() -> Hello, rust!
插入字符串 insert_str() -> Hello, I like rust!
1
2

（5）字符串删除

1. pop —— 删除并返回字符串的最后一个字符
   该方法是直接操作原来的字符串。但是存在返回值，其返回值是一个 Option 类型，如果字符串为空，则返回 None。 示例代码如下

fn main() {
    let mut string_pop = String::from("rust pop 中文!");
    let p1 = string_pop.pop();
    let p2 = string_pop.pop();
    dbg!(p1);
    dbg!(p2);
    dbg!(string_pop);
}
1
2
3
4
5
6
7
8

p1 = Some(
   '!',
)
p2 = Some(
   '文',
)
string_pop = "rust pop 中"
1
2
3
4
5
6
7

2. remove —— 删除并返回字符串中指定位置的字符
   该方法是直接操作原来的字符串。但是存在返回值，其返回值是删除位置的字符串，只接收一个参数，表示该字符起始索引位置。remove() 方法是按照字节来处理字符串的，如果参数所给的位置不是合法的字符边界，则会发生错误。

fn main() {
  let mut string_remove = String::from("测试remove方法");
  println!(
      "string_remove 占 {} 个字节",
      std::mem::size_of_val(string_remove.as_str())
  );
  // 删除第二个汉字
  string_remove.remove(3);
  // 下面代码会发生错误
  // string_remove.remove(1);
  dbg!(string_remove);
}
1
2
3
4
5
6
7
8
9
10
11
12

string_remove 占 18 个字节
[src/main.rs:13:3] string_remove = "测remove方法"
1
2

3. truncate —— 删除字符串中从指定位置开始到结尾的全部字符
   该方法是直接操作原来的字符串。无返回值。该方法 truncate() 方法是按照字节来处理字符串的，如果参数所给的位置不是合法的字符边界，则会发生错误。

fn main() {
    let mut string_truncate = String::from("测试truncate");
    string_truncate.truncate(3);
    dbg!(string_truncate);
}
1
2
3
4
5

string_truncate = "测"
1

（6）字符串替换

1. replace
   该方法可适用于 String 和 &str 类型。replace() 方法接收两个参数，第一个参数是要被替换的字符串，第二个参数是新的字符串。该方法会替换所有匹配到的字符串。该方法是返回一个新的字符串，而不是操作原来的字符串

fn main() {
    let string_replace = String::from("I like rust. Learning rust is my favorite!");
    let new_string_replace = string_replace.replace("rust", "RUST");
    dbg!(new_string_replace);
}
1
2
3
4
5

new_string_replace = "I like RUST. Learning RUST is my favorite!"
1

2. replace_range
   该方法仅适用于 String 类型。replace_range 接收两个参数，第一个参数是要替换字符串的范围（Range），第二个参数是新的字符串。该方法是直接操作原来的字符串，不会返回新的字符串。该方法需要使用 mut 关键字修饰。
   要注意下标是字节的整数倍

fn main() {
  let mut string_replace_range = String::from("我 like rust!");
  string_replace_range.replace_range(0..3, "R");
  dbg!(string_replace_range);
}
1
2
3
4
5

[src/main.rs:4:3] string_replace_range = "R like rust!"
1

（6）字符串清除

1. clear —— 清空字符串
   该方法是直接操作原来的字符串。调用后，删除字符串中的所有字符，相当于 truncate() 方法参数为 0 的时候。

fn main() {
    let mut string_clear = String::from("string clear");
    string_clear.clear();
    dbg!(string_clear);
}
1
2
3
4
5

string_clear = ""
1

（6）字符串拼接

1. 使用 + 或者 += 连接字符串
   使用 + 或者 += 连接字符串，要求右边的参数必须为字符串的切片引用（Slice）类型。其实当调用 + 的操作符时，相当于调用了 std::string 标准库中的 add() 方法，这里 add() 方法的第二个参数是一个引用的类型。因此我们在使用 + 时， 必须传递切片引用类型。

• +是返回一个新的字符串，所以变量声明可以不需要 mut 关键字修饰
• 左边的参数会交出所有权，后续不能再使用这个变量

fn main() {
  let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

// String = String + &str + &str + &str + &str
let s = s1 + "-" + &s2 + "-" + &s3;
print!("{}",s1);
}
1
2
3
4
5
6
7
8
9

  --> /Users/guilinhuang/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust/library/core/src/ops/arith.rs:91:12
   |
91 |     fn add(self, rhs: Rhs) -> Self::Output;
   |            ^^^^
   = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the macro `print` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
   |
7  | let s = s1.clone() + "-" + &s2 + "-" + &s3;
   |           ++++++++

1
2
3
4
5
6
7
8
9
10