备案控制台
开发者社区 开发与运维 文章 正文

Rust 标准库字符串类型String及其46种常用方法

2023-07-03 263
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： String是一个可变引用，而&str是对该字符串的不可变引用，即可以更改String的数据，但是不能操作&str的数据。String 类型来自标准库，它是可修改、可变长度、可拥有所有权的同样使用UTF-8编码，且它不以空(null)值终止，实际上就是对Vec的包装，在堆内存上分配一个字符串。由&[u8]表示，UTF-8编码的字符串的引用，字符串字面值，也称作字符串切片。

Rust字符串

Rust主要有两种类型的字符串：&str和String

&str

由&[u8]表示，UTF-8编码的字符串的引用，字符串字面值，也称作字符串切片。＆str用于查看字符串中的数据。它的大小是固定的，即它不能调整大小。

String

String 类型来自标准库，它是可修改、可变长度、可拥有所有权的同样使用UTF-8编码，且它不以空(null)值终止，实际上就是对Vec的包装，在堆内存上分配一个字符串。

其源代码大致如下：

pub struct String {
   
    vec: Vec<u8>,
}
impl String {
   
    pub fn new() -> String {
   
        String {
    vec: Vec::new() }
    }
    pub fn with_capacity(capacity: usize) -> String {
   
        String {
    vec: Vec::with_capacity(capacity) }
    }
    pub fn push(&mut self, ch: char) {
   
        // ...
    }
    pub fn push_str(&mut self, string: &str) {
   
        // ...
    }
    pub fn clear(&mut self) {
   
        self.vec.clear();
    }
    pub fn capacity(&self) -> usize {
   
        self.vec.capacity()
    }
    pub fn reserve(&mut self, additional: usize) {
   
        self.vec.reserve(additional);
    }
    pub fn reserve_exact(&mut self, additional: usize) {
   
        self.vec.reserve_exact(additional);
    }
    pub fn shrink_to_fit(&mut self) {
   
        self.vec.shrink_to_fit();
    }
    pub fn into_bytes(self) -> Vec<u8> {
   
        self.vec
    }
    pub fn as_str(&self) -> &str {
   
        // ...
    }
    pub fn len(&self) -> usize {
   
        // ...
    }
    pub fn is_empty(&self) -> bool {
   
        self.len() == 0
    }
    pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error> {
   
        // ...
    }
    pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> Cow<'a, str> {
   
        // ...
    }
}
impl Clone for String {
   
    fn clone(&self) -> String {
   
        String {
    vec: self.vec.clone() }
    }
    fn clone_from(&mut self, source: &Self) {
   
        self.vec.clone_from(&source.vec);
    }
}
impl fmt::Display for String {
   
    // ...
}
impl fmt::Debug for String {
   
    // ...
}
impl PartialEq for String {
   
    // ...
}
impl Eq for String {
   
    // ...
}
impl PartialOrd for String {
   
    // ...
}
impl Ord for String {
   
    // ...
}
impl Hash for String {
   
    // ...
}
impl AsRef<str> for String {
   
    // ...
}
impl AsRef<[u8]> for String {
   
    // ...
}
impl From<&str> for String {
   
    // ...
}
impl From<String> for Vec<u8> {
   
    // ...
}
// ...

String 和 &str 的区别

String是一个可变引用，而&str是对该字符串的不可变引用，即可以更改String的数据，但是不能操作&str的数据。String包含其数据的所有权，而&str没有所有权，它从另一个变量借用得来。

Rust 的标准库中还包含其他很多字符串类型，例如：OsString、OsStr、CString、CStr。

创建和输出

1、使用String::new创建空的字符串。

let empty_string = String::new();

2、使用String::from通过字符串字面量创建字符串。实际上复制了一个新的字符串。

let rust_str = "rust";
let rust_string = String::from(rust_str);

3、使用字符串字面量的to_string将字符串字面量转换为字符串。实际上复制了一个新的字符串。

let s1 = "rust_to_string";
let s2 = s1.to_string();

to_string()实际上是封装了String::from()

4、使用{}格式化输出

let s = "rust";
print!("{}",s);

索引和切片

