常用成员方法速查表
核心类型常用成员方法速查表
覆盖Rust日常开发95%以上的场景，重点突出组合器（Rust核心生产力工具）
1. 数值类型 (i32/u32/f64/...)
所有数值类型通用方法，特殊方法单独标注
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
abs | fn abs(self) -> Self | 取绝对值 | (-5).abs() // 5 |
clamp | fn clamp(self, min: Self, max: Self) -> Self | 限制值在区间内 | 15.clamp(0, 10) // 10 |
max/min | fn max(self, other: Self) -> Self | 取两个值的最大/最小 | 3.max(5) // 5 |
pow | fn pow(self, exp: u32) -> Self | 整数幂运算 | 2.pow(3) // 8 |
sqrt | fn sqrt(self) -> f64 | 平方根（仅浮点数） | 4.0.sqrt() // 2.0 |
round/ceil/floor | fn round(self) -> f64 | 浮点数取整 | 2.7.round() // 3.0 |
to_string | fn to_string(&self) -> String | 转换为字符串 | 123.to_string() // "123" |
parse | fn parse<F: FromStr>(&self) -> Result<F, F::Err> | 字符串转数值 | "123".parse::<i32>().unwrap() // 123 |
2. 布尔类型 (bool)
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
then_some | fn then_some<T>(self, t: T) -> Option<T> | 条件转Option | true.then_some(5) // Some(5) |
then | fn then<T, F: FnOnce() -> T>(self, f: F) -> Option<T> | 条件执行函数转Option | `false.then( |
not | fn not(self) -> bool | 逻辑非（同!） | true.not() // false |
and/or | fn and(self, other: bool) -> bool | 逻辑与/或（短路） | true.and(false) // false |
3. 字符类型 (char)
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
is_alphabetic | fn is_alphabetic(self) -> bool | 是否为字母 | 'a'.is_alphabetic() // true |
is_numeric | fn is_numeric(self) -> bool | 是否为数字 | '5'.is_numeric() // true |
is_whitespace | fn is_whitespace(self) -> bool | 是否为空白字符 | ' '.is_whitespace() // true |
to_ascii_lowercase | fn to_ascii_lowercase(self) -> char | ASCII转小写 | 'A'.to_ascii_lowercase() // 'a' |
to_digit | fn to_digit(self, radix: u32) -> Option<u32> | 字符转指定进制数字 | 'a'.to_digit(16) // Some(10) |
4. 字符串切片 (&str)
Rust字符串核心，所有String都可通过as_str()转为&str
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
len | fn len(&self) -> usize | 字节长度（非字符数） | "中文".len() // 6 |
is_empty | fn is_empty(&self) -> bool | 是否为空 | "".is_empty() // true |
contains | fn contains(&self, pat: impl Pattern<'_>) -> bool | 是否包含子串 | "hello".contains("ell") // true |
starts_with/ends_with | fn starts_with(&self, pat: impl Pattern<'_>) -> bool | 是否以子串开头/结尾 | "hello".starts_with("he") // true |
trim | fn trim(&self) -> &str | 去除两端空白 | " hello ".trim() // "hello" |
split_whitespace | fn split_whitespace(&self) -> SplitWhitespace<'_> | 按任意空白分割 | "a b c".split_whitespace().collect::<Vec<_>>() // ["a","b","c"] |
split | fn split(&self, pat: impl Pattern<'_>) -> Split<'_> | 按指定分隔符分割 | "a,b,c".split(',').collect::<Vec<_>>() // ["a","b","c"] |
replace | fn replace(&self, from: &str, to: &str) -> String | 替换所有子串 | "hello".replace("l", "x") // "hexxo" |
parse | fn parse<F: FromStr>(&self) -> Result<F, F::Err> | 字符串转其他类型 | "123".parse::<i32>().unwrap() // 123 |
chars | fn chars(&self) -> Chars<'_> | 迭代Unicode字符 | "中文".chars().count() // 2 |
5. 字符串 (String)
可变字符串，拥有所有权
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
new | fn new() -> String | 创建空字符串 | let s = String::new(); |
with_capacity | fn with_capacity(capacity: usize) -> String | 预分配容量（性能优化） | let mut s = String::with_capacity(100); |
push_str | fn push_str(&mut self, string: &str) | 追加字符串切片 | let mut s = "hello".to_string(); s.push_str(" world"); |
push | fn push(&mut self, ch: char) | 追加单个字符 | s.push('!'); |
pop | fn pop(&mut self) -> Option<char> | 弹出最后一个字符 | s.pop() // Some('!') |
clear | fn clear(&mut self) | 清空字符串（保留容量） | s.clear(); |
as_str | fn as_str(&self) -> &str | 转为不可变切片 | let slice: &str = s.as_str(); |
into_bytes | fn into_bytes(self) -> Vec<u8> | 转为字节向量（消耗所有权） | "hello".into_bytes() // [104,101,108,108,111] |
6. 选项类型 (Option<T>)
Rust空值安全核心，高频组合器，参考组合器详解
7. 结果类型 (Result<T, E>)
Rust错误处理核心，高频组合器，参考组合器详解
8. 向量 (Vec<T>)
Rust动态数组，最常用集合
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
new | fn new() -> Vec<T> | 创建空向量 | let v: Vec<i32> = Vec::new(); |
with_capacity | fn with_capacity(capacity: usize) -> Vec<T> | 预分配容量（性能优化） | let mut v = Vec::with_capacity(100); |
push | fn push(&mut self, value: T) | 尾部追加元素 | v.push(5); |
pop | fn pop(&mut self) -> Option<T> | 尾部弹出元素 | v.pop() // Some(5) |
len/is_empty | fn len(&self) -> usize | 获取长度/判断是否为空 | v.len() // 0 |
get/get_mut | fn get(&self, index: usize) -> Option<&T> | 安全索引访问（返回Option） | v.get(0) // None |
insert | fn insert(&mut self, index: usize, element: T) | 指定位置插入元素 | v.insert(0, 5); |
remove | fn remove(&mut self, index: usize) -> T | 删除指定位置元素（O(n)） | v.remove(0) // 5 |
extend | fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) | 追加迭代器所有元素 | v.extend([1,2,3]); |
iter/iter_mut/into_iter | fn iter(&self) -> Iter<'_, T> | 生成不可变/可变/所有权迭代器 | `v.iter().for_each( |
sort | fn sort(&mut self) | 排序（要求T: Ord） | let mut v = [3,1,2].to_vec(); v.sort(); // [1,2,3] |
contains | fn contains(&self, x: &T) -> bool | 是否包含元素（要求T: PartialEq） | v.contains(&2) // true |
clear | fn clear(&mut self) | 清空向量（保留容量） | v.clear(); |
9. 切片 (&[T])
向量的不可变视图，所有Vec都可通过as_slice()转为&[T]
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
len/is_empty | fn len(&self) -> usize | 获取长度/判断是否为空 | [1,2,3].len() // 3 |
get/get_mut | fn get(&self, index: usize) -> Option<&T> | 安全索引访问 | [1,2,3].get(5) // None |
split_at | fn split_at(&self, mid: usize) -> (&[T], &[T]) | 分割为两个切片 | [1,2,3,4].split_at(2) // ([1,2], [3,4]) |
chunks | fn chunks(&self, chunk_size: usize) -> Chunks<'_, T> | 按固定大小分块迭代 | [1,2,3,4].chunks(2).collect::<Vec<_>>() // [[1,2], [3,4]] |
windows | fn windows(&self, size: usize) -> Windows<'_, T> | 滑动窗口迭代 | [1,2,3].windows(2).collect::<Vec<_>>() // [[1,2], [2,3]] |
sort | fn sort(&mut self) | 排序（可变切片） | let mut v = [3,1,2]; v.sort(); // [1,2,3] |
contains | fn contains(&self, x: &T) -> bool | 是否包含元素 | [1,2,3].contains(&2) // true |
10. 迭代器 (Iterator)
Rust函数式编程核心，所有集合都可生成迭代器，参考组合器详解
11. 哈希映射 (HashMap<K, V>)
键值对集合，O(1)查找
| 方法 | 签名 | 适用场景 | 示例 |
|---|---|---|---|
new | fn new() -> HashMap<K, V> | 创建空哈希映射 | let mut map: HashMap<String, i32> = HashMap::new(); |
insert | fn insert(&mut self, k: K, v: V) -> Option<V> | 插入键值对（返回旧值） | map.insert("a".to_string(), 5) // None |
get/get_mut | fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> | 按键查找值 | map.get("a") // Some(&5) |
remove | fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V> | 删除键值对（返回旧值） | map.remove("a") // Some(5) |
contains_key | fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool | 是否包含键 | map.contains_key("a") // false |
entry | fn entry(&mut self, key: K) -> Entry<'_, K, V> | 条目API（最常用） | map.entry("a".to_string()).or_insert(0) += 1; |
or_insert/or_insert_with | fn or_insert(self, default: V) -> &'a mut V | 键不存在时插入默认值 | map.entry("b".to_string()).or_insert(10); |
keys/values | fn keys(&self) -> Keys<'_, K, V> | 迭代所有键/值 | `map.keys().for_each( |
iter/iter_mut/into_iter | fn iter(&self) -> Iter<'_, K, V> | 生成键值对迭代器 | `map.iter().for_each( |
补充说明
- 所有权规则：方法名中带
into_前缀的通常会消耗self所有权；带_mut后缀的会修改self；带as_前缀的会返回引用 - 组合器优先：Rust中优先使用
map/and_then/filter等组合器，而非if let/match嵌套，代码更简洁易读 - 性能提示：创建集合时尽量使用
with_capacity预分配容量，避免频繁扩容 - 安全优先：避免滥用
unwrap，生产环境优先使用unwrap_or/unwrap_or_else或?操作符