Primitive Type char

一个字符类型。

char 类型代表一个字符。更具体地说，由于 ‘character’ 在 Unicode 中不是一个明确定义的概念，因此 char 是一个 Unicode 标量值。

本文档描述了 char 类型上的许多方法和 trait 实现。由于技术原因，the std::char module 中还有其他单独的文档。

Validity

char 是一个 Unicode 标量值，它是除 代理代码点 之外的任何 Unicode 代码点。这有一个固定的数字定义: 代码点在 0 到 0x10FFFF 的范围内，包括 0 到 0x10FFFF。 UTF-16 使用的代理代码点在 0xD800 到 0xDFFF 范围内。

无论是作为字面量还是在运行时，都不能构造不是 Unicode 标量值的 char:

// 这些都是编译器错误
['\u{D800}', '\u{DFFF}', '\u{110000}'];

// Panics; from_u32 返回 None。
char::from_u32(0xDE01).unwrap();

// 未定义的行为
unsafe { char::from_u32_unchecked(0x110000) };

USV 也是可以在 UTF-8 中编码的精确值集。 因为 char 值是 USV 而 str 值是有效的 UTF-8，所以将任何 char 存储在 str 中或从 str 读取任何字符作为 char 是安全的。

编译器可以理解有效 char 值的差距，因此在下面的示例中，这两个范围被理解为涵盖了可能的 char 值的整个范围，并且 非穷举匹配 没有错误。

let c: char = 'a';
match c {
    '\0' ..= '\u{D7FF}' => false,
    '\u{E000}' ..= '\u{10FFFF}' => true,
};

所有的 USV 都是有效的 char 值，但并不是所有的都代表一个真实的字符。 许多 USV 目前没有分配给一个字符，但将来可能会被分配 (“保留”); 有些永远不会是字符 (“非字符”); 并且有些可能被不同的用户赋予不同的含义 (“私有使用”)。

Representation

char 的大小始终为四个字节。这与给定字符作为 String 的一部分的表示形式不同。例如：

let v = vec!['h', 'e', 'l', 'l', 'o'];

// 五个元素乘以每个元素四个字节
assert_eq!(20, v.len() * std::mem::size_of::<char>());

let s = String::from("hello");

// 5 个元素乘以每个元素一个字节
assert_eq!(5, s.len() * std::mem::size_of::<u8>());

与往常一样，请记住，人类对 ‘character’ 的直觉可能不是 map 到 Unicode 的定义。 例如，尽管看起来相似，但 ‘é’ 字符是一个 Unicode 代码点，而 ‘é’ 是两个 Unicode 代码点：

let mut chars = "é".chars();
// U+00e9: '带锐音符的拉丁小写字母 e'
assert_eq!(Some('\u{00e9}'), chars.next());
assert_eq!(None, chars.next());

let mut chars = "é".chars();
// U+0065: ' 拉丁小写字母 e'
assert_eq!(Some('\u{0065}'), chars.next());
// U+0301: '结合重音'
assert_eq!(Some('\u{0301}'), chars.next());
assert_eq!(None, chars.next());

这意味着 will 上方的第一个字符串的内容适合 char，而第二个字符串 will 的内容则不会。

尝试使用第二个字符串的内容创建 char 字面量会产生错误：

error: character literal may only contain one codepoint: 'é'
let c = 'é';
        ^^^

char 的 4 字节固定大小的另一个含义是，每个字符处理可能最终会使用更多的内存：

let s = String::from("love: ❤️");
let v: Vec<char> = s.chars().collect();

assert_eq!(12, std::mem::size_of_val(&s[..]));
assert_eq!(32, std::mem::size_of_val(&v[..]));

Implementations

impl char

pub const MAX: char = '\u{10ffff}'

char 可以拥有所有权的最高有效代码点 '\u{10FFFF}'。

Examples

let c: char = something_which_returns_char();
assert!(c <= char::MAX);

let value_at_max = char::MAX as u32;
assert_eq!(char::from_u32(value_at_max), Some('\u{10FFFF}'));
assert_eq!(char::from_u32(value_at_max + 1), None);

pub const REPLACEMENT_CHARACTER: char = '�'

U+FFFD REPLACEMENT CHARACTER () 在 Unicode 中用于表示解码错误。

例如，当将格式错误的 UTF-8 字节提供给 String::from_utf8_lossy 时，就会发生这种情况。

pub const UNICODE_VERSION: (u8, u8, u8) = crate::unicode::UNICODE_VERSION

char 和 str 方法的 Unicode 部分所基于的 Unicode 版本。

Unicode 的新版本会定期发布，随后会更新标准库中取决于 Unicode 的所有方法。 因此，某些 char 和 str 方法的行为以及该常量的值会随时间变化。 这不是一个突破性的改变。

版本编号方案在 Unicode 11.0 或更高版本，第 3.1 节 Unicode 标准版本 中进行了说明。

pub fn decode_utf16<I: IntoIterator<Item = u16>>( iter: I ) -> DecodeUtf16<I::IntoIter>