1、String字符串是UTF-8编码，不提供索引操作。

2、Rust 使用切片来“索引”字符串，[ ] 里不是单个数字而是必须要提供范围。

范围操作符： .. 或 ..=

start..end 左开右闭区间 [start, end)

start..=end 全开区间 [start, end]

示例：

fn main() {
   
    let s = "hello, world";
    let a = &s[1..4];
    println!("{}", a);
    let a = &s[1..=4];
    println!("{}", a);
    //单个字符只能使用范围指定，不能仅用一个整数[1]
    let a = &s[1..2];
    println!("{}", a);
    let a = &s[1..=1];
    println!("{}", a);
    //等价于以下操作：
    println!("{:?}", s.chars().nth(1));
    println!("{}", s.chars().nth(1).unwrap());
}

输出：

ell
ello
e
e
Some('e')
e

拼接和迭代

1、拼接直接使用加号 +

fn main() {
   
    let s1 = String::from("hello");
    let s2 = String::from("world");

    let s = s1 + ", " + &s2 ;

    println!("{}", s);
}

输出：

hello, world

2、各种遍历(迭代)

.chars()方法：该方法返回一个迭代器，可以遍历字符串的Unicode字符。

let s = String::from("Hello, Rust!");
for c in s.chars() {
println!("{}", c);
}
.bytes()方法：该方法返回一个迭代器，可以遍历字符串的字节序列。

let s = String::from("Hello, Rust!");
for b in s.bytes() {
println!("{}", b);
}
.chars().enumerate()方法：该方法返回一个元组迭代器，可以同时遍历字符和它们在字符串中的索引。

let s = String::from("Hello, Rust!");
for (i, c) in s.chars().enumerate() {
println!("{}: {}", i, c);
}
.split()方法：该方法返回一个分割迭代器，可以根据指定的分隔符将字符串分割成多个子字符串，然后遍历每个子字符串。

let s = String::from("apple,banana,orange");
for word in s.split(",") {
println!("{}", word);
}
.split_whitespace()方法：该方法返回一个分割迭代器，可以根据空格将字符串分割成多个子字符串，然后遍历每个子字符串。

let s = String::from("The quick brown fox");
for word in s.split_whitespace() {
println!("{}", word);
}

3. 使用切片循环输出

fn main() {
   
    let s = String::from("The quick brown fox"); 
    let mut i = 0;
    while i < s.len() {
   
        print!("{}", &s[i..=i]);
        i += 1;
    }
    println!();
    while i > 0 {
   
        i -= 1;
        print!("{}", &s[i..=i]);

    }
    println!();
    loop {
   
        if i >= s.len() {
   
            break;
        }
        print!("{}", &s[i..i+1]);
        i += 1;
    }
    println!();
}

输出：

The quick brown fox
xof nworb kciuq ehT
The quick brown fox

String除了以上这几种最基本的操作外，标准库提供了删增改等等各种各样的方法以方便程序员用来操作字符串。以下归纳了String字符串比较常用的46种方法：

String 方法

1、 new
new()：创建一个空的 String 对象。

let s = String::new();

2、 from
from()：从一个字符串字面量、一个字节数组或另一个字符串对象中创建一个新的 String 对象。

let s1 = String::from("hello");
let s2 = String::from_utf8(vec![104, 101, 108, 108, 111]).unwrap();
let s3 = String::from(s1);

3、 with_capacity
with_capacity()：创建一个具有指定容量的 String 对象。

let mut s = String::with_capacity(10);
s.push('a');

4、 capacity
capacity()：返回字符串的容量（以字节为单位）。

let s = String::with_capacity(10);
assert_eq!(s.capacity(), 10);

5、 reserve
reserve()：为字符串预留更多的空间。

let mut s = String::with_capacity(10);
s.reserve(10);

6、 shrink_to_fit
shrink_to_fit()：将字符串的容量缩小到它所包含的内容所需的最小值。

let mut s = String::from("foo");
s.reserve(100);
assert!(s.capacity() >= 100);
s.shrink_to_fit();
assert_eq!(3, s.capacity());

