字符类型 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 范围。

rust
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 字符。

rust
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 的常用方法 ​

rust
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 个字节。

rust
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);  // '中'
}

转义字符 ​

rust
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);
}

基本示例 ​

统计字符串中各类字符的数量:

rust
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 有什么区别?

对比项charu8
大小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 编码,同一个字符在两者中占用的字节数可能不同。