在 iter 中的 UTF-16 编码的代码点上创建一个迭代器，将不成对的代理返回为 Errs。

Examples

基本用法：

// 𝄞mus<invalid>ic<invalid>
let v = [
    0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834,
];

assert_eq!(
    char::decode_utf16(v)
        .map(|r| r.map_err(|e| e.unpaired_surrogate()))
        .collect::<Vec<_>>(),
    vec![
        Ok('𝄞'),
        Ok('m'), Ok('u'), Ok('s'),
        Err(0xDD1E),
        Ok('i'), Ok('c'),
        Err(0xD834)
    ]
);

通过用替换字符替换 Err 结果，可以获得有损解码器：

// 𝄞mus<invalid>ic<invalid>
let v = [
    0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834,
];

assert_eq!(
    char::decode_utf16(v)
       .map(|r| r.unwrap_or(char::REPLACEMENT_CHARACTER))
       .collect::<String>(),
    "𝄞mus�ic�"
);

pub const fn from_u32(i: u32) -> Option<char>

将 u32 转换为 char。

请注意，所有的 chars 都是有效的 u32，并且可以使用以下命令将其强制转换为 1 as:

let c = '💯';
let i = c as u32;

assert_eq!(128175, i);

但是，相反的情况并非如此：并非所有有效的 u32 都是有效的 char。 如果输入不是 char 的有效值，from_u32() 将返回 None。

有关忽略这些检查的该函数的不安全版本，请参见 from_u32_unchecked。

Examples

基本用法：

let c = char::from_u32(0x2764);

assert_eq!(Some('❤'), c);

当输入不是有效的 char 时返回 None：

let c = char::from_u32(0x110000);

assert_eq!(None, c);

pub unsafe fn from_u32_unchecked(i: u32) -> char

将 u32 转换为 char，而忽略有效性。

请注意，所有的 chars 都是有效的 u32，并且可以使用以下命令将其强制转换为 1 as:

let c = '💯';
let i = c as u32;

assert_eq!(128175, i);

但是，相反的情况并非如此：并非所有有效的 u32 都是有效的 char。 from_u32_unchecked() 将忽略这一点，并盲目地转换为 char，可能会创建一个无效的。

Safety

该函数是不安全的，因为它可能创建无效的 char 值。

有关此函数的安全版本，请参见 from_u32 函数。

Examples

基本用法：

let c = unsafe { char::from_u32_unchecked(0x2764) };

assert_eq!('❤', c);

pub const fn from_digit(num: u32, radix: u32) -> Option<char>

将给定基数中的数字转换为 char。

这里的 ‘radix’ 有时也称为 ‘base’。 基数 2 表示二进制数，以十进制表示的十进制，以十六进制表示十六进制的基数，以给出一些公共值。

支持任意基数。

如果输入不是给定基数中的数字，from_digit() 将返回 None。

Panics

如果给定的基数大于 36，就会出现 panics。

Examples

基本用法：

let c = char::from_digit(4, 10);

assert_eq!(Some('4'), c);

// 十进制 11 是以 16 为底的一位数字
let c = char::from_digit(11, 16);

assert_eq!(Some('b'), c);

当输入不是数字时返回 None：

let c = char::from_digit(20, 10);

assert_eq!(None, c);

传递较大的基数，导致 panic：

// 这个 panics
let _c = char::from_digit(1, 37);

pub fn is_digit(self, radix: u32) -> bool

检查 char 是否为给定基数中的数字。

这里的 ‘radix’ 有时也称为 ‘base’。 基数 2 表示二进制数，以十进制表示的十进制，以十六进制表示十六进制的基数，以给出一些公共值。

支持任意基数。

与 is_numeric() 相比，此函数仅识别字符 0-9，a-z 和 A-Z。

‘Digit’ 定义为仅以下字符：

• 0-9
• a-z
• A-Z

要更全面地了解 ‘digit’，请参见 is_numeric()。

Panics

如果给定的基数大于 36，就会出现 panics。

Examples

基本用法：

assert!('1'.is_digit(10));
assert!('f'.is_digit(16));
assert!(!'f'.is_digit(10));

传递较大的基数，导致 panic：

// 这个 panics
'1'.is_digit(37);

pub const fn to_digit(self, radix: u32) -> Option<u32>

将 char 转换为给定基数的数字。

这里的 ‘radix’ 有时也称为 ‘base’。 基数 2 表示二进制数，以十进制表示的十进制，以十六进制表示十六进制的基数，以给出一些公共值。

支持任意基数。

‘Digit’ 定义为仅以下字符：

• 0-9
• a-z
• A-Z

Errors

如果 char 未引用给定基数中的数字，则返回 None。

Panics

如果给定的基数大于 36，就会出现 panics。

Examples

基本用法：

assert_eq!('1'.to_digit(10), Some(1));
assert_eq!('f'.to_digit(16), Some(15));

传递非数字会导致失败：

assert_eq!('f'.to_digit(10), None);
assert_eq!('z'.to_digit(16), None);

传递较大的基数，导致 panic：

// 这个 panics
let _ = '1'.to_digit(37);