7、 shrink_to
shrink_to()：将字符串的容量缩小到指定下限。如果当前容量小于下限，则这是一个空操作。

let mut s = String::from("foo");
s.reserve(100);
assert!(s.capacity() >= 100);
s.shrink_to(10);
assert!(s.capacity() >= 10);
s.shrink_to(0);
assert!(s.capacity() >= 3);

8、 push
push()：将一个字符追加到字符串的末尾。

let mut s = String::from("hello");
s.push('!');

9、 push_str
push_str()：将一个字符串追加到字符串的末尾。

let mut s = String::from("hello");
s.push_str(", world!");

10、 pop
pop()：将字符串的最后一个字符弹出，并返回它。

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

11、 truncate
truncate()：将字符串截短到指定长度，此方法对字符串的分配容量没有影响。

let mut s = String::from("hello");
s.truncate(2);
assert_eq!("he", s);
assert_eq!(2, s.len());
assert_eq!(5, s.capacity());

12、 clear
clear()：将字符串清空，此方法对字符串的分配容量没有影响。

let mut s = String::from("foo");
s.clear();
assert!(s.is_empty());
assert_eq!(0, s.len());
assert_eq!(3, s.capacity());

13、 remove
remove()：从字符串的指定位置移除一个字符，并返回它。

let mut s = String::from("hello");
let second = s.remove(1);

14、 remove_range
remove_range()：从字符串的指定范围删除所有字符。

let mut s = String::from("hello");
s.remove_range(1..3);

15、 insert
insert()：在字符串的指定位置插入一个字符。

let mut s = String::from("hello");
s.insert(2, 'l');

16、 insert_str
insert_str()：在字符串的指定位置插入一个字符串。

let mut s = String::from("hello");
s.insert_str(2, "ll");

17、 replace
replace()：将字符串中的所有匹配项替换为另一个字符串。

let mut s = String::from("hello, world");
let new_s = s.replace("world", "Rust");

18、 replace_range
replace_range()：替换字符串的指定范围内的所有字符为另一个字符串。

let mut s = String::from("hello");
s.replace_range(1..3, "a");

19、 split
split()：将字符串分割为一个迭代器，每个元素都是一个子字符串。

let s = String::from("hello, world");
let mut iter = s.split(", ");
assert_eq!(iter.next(), Some("hello"));
assert_eq!(iter.next(), Some("world"));
assert_eq!(iter.next(), None);

20、 split_whitespace
split_whitespace()：将字符串分割为一个迭代器，每个元素都是一个不包含空格的子字符串。

let s = String::from("   hello   world   ");
let mut iter = s.split_whitespace();
assert_eq!(iter.next(), Some("hello"));
assert_eq!(iter.next(), Some("world"));
assert_eq!(iter.next(), None);

21、 split_at
split_at()：将字符串分成两个部分，在指定的位置进行分割。

let s = String::from("hello");
let (left, right) = s.split_at(2);

22、 split_off
split_off()：从字符串的指定位置分离出一个子字符串，并返回新的 String 对象。

let mut s = String::from("hello");
let new_s = s.split_off(2);

23、 len
len()：返回字符串的长度（以字节为单位）。

let s = String::from("hello");
assert_eq!(s.len(), 5);

24、 is_empty
is_empty()：检查字符串是否为空。

let s = String::from("");
assert!(s.is_empty());

25、 as_bytes
as_bytes()：将 String 对象转换为字节数组。

let s = String::from("hello");
let bytes = s.as_bytes();

26、 into_bytes
into_bytes()：将 String 对象转换为字节向量。

let s = String::from("hello");
let bytes = s.into_bytes();
assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);

27、 clone
clone()：创建一个与原始字符串相同的新字符串。

let s1 = String::from("hello");
let s2 = s1.clone();

28、 eq
eq()：比较两个字符串是否相等。

let s1 = String::from("hello");
let s2 = String::from("hello");
assert!(s1.eq(&s2));

29、 contains
contains()：检查字符串是否包含指定的子字符串。

let s = String::from("hello");
assert!(s.contains("ell"));

30、 starts_with
starts_with()：检查字符串是否以指定的前缀开头。

