字符类型 char 与 Unicode
什么是 char
char 是 Rust 的字符类型,表示一个 Unicode 标量值(Unicode Scalar Value)。它占用 4 个字节(32 位),能表示从 U+0000 到 U+10FFFF 范围内的所有 Unicode 字符,包括中文、日文、韩文、emoji 等。
注意 Rust 的 char 和 C 语言的 char 完全不同——C 的 char 只有 1 字节,只能表示 ASCII 字符。Rust 的 char 是 4 字节,覆盖整个 Unicode 范围。
fn main() {
// char 用单引号包裹
let letter = 'A';
let chinese = '中';
let emoji = '🦀'; // Rust 的吉祥物——螃蟹
let space = ' ';
let newline = '\n';
println!("字母:{}", letter);
println!("中文:{}", chinese);
println!("emoji:{}", emoji);
// char 固定占用 4 字节
println!("char 大小:{} 字节", std::mem::size_of::<char>()); // 4
}char 与 Unicode 编码
每个 char 值对应一个 Unicode 码点(code point)。你可以用 \u{十六进制码点} 语法来指定任意 Unicode 字符。
fn main() {
// 用 Unicode 转义指定字符
let a = '\u{0041}'; // 'A'(U+0041)
let zhong = '\u{4E2D}'; // '中'(U+4E2D)
let crab = '\u{1F980}'; // '🦀'(U+1F980)
println!("{}, {}, {}", a, zhong, crab);
// 查看字符的 Unicode 码点
let ch = '中';
println!("'{}' 的 Unicode 码点:U+{:04X}", ch, ch as u32); // U+4E2D
// 从 u32 转成 char
let code: u32 = 0x1F600; // 😀 的码点
match char::from_u32(code) {
Some(c) => println!("U+{:X} 对应:{}", code, c),
None => println!("无效的 Unicode 码点"),
}
// 遍历一些有趣的 Unicode 范围
println!("\nASCII 大写字母:");
for code in 'A'..='Z' {
print!("{} ", code);
}
println!();
println!("部分中文数字:");
for code in '零'..='九' {
print!("{} ", code);
}
println!();
}char 的常用方法
fn main() {
// 判断字符类别
println!("'A' 是字母:{}", 'A'.is_alphabetic()); // true
println!("'3' 是数字:{}", '3'.is_numeric()); // true
println!("'A' 是字母或数字:{}", 'A'.is_alphanumeric()); // true
println!("' ' 是空白:{}", ' '.is_whitespace()); // true
println!("'a' 是小写:{}", 'a'.is_lowercase()); // true
println!("'A' 是大写:{}", 'A'.is_uppercase()); // true
println!("'A' 是 ASCII:{}", 'A'.is_ascii()); // true
println!("'中' 是 ASCII:{}", '中'.is_ascii()); // false
// 大小写转换
println!("'a' 转大写:{}", 'a'.to_uppercase().next().unwrap()); // 'A'
println!("'A' 转小写:{}", 'A'.to_lowercase().next().unwrap()); // 'a'
// to_uppercase/to_lowercase 返回迭代器而不是单个 char
// 因为某些字符转换后可能变成多个字符
let sharp_s = 'ß';
let upper: String = sharp_s.to_uppercase().collect();
println!("'ß' 转大写:'{}'", upper); // "SS"(一个字符变两个)
// ASCII 相关转换
println!("'a' 转 ASCII 大写:{}", 'a'.to_ascii_uppercase()); // 'A'
println!("'3' 转数字值:{:?}", '3'.to_digit(10)); // Some(3)
println!("'F' 转十六进制值:{:?}", 'F'.to_digit(16)); // Some(15)
// char 和整数的转换
let ch = 'A';
let code = ch as u32; // 65
let back = code as u8 as char; // 'A'(仅适用于 ASCII 范围)
println!("'A' -> {} -> '{}'", code, back);
}char 与字符串的关系
Rust 的字符串(String 和 &str)使用 UTF-8 编码存储,而 char 是 UTF-32(固定 4 字节)。这意味着一个 char 在字符串中可能占用 1 到 4 个字节。
fn main() {
let s = "Hello中文🦀";
// 字节长度和字符数量不同
println!("字节长度:{}", s.len()); // 17(Hello=5 + 中文=6 + 🦀=4 + 空=2,实际按UTF-8算)
println!("字符数量:{}", s.chars().count()); // 8
// 遍历字符
println!("逐字符遍历:");
for ch in s.chars() {
println!(" '{}' -> U+{:04X},UTF-8 占 {} 字节",
ch, ch as u32, ch.len_utf8());
}
// 各种字符在 UTF-8 中的字节数
println!("\n字符的 UTF-8 编码长度:");
println!("'A':{} 字节", 'A'.len_utf8()); // 1(ASCII)
println!("'é':{} 字节", 'é'.len_utf8()); // 2
println!("'中':{} 字节", '中'.len_utf8()); // 3
println!("'🦀':{} 字节", '🦀'.len_utf8()); // 4
// 从字符串中取单个字符
// 不能用索引(s[0]),因为 UTF-8 是变长编码
let first_char = s.chars().next().unwrap();
println!("第一个字符:{}", first_char); // 'H'
// 取第 n 个字符
let third = s.chars().nth(5).unwrap();
println!("第 6 个字符:{}", third); // '中'
}转义字符
fn main() {
// 常用转义序列
let newline = '\n'; // 换行
let tab = '\t'; // 制表符
let backslash = '\\'; // 反斜杠
let single_quote = '\''; // 单引号
let null_char = '\0'; // 空字符(null)
println!("换行符 ASCII:{}", newline as u32); // 10
println!("制表符 ASCII:{}", tab as u32); // 9
println!("反斜杠:{}", backslash);
println!("单引号:{}", single_quote);
println!("空字符 ASCII:{}", null_char as u32); // 0
// ASCII 转义(用 \x 后接两位十六进制)
let bell = '\x07'; // ASCII 响铃符
let escape = '\x1B'; // ASCII ESC 键
println!("bell ASCII:{}", bell as u32); // 7
println!("escape ASCII:{}", escape as u32); // 27
// Unicode 转义(用 \u{} 后接 1-6 位十六进制)
let heart = '\u{2764}'; // ❤
let star = '\u{2B50}'; // ⭐
println!("{} {}", heart, star);
}基本示例
统计字符串中各类字符的数量:
fn main() {
let text = "Hello, 世界! 2026年 🦀 Rust";
let mut ascii_count = 0;
let mut chinese_count = 0;
let mut digit_count = 0;
let mut space_count = 0;
let mut other_count = 0;
for ch in text.chars() {
if ch.is_ascii_alphabetic() {
ascii_count += 1;
} else if ch >= '\u{4E00}' && ch <= '\u{9FFF}' {
// CJK 统一表意文字的基本范围
chinese_count += 1;
} else if ch.is_numeric() {
digit_count += 1;
} else if ch.is_whitespace() {
space_count += 1;
} else {
other_count += 1;
}
}
println!("文本:{}", text);
println!("ASCII 字母:{} 个", ascii_count);
println!("中文字符:{} 个", chinese_count);
println!("数字:{} 个", digit_count);
println!("空白:{} 个", space_count);
println!("其他(标点/emoji):{} 个", other_count);
println!("总字符数:{}", text.chars().count());
println!("总字节数:{}", text.len());
}常见问题
问题一:char 和 u8 有什么区别?
| 对比项 | char | u8 |
|---|---|---|
| 大小 | 4 字节 | 1 字节 |
| 表示范围 | 所有 Unicode 字符 | 0-255 |
| 字面量语法 | 'A' | b'A'(字节字面量) |
| 和字符串的关系 | .chars() 迭代得到 | .bytes() / .as_bytes() 得到 |
| 用途 | 表示人类可读的字符 | 表示原始字节数据 |
问题二:为什么不能用索引访问字符串中的字符?
因为 Rust 的字符串是 UTF-8 编码的,一个字符可能占 1-4 个字节。如果允许 s[0] 这样的语法,返回什么?一个字节(可能是残缺的字符)还是一个完整的字符(需要扫描找到边界)?Rust 认为这种歧义不应该被隐藏,所以要求你用 .chars().nth(n) 显式表达意图。
问题三:char 可以比较大小吗?
可以。char 实现了 Ord trait,按 Unicode 码点值比较。'A' < 'B' 是 true,'a' > 'A' 也是 true(因为小写字母的码点在大写字母后面)。
问题四:一个 emoji 是一个 char 吗?
大多数基本 emoji(如 🦀、😀)是单个 Unicode 码点,所以是一个 char。但有些复杂的 emoji(如 👨👩👧👦 家庭 emoji)实际上由多个码点组合而成,会对应多个 char。处理 emoji 时用 Unicode 的"字形簇"(grapheme cluster)概念更准确,标准库的 char 不处理这个层面。
适用场景
- 文本处理:逐字符分析文本内容、统计字符
- 输入验证:检查字符是否是字母、数字、空白等
- 大小写转换:单个字符级别的大小写操作
- Unicode 处理:处理多语言文本
- 解析器/词法分析器:逐字符扫描源代码或数据格式
- 密码强度检测:检查密码是否包含大写、小写、数字、特殊字符
注意事项
char是 4 字节,而 UTF-8 编码中同一个字符可能只需要 1-3 字节,大量存储字符时String比Vec<char>更省内存char不是"用户看到的一个字符"(字形簇),有些视觉上的单个字符实际上由多个char组成to_uppercase()和to_lowercase()返回迭代器而不是单个char,因为某些字符转换后会变成多个字符char和u32之间可以互转,但char::from_u32()可能返回None(无效码点)- 不要用
as u8把非 ASCII 的char转成字节,会截断丢失数据 - 字符串的
.len()返回字节数不是字符数,要字符数用.chars().count()
总结
Rust 的 char 类型是 4 字节的 Unicode 标量值,能表示几乎所有人类语言的字符以及 emoji 等符号。它通过单引号语法创建,支持 Unicode 转义(\u{码点})和 ASCII 转义(\xNN)。标准库为 char 提供了丰富的判断和转换方法(is_alphabetic、is_numeric、to_uppercase 等)。char 和字符串的关系需要注意编码差异——char 是固定 4 字节(UTF-32),而字符串是变长的 UTF-8 编码,同一个字符在两者中占用的字节数可能不同。