pub fn escape_unicode(self) -> EscapeUnicode

返回一个迭代器，该迭代器将字符的十六进制 Unicode 转义生成为 chars。

这将使用 \u{NNNNNN} 格式的 Rust 语法对字符进行转义，其中 NNNNNN 是十六进制表示形式。

Examples

作为迭代器：

for c in '❤'.escape_unicode() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", '❤'.escape_unicode());

两者都等同于：

println!("\\u{{2764}}");

使用 to_string：

assert_eq!('❤'.escape_unicode().to_string(), "\\u{2764}");

pub fn escape_debug(self) -> EscapeDebug

返回一个迭代器，该迭代器将字符的字面量转义码生成为 chars。

这将转义类似于 str 或 char 的 Debug 实现的字符。

Examples

作为迭代器：

for c in '\n'.escape_debug() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", '\n'.escape_debug());

两者都等同于：

println!("\\n");

使用 to_string：

assert_eq!('\n'.escape_debug().to_string(), "\\n");

pub fn escape_default(self) -> EscapeDefault

返回一个迭代器，该迭代器将字符的字面量转义码生成为 chars。

选择默认值时会偏向于生成在多种语言 (包括 C++ 11 和类似的 C 系列语言) 中都合法的字面量。 确切的规则是：

• 制表符被转义为 \t。
• 回车符被转义为 \r。
• 换行符转为 \n。
• 单引号转义为 \'。
• 双引号转义为 \"。
• 反斜杠转义为 \\。
• 可打印 ASCII 范围 0x20 .. 中的任何字符 0x7e (含 0x7e) 不会转义。
• 所有其他字符均使用十六进制 Unicode 转义； 请参见 escape_unicode。

Examples

作为迭代器：

for c in '"'.escape_default() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", '"'.escape_default());

两者都等同于：

println!("\\\"");

使用 to_string：

assert_eq!('"'.escape_default().to_string(), "\\\"");

pub const fn len_utf8(self) -> usize

返回以 UTF-8 编码时此 char 所需的字节数。

该字节数始终在 1 到 4 之间 (含 1 和 4)。

Examples

基本用法：

let len = 'A'.len_utf8();
assert_eq!(len, 1);

let len = 'ß'.len_utf8();
assert_eq!(len, 2);

let len = 'ℝ'.len_utf8();
assert_eq!(len, 3);

let len = '💣'.len_utf8();
assert_eq!(len, 4);

&str 类型保证其内容为 UTF-8，因此我们可以比较将每个代码点表示为 char 相对于 &str 本身所花费的长度：

// 作为字符
let eastern = '東';
let capital = '京';

// 两者都可以表示为三个字节
assert_eq!(3, eastern.len_utf8());
assert_eq!(3, capital.len_utf8());

// 作为 &str，这两个编码为 UTF-8
let tokyo = "東京";

let len = eastern.len_utf8() + capital.len_utf8();

// 我们可以看到它们总共占用六个字节...
assert_eq!(6, tokyo.len());

// ... 就像 &str
assert_eq!(len, tokyo.len());

pub const fn len_utf16(self) -> usize

返回以 UTF-16 编码时 char 所需的 16 位代码单元的数量。

对于 basic multilingual plane 或 supplementary planes 中的 unicode 标量值，代码单元的数量始终为 1 或 2。

有关此概念的更多说明，请参见 len_utf8() 的文档。该函数是一个镜像，但是用于 UTF-16 而不是 UTF-8。

Examples

基本用法：

let n = 'ß'.len_utf16();
assert_eq!(n, 1);

let len = '💣'.len_utf16();
assert_eq!(len, 2);

pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str

将此字符编码为 UTF-8 到提供的字节缓冲区中，然后返回包含编码字符的缓冲区的子切片。

Panics

如果缓冲区不够大，就会出现 panics。 长度为四的缓冲区足够大，可以对任何 char 进行编码。

Examples

在这两个示例中，‘ß’ 占用两个字节进行编码。

let mut b = [0; 2];

let result = 'ß'.encode_utf8(&mut b);

assert_eq!(result, "ß");

assert_eq!(result.len(), 2);

缓冲区太小：

let mut b = [0; 1];

// 这个 panics
'ß'.encode_utf8(&mut b);

pub fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16]

将此字符编码为 UTF-16 到提供的 u16 缓冲区中，然后返回包含编码字符的缓冲区的子切片。

Panics

如果缓冲区不够大，就会出现 panics。 长度为 2 的缓冲区足够大，可以对任何 char 进行编码。

Examples

在这两个示例中，‘𝕊’ 都需要两个 u16 进行编码。

let mut b = [0; 2];

let result = '𝕊'.encode_utf16(&mut b);

assert_eq!(result.len(), 2);

缓冲区太小：

let mut b = [0; 1];

// 这个 panics
'𝕊'.encode_utf16(&mut b);

pub fn is_alphabetic(self) -> bool

如果此 char 具有 Alphabetic 属性，则返回 true。

Alphabetic 在 Unicode 标准 的第 4 章 (字符属性) 中描述并在 Unicode Character Database DerivedCoreProperties.txt 中指定。