let s = String::from("hello");
assert!(s.starts_with("he"));

31、 ends_with
ends_with()：检查字符串是否以指定的后缀结尾。

let s = String::from("hello");
assert!(s.ends_with("lo"));

32、 find
find()：查找字符串中第一个匹配指定子字符串的位置。

let s = String::from("hello");
let pos = s.find("l");
assert_eq!(pos, Some(2));

33、 rfind
rfind()：查找字符串中最后一个匹配指定子字符串的位置。

let s = String::from("hello");
let pos = s.rfind("l");
assert_eq!(pos, Some(3));

34、 trim
trim()：删除字符串两端的所有空格。

let s = String::from("   hello   ");
let trimmed = s.trim();

35、 trim_start
trim_start()：删除字符串开头的所有空格。

let s = String::from("   hello   ");
let trimmed = s.trim_start();

36、 trim_end
trim_end()：删除字符串末尾的所有空格。

let s = String::from("   hello   ");
let trimmed = s.trim_end();

37、 to_lowercase
to_lowercase()：将字符串中的所有字符转换为小写。

let s = String::from("HeLLo");
let lower = s.to_lowercase();

38、 to_uppercase
to_uppercase()：将字符串中的所有字符转换为大写。

let s = String::from("HeLLo");
let upper = s.to_uppercase();

39、 retain
retain()：保留满足指定条件的所有字符。

let mut s = String::from("hello");
s.retain(|c| c != 'l');

40、 drain
drain()：从字符串中删除指定范围内的所有字符，并返回它们的迭代器。

let mut s = String::from("hello");
let mut iter = s.drain(1..3);
assert_eq!(iter.next(), Some('e'));
assert_eq!(iter.next(), Some('l'));
assert_eq!(iter.next(), None);

41、 lines
lines()：将字符串分割为一个迭代器，每个元素都是一行文本。

let s = String::from("hello\nworld");
let mut iter = s.lines();
assert_eq!(iter.next(), Some("hello"));
assert_eq!(iter.next(), Some("world"));
assert_eq!(iter.next(), None);

42、 chars
chars()：将字符串分割为一个迭代器，每个元素都是一个字符。

let s = String::from("hello");
let mut iter = s.chars();
assert_eq!(iter.next(), Some('h'));
assert_eq!(iter.next(), Some('e'));
assert_eq!(iter.next(), Some('l'));
assert_eq!(iter.next(), Some('l'));
assert_eq!(iter.next(), Some('o'));
assert_eq!(iter.next(), None);

43、 bytes
bytes()：将字符串分割为一个迭代器，每个元素都是一个字节。

let s = String::from("hello");
let mut iter = s.bytes();
assert_eq!(iter.next(), Some(104));
assert_eq!(iter.next(), Some(101));
assert_eq!(iter.next(), Some(108));
assert_eq!(iter.next(), Some(108));
assert_eq!(iter.next(), Some(111));
assert_eq!(iter.next(), None);

44、 as_str
as_str()：将 String 对象转换为字符串切片。

let s = String::from("hello");
let slice = s.as_str();

45、 as_mut_str
as_mut_str()：将 String 对象转换为可变字符串切片。

let mut s = String::from("foobar");
let s_mut_str = s.as_mut_str();
s_mut_str.make_ascii_uppercase();
assert_eq!("FOOBAR", s_mut_str);

46、 remove_matches
remove_matches()：删除字符串中所有匹配的子串。

#![feature(string_remove_matches)]  //使用不稳定的库功能，此行必须
let mut s = String::from("Trees are not green, the sky is not blue.");
s.remove_matches("not ");
assert_eq!("Trees are green, the sky is blue.", s);

String字符串包括但不限于此46种方法，更多方法请见官方文档：

String in std::string - Rust

​