Examples

基本用法：

assert!('a'.is_alphabetic());
assert!('京'.is_alphabetic());

let c = '💝';
// love 有很多东西，但它不是按字母顺序排列的
assert!(!c.is_alphabetic());

pub fn is_lowercase(self) -> bool

如果此 char 具有 Lowercase 属性，则返回 true。

Lowercase 在 Unicode 标准 的第 4 章 (字符属性) 中描述并在 Unicode 字符数据库 DerivedCoreProperties.txt 中指定。

Examples

基本用法：

assert!('a'.is_lowercase());
assert!('δ'.is_lowercase());
assert!(!'A'.is_lowercase());
assert!(!'Δ'.is_lowercase());

// 各种中文脚本和标点符号没有大小写，因此：
assert!(!'中'.is_lowercase());
assert!(!' '.is_lowercase());

在 const 上下文中:

#![feature(const_unicode_case_lookup)]
const CAPITAL_DELTA_IS_LOWERCASE: bool = 'Δ'.is_lowercase();
assert!(!CAPITAL_DELTA_IS_LOWERCASE);

pub fn is_uppercase(self) -> bool

如果此 char 具有 Uppercase 属性，则返回 true。

Uppercase 在 Unicode 标准 的第 4 章 (字符属性) 中描述并在 Unicode 字符数据库 DerivedCoreProperties.txt 中指定。

Examples

基本用法：

assert!(!'a'.is_uppercase());
assert!(!'δ'.is_uppercase());
assert!('A'.is_uppercase());
assert!('Δ'.is_uppercase());

// 各种中文脚本和标点符号没有大小写，因此：
assert!(!'中'.is_uppercase());
assert!(!' '.is_uppercase());

在 const 上下文中:

#![feature(const_unicode_case_lookup)]
const CAPITAL_DELTA_IS_UPPERCASE: bool = 'Δ'.is_uppercase();
assert!(CAPITAL_DELTA_IS_UPPERCASE);

pub fn is_whitespace(self) -> bool

如果此 char 具有 White_Space 属性，则返回 true。

White_Space 在 Unicode 字符数据库 PropList.txt 中指定。

Examples

基本用法：

assert!(' '.is_whitespace());

// 行中断
assert!('\n'.is_whitespace());

// 一个不间断空格
assert!('\u{A0}'.is_whitespace());

assert!(!'越'.is_whitespace());

pub fn is_alphanumeric(self) -> bool

如果此 char 满足 is_alphabetic() 或 is_numeric()，则返回 true。

Examples

基本用法：

assert!('٣'.is_alphanumeric());
assert!('7'.is_alphanumeric());
assert!('৬'.is_alphanumeric());
assert!('¾'.is_alphanumeric());
assert!('①'.is_alphanumeric());
assert!('K'.is_alphanumeric());
assert!('و'.is_alphanumeric());
assert!('藏'.is_alphanumeric());

pub fn is_control(self) -> bool

如果此 char 具有控制代码的常规类别，则返回 true。

[Unicode 标准] 的第 4 章 (字符属性) 中描述了控制代码 (具有 Cc 的常规类别的代码点)，并在 Unicode 字符数据库 UnicodeData.txt 中进行了指定。

Examples

基本用法：

// U+009C，字符串终止符
assert!('œ'.is_control());
assert!(!'q'.is_control());

pub fn is_numeric(self) -> bool

如果此 char 具有数字的常规类别之一，则返回 true。

在 Unicode 字符数据库 UnicodeData.txt 中指定了数字的常规类别 (Nd 表示十进制数字，Nl 表示类似字母的数字字符，No 表示其他数字字符)。

This method doesn’t cover everything that could be considered a number, e.g. ideographic numbers like ‘三’. 如果您想要包括具有重叠目的的字符在内的所有内容，那么您可能需要使用 unicode 或语言处理库来公开适当的字符属性，而不是查看 unicode 类别。

如果要解析 ASCII 十进制数字 (0-9) 或 ASCII base-N，请改用 is_ascii_digit 或 is_digit。

Examples

基本用法：

assert!('٣'.is_numeric());
assert!('7'.is_numeric());
assert!('৬'.is_numeric());
assert!('¾'.is_numeric());
assert!('①'.is_numeric());
assert!(!'K'.is_numeric());
assert!(!'و'.is_numeric());
assert!(!'藏'.is_numeric());
assert!(!'三'.is_numeric());

pub fn to_lowercase(self) -> ToLowercase

返回一个迭代器，该迭代器将这个 char 的小写字母映射为一个或多个 chars.

如果此 char 没有小写映射，则迭代器将产生相同的 char。

如果此 char 具有 Unicode 字符数据库 UnicodeData.txt 给出的一对一小写映射，则迭代器将产生该 char。

如果此 char 需要特殊考虑 (例如，多个 char)，则迭代器将产生 SpecialCasing.txt 给定的 char。

此操作无需裁剪即可执行无条件映射。即，转换独立于上下文和语言。

在 Unicode 标准 中，第 4 章 (字符属性) 通常讨论大小写映射，而第 3 章 (一致性) 讨论大小写转换的默认算法。

Examples

作为迭代器：

for c in 'İ'.to_lowercase() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", 'İ'.to_lowercase());

两者都等同于：

println!("i\u{307}");

使用 to_string：

assert_eq!('C'.to_lowercase().to_string(), "c");

// 有时结果是多个字符：
assert_eq!('İ'.to_lowercase().to_string(), "i\u{307}");

// 同时没有大写和小写字母的字符会转换成自己。
assert_eq!('山'.to_lowercase().to_string(), "山");

pub fn to_uppercase(self) -> ToUppercase

返回一个迭代器，该迭代器将这个 char 的大写映射生成为一个或多个 chars.

如果此 char 没有大写映射，则迭代器生成相同的 char。

如果此 char 具有 Unicode 字符数据库 UnicodeData.txt 给出的一对一大写映射，则迭代器将产生该 char。

如果此 char 需要特殊考虑 (例如，多个 char)，则迭代器将产生 SpecialCasing.txt 给定的 char。

此操作无需裁剪即可执行无条件映射。即，转换独立于上下文和语言。

在 Unicode 标准 中，第 4 章 (字符属性) 通常讨论大小写映射，而第 3 章 (一致性) 讨论大小写转换的默认算法。

Examples

作为迭代器：

for c in 'ß'.to_uppercase() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", 'ß'.to_uppercase());

两者都等同于：

println!("SS");

使用 to_string：

assert_eq!('c'.to_uppercase().to_string(), "C");

// 有时结果是多个字符：
assert_eq!('ß'.to_uppercase().to_string(), "SS");

// 同时没有大写和小写字母的字符会转换成自己。
assert_eq!('山'.to_uppercase().to_string(), "山");

关于语言环境说明

在土耳其语中，相当于 ‘i’ 的拉丁语具有 5 种形式，而不是 2 种形式：

• ‘Dotless’: I/ı，有时写成 ï
• ‘Dotted’: İ / i

注意，小写的点缀 ‘i’ 与拉丁字母相同。Therefore:

let upper_i = 'i'.to_uppercase().to_string();

upper_i 的值在此取决于文本的语言：如果我们在 en-US 中，则应为 "I"，但如果我们在 tr_TR 中，则应为 "İ"。 to_uppercase() 没有考虑到这一点，因此：

let upper_i = 'i'.to_uppercase().to_string();

assert_eq!(upper_i, "I");

适用于多种语言。

pub const fn is_ascii(&self) -> bool

检查该值是否在 ASCII 范围内。

Examples

let ascii = 'a';
let non_ascii = '❤';

assert!(ascii.is_ascii());
assert!(!non_ascii.is_ascii());

pub const fn as_ascii(&self) -> Option<Char>