文章标签：
索引
程序员
Rust
关键词：
Rust类型
库String
String字符串
字符串String
String方法
HannYang
目录
相关文章
米诺斯
|
3天前
|
C++ 容器
C++字符串string容器(构造、赋值、拼接、查找、替换、比较、存取、插入、删除、子串)
C++字符串string容器(构造、赋值、拼接、查找、替换、比较、存取、插入、删除、子串)
米诺斯
12 1
多多!
|
5天前
|
存储 缓存 Java
JavaSE 字符串String及相关API StringBuilder StringJoiner 底层原理 详解
JavaSE 字符串String及相关API StringBuilder StringJoiner 底层原理 详解
多多!
11 2
sumith
|
4天前
|
Java 数据处理 Apache
探讨Java中判断String类型为空和null的方法
探讨Java中判断String类型为空和null的方法
sumith
11 1
tsglz3210
|
9天前
|
C语言 C++
C++对C的改进和拓展\string类型
C++对C的改进和拓展\string类型
tsglz3210
8 1
Eternity._
|
14天前
|
编译器 C++
【C++进阶】深入STL之string：模拟实现走进C++字符串的世界
【C++进阶】深入STL之string：模拟实现走进C++字符串的世界
Eternity._
15 1
米诺斯
|
1天前
|
存储 Rust 开发者
Rust复合类型详解
Rust复合类型详解
米诺斯
5 0
米诺斯
|
1天前
|
存储 Rust 自然语言处理
Rust标量类型详解
Rust标量类型详解
米诺斯
7 0
知更鸟呆呆
|
15天前
|
C++ 容器
【C++语言】String 类关键函数实现，手搓一个简单字符串类！
【C++语言】String 类关键函数实现，手搓一个简单字符串类！
知更鸟呆呆
16 0
游客iyfakqyinfxv2
|
5天前
|
Java UED
Java中String强转int：一种常见的错误和解决方法
在Java中将非数字字符串转换为整数会导致`NumberFormatException`。要解决这个问题，可以使用`try-catch`捕获异常，正则表达式验证数字格式，或利用异常信息提供错误提示。例如，`Integer.parseInt()`会因遇到非数字字符如`&quot;123abc&quot;`而抛出异常，但通过异常处理或正则`\\d+`可确保安全转换。记得在编程时避免直接强转，以防止程序异常中断。
游客iyfakqyinfxv2
45 3
兴化
|
1天前
|
安全 Java
Java基础之StringBuffer
Java中的`StringBuffer`是线程安全的可变字符串，适用于多线程环境，其方法同步导致较慢。`StringBuilder`在Java 5引入，非线程安全但更快，适合单线程操作。两者均提供append、insert、delete等方法。在不需要线程安全时，选择`StringBuilder`以提升效率。
兴化
8 1

热门文章

最新文章

  • 1
    Rust 笔记：Rust 语言中使用 vector（向量）
  • 2
    Android中使用Rust构建so库
  • 3
    Rust hello world !
  • 4
    【Rust 实战】Rust与C#交互-生成DLL库
  • 5
    历时四年，Dropbox 用 Rust 重写同步引擎核心代码
  • 6
    上手体验用 Rust + Tauri 编写一个抖音批量下载器
  • 7
    Rust 大展拳脚的新兴领域：机密计算
  • 8
    Serverless时代Rust即将称王，详解C、Java、Go、Rust高并发背后的技术？
  • 9
    rust实现解析yml配置
  • 10
    【算法】1476. 子矩形查询（java / c / c++ / python / go / rust）
  • 1
    JavaScript 中如何检测一个变量是一个 String 类型？
    33
  • 2
    javaDataUtil将 Date 转为 LocalDateTime转Long转String转Date
    40
  • 3
    BigDecimal转String
    18
  • 4
    C++入门指南：string类文档详细解析（非常经典，建议收藏）
    55
  • 5
    【Java】如果一个集合中类型是String如何使用拉姆达表达式 进行Bigdecimal类型计算？
    39
  • 6
    js开发：请解释什么是ES6的模板字符串（template string），并给出一个示例。
    25
  • 7
    【Java】String类常用方法总结
    28
  • 8
    CMake String函数：如何巧妙地在cmake中操作字符串
    305
  • 9
    C++ std::string类的使用
    31
  • 10
    深入C#中的String类
    18

    • 相关课程

    更多
  • Go语言核心编程 - 基础语法、数组、切片、Map

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 语言入门-3：string的方法
  • 语言入门-2：基本类型
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）