🔬This is a nightly-only experimental API. (ascii_char #110998)

如果值在 ASCII 范围内，则返回 Some，否则返回 None。

当您将值传递给可以采用 ascii::Char 的其他东西时，这比 Self::is_ascii 更受欢迎，而不是需要再次检查其自身是否为 ASCII 值。

pub const fn to_ascii_uppercase(&self) -> char

使值的副本等效于其 ASCII 大写字母。

ASCII 字母 ‘a’ 到 ‘z’ 映射到 ‘A’ 到 ‘Z’，但是非 ASCII 字母不变。

要就地将值大写，请使用 make_ascii_uppercase()。

要除非 ASCII 字符外还使用大写 ASCII 字符，请使用 to_uppercase()。

Examples

let ascii = 'a';
let non_ascii = '❤';

assert_eq!('A', ascii.to_ascii_uppercase());
assert_eq!('❤', non_ascii.to_ascii_uppercase());

pub const fn to_ascii_lowercase(&self) -> char

以等效的 ASCII 小写形式复制值。

ASCII 字母 ‘A’ 到 ‘Z’ 映射到 ‘a’ 到 ‘z’，但是非 ASCII 字母不变。

要就地小写该值，请使用 make_ascii_lowercase()。

要除非 ASCII 字符外还使用小写 ASCII 字符，请使用 to_lowercase()。

Examples

let ascii = 'A';
let non_ascii = '❤';

assert_eq!('a', ascii.to_ascii_lowercase());
assert_eq!('❤', non_ascii.to_ascii_lowercase());

pub const fn eq_ignore_ascii_case(&self, other: &char) -> bool

检查两个值是否为 ASCII 不区分大小写的匹配。

相当于 to_ascii_lowercase(a) == to_ascii_lowercase(b)。

Examples

let upper_a = 'A';
let lower_a = 'a';
let lower_z = 'z';

assert!(upper_a.eq_ignore_ascii_case(&lower_a));
assert!(upper_a.eq_ignore_ascii_case(&upper_a));
assert!(!upper_a.eq_ignore_ascii_case(&lower_z));

pub fn make_ascii_uppercase(&mut self)

将此类型就地转换为其 ASCII 大写等效项。

ASCII 字母 ‘a’ 到 ‘z’ 映射到 ‘A’ 到 ‘Z’，但是非 ASCII 字母不变。

要返回新的大写值而不修改现有值，请使用 to_ascii_uppercase()。

Examples

let mut ascii = 'a';

ascii.make_ascii_uppercase();

assert_eq!('A', ascii);

pub fn make_ascii_lowercase(&mut self)

将此类型就地转换为其 ASCII 小写等效项。

ASCII 字母 ‘A’ 到 ‘Z’ 映射到 ‘a’ 到 ‘z’，但是非 ASCII 字母不变。

要返回新的小写值而不修改现有值，请使用 to_ascii_lowercase()。

Examples

let mut ascii = 'A';

ascii.make_ascii_lowercase();

assert_eq!('a', ascii);

pub const fn is_ascii_alphabetic(&self) -> bool

检查值是否为 ASCII 字母字符：

• U+0041 ‘A’ ..= U+005A ‘Z’, or
• U+0061 ‘a’ ..= U+007A ‘z’.

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(uppercase_a.is_ascii_alphabetic());
assert!(uppercase_g.is_ascii_alphabetic());
assert!(a.is_ascii_alphabetic());
assert!(g.is_ascii_alphabetic());
assert!(!zero.is_ascii_alphabetic());
assert!(!percent.is_ascii_alphabetic());
assert!(!space.is_ascii_alphabetic());
assert!(!lf.is_ascii_alphabetic());
assert!(!esc.is_ascii_alphabetic());

pub const fn is_ascii_uppercase(&self) -> bool

检查值是否为 ASCII 大写字符： U+0041 ‘A’ ..= U+005A ‘Z’.

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(uppercase_a.is_ascii_uppercase());
assert!(uppercase_g.is_ascii_uppercase());
assert!(!a.is_ascii_uppercase());
assert!(!g.is_ascii_uppercase());
assert!(!zero.is_ascii_uppercase());
assert!(!percent.is_ascii_uppercase());
assert!(!space.is_ascii_uppercase());
assert!(!lf.is_ascii_uppercase());
assert!(!esc.is_ascii_uppercase());

pub const fn is_ascii_lowercase(&self) -> bool

检查值是否为 ASCII 小写字符： U+0061 ‘a’ ..= U+007A ‘z’.

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(!uppercase_a.is_ascii_lowercase());
assert!(!uppercase_g.is_ascii_lowercase());
assert!(a.is_ascii_lowercase());
assert!(g.is_ascii_lowercase());
assert!(!zero.is_ascii_lowercase());
assert!(!percent.is_ascii_lowercase());
assert!(!space.is_ascii_lowercase());
assert!(!lf.is_ascii_lowercase());
assert!(!esc.is_ascii_lowercase());

pub const fn is_ascii_alphanumeric(&self) -> bool

检查值是否为 ASCII 字母数字字符：

• U+0041 ‘A’ ..= U+005A ‘Z’, or
• U+0061 ‘a’ ..= U+007A ‘z’, or
• U+0030 ‘0’ ..= U+0039 ‘9’.

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(uppercase_a.is_ascii_alphanumeric());
assert!(uppercase_g.is_ascii_alphanumeric());
assert!(a.is_ascii_alphanumeric());
assert!(g.is_ascii_alphanumeric());
assert!(zero.is_ascii_alphanumeric());
assert!(!percent.is_ascii_alphanumeric());
assert!(!space.is_ascii_alphanumeric());
assert!(!lf.is_ascii_alphanumeric());
assert!(!esc.is_ascii_alphanumeric());

pub const fn is_ascii_digit(&self) -> bool

检查值是否为 ASCII 十进制数字： U+0030 ‘0’ ..= U+0039 ‘9’.

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(!uppercase_a.is_ascii_digit());
assert!(!uppercase_g.is_ascii_digit());
assert!(!a.is_ascii_digit());
assert!(!g.is_ascii_digit());
assert!(zero.is_ascii_digit());
assert!(!percent.is_ascii_digit());
assert!(!space.is_ascii_digit());
assert!(!lf.is_ascii_digit());
assert!(!esc.is_ascii_digit());

pub fn is_ascii_octdigit(&self) -> bool

🔬This is a nightly-only experimental API. (is_ascii_octdigit #101288)

检查值是否为 ASCII 八进制数字: U+0030 ‘0’ ..= U+0037 ‘7’.

Examples

#![feature(is_ascii_octdigit)]

let uppercase_a = 'A';
let a = 'a';
let zero = '0';
let seven = '7';
let nine = '9';
let percent = '%';
let lf = '\n';

assert!(!uppercase_a.is_ascii_octdigit());
assert!(!a.is_ascii_octdigit());
assert!(zero.is_ascii_octdigit());
assert!(seven.is_ascii_octdigit());
assert!(!nine.is_ascii_octdigit());
assert!(!percent.is_ascii_octdigit());
assert!(!lf.is_ascii_octdigit());

pub const fn is_ascii_hexdigit(&self) -> bool

检查值是否为 ASCII 十六进制数字：

• U+0030 ‘0’ ..= U+0039 ‘9’, or
• U+0041 ‘A’ ..= U+0046 ‘F’, or
• U+0061 ‘a’ ..= U+0066 ‘f’.

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(uppercase_a.is_ascii_hexdigit());
assert!(!uppercase_g.is_ascii_hexdigit());
assert!(a.is_ascii_hexdigit());
assert!(!g.is_ascii_hexdigit());
assert!(zero.is_ascii_hexdigit());
assert!(!percent.is_ascii_hexdigit());
assert!(!space.is_ascii_hexdigit());
assert!(!lf.is_ascii_hexdigit());
assert!(!esc.is_ascii_hexdigit());

pub const fn is_ascii_punctuation(&self) -> bool

检查值是否为 ASCII 标点符号：

• U+0021 ..= U+002F ! " # $ % & ' ( ) * + , - . /, or
• U+003A ..= U+0040 : ; < = > ? @, or
• U+005B ..= U+0060 [ \ ] ^ _ ` , or
• U+007B ..= U+007E { | } ~

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(!uppercase_a.is_ascii_punctuation());
assert!(!uppercase_g.is_ascii_punctuation());
assert!(!a.is_ascii_punctuation());
assert!(!g.is_ascii_punctuation());
assert!(!zero.is_ascii_punctuation());
assert!(percent.is_ascii_punctuation());
assert!(!space.is_ascii_punctuation());
assert!(!lf.is_ascii_punctuation());
assert!(!esc.is_ascii_punctuation());

pub const fn is_ascii_graphic(&self) -> bool

检查值是否为 ASCII 图形字符： U+0021 ‘!’ ..= U+007E ‘~’.

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(uppercase_a.is_ascii_graphic());
assert!(uppercase_g.is_ascii_graphic());
assert!(a.is_ascii_graphic());
assert!(g.is_ascii_graphic());
assert!(zero.is_ascii_graphic());
assert!(percent.is_ascii_graphic());
assert!(!space.is_ascii_graphic());
assert!(!lf.is_ascii_graphic());
assert!(!esc.is_ascii_graphic());

pub const fn is_ascii_whitespace(&self) -> bool

检查值是否为 ASCII 空格字符： U+0020 空格、U+0009 水平制表符、U+000A 换行、U+000C 换页或 U+000D 回车。

Rust 使用 WhatWG 基础标准的 ASCII 空格的定义。还有其他几种广泛使用的定义。 例如，POSIX 语言环境 包括 U+000B 垂直标签以及所有上述字符，但是 - 从相同的规格来看 -Bourne shell 中 “field splitting” 的默认规则 仅考虑空格，水平标签和 LINE FEED 作为空白。

如果要编写将处理现有文件格式的程序，请在使用此函数之前检查该格式的空格定义。

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(!uppercase_a.is_ascii_whitespace());
assert!(!uppercase_g.is_ascii_whitespace());
assert!(!a.is_ascii_whitespace());
assert!(!g.is_ascii_whitespace());
assert!(!zero.is_ascii_whitespace());
assert!(!percent.is_ascii_whitespace());
assert!(space.is_ascii_whitespace());
assert!(lf.is_ascii_whitespace());
assert!(!esc.is_ascii_whitespace());

pub const fn is_ascii_control(&self) -> bool

检查值是否为 ASCII 控制字符： U+0000 NUL ..= U+001F 单元分隔符，或 U+007F 删除。 请注意，大多数 ASCII 空格字符是控制字符，而 SPACE 不是。

Examples

let uppercase_a = 'A';
let uppercase_g = 'G';
let a = 'a';
let g = 'g';
let zero = '0';
let percent = '%';
let space = ' ';
let lf = '\n';
let esc = '\x1b';

assert!(!uppercase_a.is_ascii_control());
assert!(!uppercase_g.is_ascii_control());
assert!(!a.is_ascii_control());
assert!(!g.is_ascii_control());
assert!(!zero.is_ascii_control());
assert!(!percent.is_ascii_control());
assert!(!space.is_ascii_control());
assert!(lf.is_ascii_control());
assert!(esc.is_ascii_control());

Trait Implementations

impl Clone for char

fn clone(&self) -> Self

返回值的副本。

fn clone_from(&mut self, source: &Self)

从 source 执行复制分配。

impl Debug for char

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl Default for char

fn default() -> char

Returns the default value of \x00

impl Display for char

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl From<char> for u128

fn from(c: char) -> Self

将 char 转换为 u128。

Examples

use std::mem;

let c = '⚙';
let u = u128::from(c);
assert!(16 == mem::size_of_val(&u))

impl From<char> for u32

fn from(c: char) -> Self

将 char 转换为 u32。

Examples

use std::mem;

let c = 'c';
let u = u32::from(c);
assert!(4 == mem::size_of_val(&u))

impl From<char> for u64

fn from(c: char) -> Self

将 char 转换为 u64。

Examples

use std::mem;

let c = '👤';
let u = u64::from(c);
assert!(8 == mem::size_of_val(&u))

impl From<u8> for char

将 0x00..=0xFF 中的字节映射到 char，该 char 的代码点具有相同的值，即 U+0000..=U+00FF。

Unicode 的设计使其可以使用 IANA 称为 ISO-8859-1 的字符编码有效地解码字节。 此编码与 ASCII 兼容。

请注意，这与 ISO/IEC 8859-1 又名不同 ISO 8859-1 (连字符少一个)，它留下了一些 “blanks” 字节值，这些值未分配给任何字符。 ISO-8859-1 (属于 IANA) 将它们分配给 C0 和 C1 控制代码。

请注意，这也与 Windows-1252 也不同 代码页 1252，它是 ISO/IEC 8859-1 的超集，它为标点符号和各种拉丁字符分配了一些 (不是全部) 空格。

为了进一步混淆，在 Web 上 ascii，iso-8859-1 和 windows-1252 都是 Windows-1252 超集的别名，该超集用相应的 C0 和 C1 控制代码填充了其余的空白。

fn from(i: u8) -> Self

将 u8 转换为 char。

Examples

use std::mem;

let u = 32 as u8;
let c = char::from(u);
assert!(4 == mem::size_of_val(&c))

impl FromStr for char

type Err = ParseCharError

可以从解析中返回的相关错误。

fn from_str(s: &str) -> Result<Self, Self::Err>

解析字符串 s 以返回此类型的值。

impl Hash for char

fn hash<H: Hasher>(&self, state: &mut H)

将该值输入给定的 Hasher。

fn hash_slice<H: Hasher>(data: &[Self], state: &mut H)where Self: Sized,

将这种类型的切片送入给定的 Hasher 中。

impl Ord for char

fn cmp(&self, other: &char) -> Ordering

此方法返回 self 和 other 之间的 Ordering。

fn max(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最大值。

fn min(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最小值。

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

将值限制在某个时间间隔内。

impl PartialEq<char> for char

fn eq(&self, other: &char) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &char) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl PartialOrd<char> for char

fn partial_cmp(&self, other: &char) -> Option<Ordering>

如果存在，则此方法返回 self 和 other 值之间的顺序。

fn lt(&self, other: &char) -> bool

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

fn le(&self, other: &char) -> bool

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

fn ge(&self, other: &char) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

fn gt(&self, other: &char) -> bool

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

impl<'a> Pattern<'a> for char

搜索等于给定 char 的字符。

Examples

assert_eq!("Hello world".find('o'), Some(4));

type Searcher = CharSearcher<'a>

🔬This is a nightly-only experimental API. (pattern #27721)

此模式的关联搜索者

fn into_searcher(self, haystack: &'a str) -> Self::Searcher

🔬This is a nightly-only experimental API. (pattern #27721)

从 self 和 haystack 构造关联的搜索器以进行搜索。

fn is_contained_in(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)

检查模式是否与 haystack 中的任何位置匹配

fn is_prefix_of(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)

检查模式是否在 haystack 的前面匹配

fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

🔬This is a nightly-only experimental API. (pattern #27721)

如果匹配，则从 haystack 的正面删除模式。

fn is_suffix_of(self, haystack: &'a str) -> boolwhere Self::Searcher: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)

检查模式是否与 haystack 的后面匹配

fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where Self::Searcher: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)

如果匹配，则从 haystack 的后面删除模式。

impl Step for char

fn steps_between(start: &char, end: &char) -> Option<usize>

🔬This is a nightly-only experimental API. (step_trait #42168)

返回从 start 到 end 所需的 successor 步骤的数量。

fn forward_checked(start: char, count: usize) -> Option<char>

🔬This is a nightly-only experimental API. (step_trait #42168)

返回通过将 self count 的 successor 而获得的值。

fn backward_checked(start: char, count: usize) -> Option<char>

🔬This is a nightly-only experimental API. (step_trait #42168)

返回通过获取 self count 次的 predecessor 而获得的值。

unsafe fn forward_unchecked(start: char, count: usize) -> char

🔬This is a nightly-only experimental API. (step_trait #42168)

返回通过将 self count 的 successor 而获得的值。

unsafe fn backward_unchecked(start: char, count: usize) -> char

🔬This is a nightly-only experimental API. (step_trait #42168)

返回通过获取 self count 次的 predecessor 而获得的值。

fn forward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait #42168)

返回通过将 self count 的 successor 而获得的值。

fn backward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait #42168)

返回通过获取 self count 次的 predecessor 而获得的值。

impl TryFrom<char> for u8

将 U+0000..=U+00FF 中代码点的 char 映射到 0x00..=0xFF 中具有相同值的字节，如果代码点大于 U+00FF 则失败。

有关编码的详细信息，请参见 impl From<u8> for char。

type Error = TryFromCharError

发生转换错误时返回的类型。

fn try_from(c: char) -> Result<u8, Self::Error>

执行转换。

impl TryFrom<u32> for char

type Error = CharTryFromError

发生转换错误时返回的类型。

fn try_from(i: u32) -> Result<Self, Self::Error>

执行转换。

impl ConstParamTy for char

impl Copy for char

impl Eq for char

impl StructuralEq for char

impl TrustedStep for char