Primitive Type char

1.0.0 ·
Expand description

一个字符类型。

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}'];
Run
ⓘ
// Panics; from_u32 返回 None。
char::from_u32(0xDE01).unwrap();
Run
// 未定义的行为
unsafe { char::from_u32_unchecked(0x110000) };
Run

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,
};
Run

所有的 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>());
Run

与往常一样，请记住，人类对 ‘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());
Run

这意味着 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[..]));
Run

Implementations§

source§

impl char

1.52.0 · source

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);
Run
1.52.0 · source

pub const REPLACEMENT_CHARACTER: char = '�'

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

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

1.52.0 · source

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 标准版本 中进行了说明。

1.52.0 · source

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

在 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)
    ]
);
Run

通过用替换字符替换 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�"
);
Run
1.52.0 (const: 1.67.0) · source

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);
Run

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

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

Examples

基本用法：

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

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

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

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

assert_eq!(None, c);
Run
1.52.0 (const: unstable) · source

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);
Run

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

Safety

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

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

Examples

基本用法：

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

assert_eq!('❤', c);
Run
1.52.0 (const: 1.67.0) · source

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);
Run

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

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

assert_eq!(None, c);
Run

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

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

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));
Run

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

ⓘ
// 这个 panics
'1'.is_digit(37);
Run
const: 1.67.0 · source

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));
Run

传递非数字会导致失败：

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

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

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

pub fn escape_unicode(self) -> EscapeUnicode ⓘ

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

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

Examples

作为迭代器：

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

直接使用 println!：

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

两者都等同于：

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

使用 to_string：

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

pub fn escape_debug(self) -> EscapeDebug ⓘ

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

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

Examples

作为迭代器：

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

直接使用 println!：

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

两者都等同于：

println!("\\n");
Run

使用 to_string：

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

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!();
Run

直接使用 println!：

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

两者都等同于：

println!("\\\"");
Run

使用 to_string：

assert_eq!('"'.escape_default().to_string(), "\\\"");
Run
const: 1.52.0 · source

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);
Run

&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());
Run
const: 1.52.0 · source

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);
Run
1.15.0 · source

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);
Run

缓冲区太小：

ⓘ
let mut b = [0; 1];

// 这个 panics
'ß'.encode_utf8(&mut b);
Run
1.15.0 · source

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);
Run

缓冲区太小：

ⓘ
let mut b = [0; 1];

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

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());
Run
const: unstable · source

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());
Run

在 const 上下文中:

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

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());
Run

在 const 上下文中:

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

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());
Run
source

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());
Run
source

pub fn is_control(self) -> bool

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

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

Examples

基本用法：

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

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());
Run
source

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!();
Run

直接使用 println!：

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

两者都等同于：

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

使用 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(), "山");
Run
source

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!();
Run

直接使用 println!：

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

两者都等同于：

println!("SS");
Run

使用 to_string：

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

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

// 同时没有大写和小写字母的字符会转换成自己。
assert_eq!('山'.to_uppercase().to_string(), "山");
Run
关于语言环境说明

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

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

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

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

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

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

assert_eq!(upper_i, "I");
Run

适用于多种语言。

1.23.0 (const: 1.32.0) · source

pub const fn is_ascii(&self) -> bool

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

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

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

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

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

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

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

1.23.0 (const: 1.52.0) · source

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());
Run
1.23.0 (const: 1.52.0) · source

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());
Run
1.23.0 (const: 1.52.0) · source

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));
Run
1.23.0 · source

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);
Run
1.23.0 · source

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);
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
const: unstable · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run
1.24.0 (const: 1.47.0) · source

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());
Run

Trait Implementations§

source§

impl AsciiExt for char

§

type Owned = char

👎Deprecated since 1.26.0: use inherent methods instead
复制的 ASCII 字符的容器类型。
source§

fn is_ascii(&self) -> bool

👎Deprecated since 1.26.0: use inherent methods instead
检查该值是否在 ASCII 范围内。 Read more
source§

fn to_ascii_uppercase(&self) -> Self::Owned

👎Deprecated since 1.26.0: use inherent methods instead
使值的副本等效于其 ASCII 大写字母。 Read more
source§

fn to_ascii_lowercase(&self) -> Self::Owned

👎Deprecated since 1.26.0: use inherent methods instead
以等效的 ASCII 小写形式复制值。 Read more
source§

fn eq_ignore_ascii_case(&self, o: &Self) -> bool

👎Deprecated since 1.26.0: use inherent methods instead
检查两个值是否为 ASCII 不区分大小写的匹配。 Read more
source§

fn make_ascii_uppercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead
将此类型就地转换为其 ASCII 大写等效项。 Read more
source§

fn make_ascii_lowercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead
将此类型就地转换为其 ASCII 小写等效项。 Read more
source§

impl Clone for char

source§

fn clone(&self) -> char

返回值的副本。 Read more
source§

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

从 source 执行复制分配。 Read more
source§

impl Debug for char

source§

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

使用给定的格式化程序格式化该值。 Read more
source§

impl Default for char

source§

fn default() -> char

Returns the default value of \x00

source§

impl Display for char

source§

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

使用给定的格式化程序格式化该值。 Read more
1.2.0 · source§

impl<'a> Extend<&'a char> for String

source§

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = &'a char>,

使用迭代器的内容扩展集合。 Read more
source§

fn extend_one(&mut self, _: &'a char)

🔬This is a nightly-only experimental API. (extend_one #72631)
用一个元素扩展一个集合。
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)
在集合中为给定数量的附加元素保留容量。 Read more
source§

impl Extend<char> for String

source§

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = char>,

使用迭代器的内容扩展集合。 Read more
source§

fn extend_one(&mut self, c: char)

🔬This is a nightly-only experimental API. (extend_one #72631)
用一个元素扩展一个集合。
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)
在集合中为给定数量的附加元素保留容量。 Read more
1.46.0 · source§

impl From<char> for String

source§

fn from(c: char) -> String

从单个字符分配一个拥有所有权的 String。

Example
let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..]);
Run
1.51.0 · source§

impl From<char> for u128

source§

fn from(c: char) -> u128

将 char 转换为 u128。

Examples
use std::mem;

let c = '⚙';
let u = u128::from(c);
assert!(16 == mem::size_of_val(&u))
Run
1.13.0 · source§

impl From<char> for u32

source§

fn from(c: char) -> u32

将 char 转换为 u32。

Examples
use std::mem;

let c = 'c';
let u = u32::from(c);
assert!(4 == mem::size_of_val(&u))
Run
1.51.0 · source§

impl From<char> for u64

source§

fn from(c: char) -> u64

将 char 转换为 u64。

Examples
use std::mem;

let c = '👤';
let u = u64::from(c);
assert!(8 == mem::size_of_val(&u))
Run
1.13.0 · source§

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 控制代码填充了其余的空白。

source§

fn from(i: u8) -> char

将 u8 转换为 char。

Examples
use std::mem;

let u = 32 as u8;
let c = char::from(u);
assert!(4 == mem::size_of_val(&c))
Run
1.17.0 · source§

impl<'a> FromIterator<&'a char> for String

source§

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = &'a char>,

从迭代器创建一个值。 Read more
1.12.0 · source§

impl<'a> FromIterator<char> for Cow<'a, str>

source§

fn from_iter<I>(it: I) -> Cow<'a, str>where I: IntoIterator<Item = char>,

从迭代器创建一个值。 Read more
source§

impl FromIterator<char> for String

source§

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = char>,

从迭代器创建一个值。 Read more
1.20.0 · source§

impl FromStr for char

§

type Err = ParseCharError

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

fn from_str(s: &str) -> Result<char, <char as FromStr>::Err>

解析字符串 s 以返回此类型的值。 Read more
source§

impl Hash for char

source§

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

将该值输入给定的 Hasher。 Read more
1.3.0 · source§

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

将这种类型的切片送入给定的 Hasher 中。 Read more
source§

impl Ord for char

source§

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

此方法返回 self 和 other 之间的 Ordering。 Read more
1.21.0 · source§

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

比较并返回两个值中的最大值。 Read more
1.21.0 · source§

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

比较并返回两个值中的最小值。 Read more
1.50.0 · source§

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

将值限制在某个时间间隔内。 Read more
source§

impl PartialEq<char> for char

source§

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

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

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

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

impl PartialOrd<char> for char

source§

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

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

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

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

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

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

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

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

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

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

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

搜索等于给定 char 的字符。

Examples

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

type Searcher = CharSearcher<'a>

🔬This is a nightly-only experimental API. (pattern #27721)
此模式的关联搜索者
source§

fn into_searcher(self, haystack: &'a str) -> <char as Pattern<'a>>::Searcher

🔬This is a nightly-only experimental API. (pattern #27721)
从 self 和 haystack 构造关联的搜索器以进行搜索。
source§

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

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 中的任何位置匹配
source§

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

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否在 haystack 的前面匹配
source§

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

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配，则从 haystack 的正面删除模式。
source§

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

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 的后面匹配
source§

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

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配，则从 haystack 的后面删除模式。
source§

impl Step for char

source§

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

🔬This is a nightly-only experimental API. (step_trait #42168)
返回从 start 到 end 所需的 successor 步骤的数量。 Read more
source§

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

🔬This is a nightly-only experimental API. (step_trait #42168)
返回通过将 self count 的 successor 而获得的值。 Read more
source§

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

🔬This is a nightly-only experimental API. (step_trait #42168)
返回通过获取 self count 次的 predecessor 而获得的值。 Read more
source§

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

🔬This is a nightly-only experimental API. (step_trait #42168)
返回通过将 self count 的 successor 而获得的值。 Read more
source§

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

🔬This is a nightly-only experimental API. (step_trait #42168)
返回通过获取 self count 次的 predecessor 而获得的值。 Read more
source§

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

🔬This is a nightly-only experimental API. (step_trait #42168)
返回通过将 self count 的 successor 而获得的值。 Read more
source§

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

🔬This is a nightly-only experimental API. (step_trait #42168)
返回通过获取 self count 次的 predecessor 而获得的值。 Read more
1.46.0 · source§

impl ToString for char

source§

fn to_string(&self) -> String

将给定值转换为 String。 Read more
1.59.0 · source§

impl TryFrom<char> for u8

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

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

§

type Error = TryFromCharError

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

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

执行转换。
1.34.0 · source§

impl TryFrom<u32> for char

§

type Error = CharTryFromError

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

fn try_from(i: u32) -> Result<char, <char as TryFrom<u32>>::Error>

执行转换。
source§

impl ConstParamTy for char

source§

impl Copy for char

source§

impl Eq for char

source§

impl StructuralEq for char

source§

impl TrustedStep for char

Auto Trait Implementations§

§

impl RefUnwindSafe for char

§

impl Send for char

§

impl Sync for char

§

impl Unpin for char

§

impl UnwindSafe for char

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 self 的 TypeId。 Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

从拥有的值中借用。 Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

返回未更改的参数。

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

调用 U::from(self)。

也就是说，这种转换是 From<T> for U 实现选择执行的任何操作。

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

获得所有权后的结果类型。
source§

fn to_owned(&self) -> T

从借用的数据创建拥有的数据，通常是通过克隆。 Read more
source§

fn clone_into(&self, target: &mut T)

使用借来的数据来替换拥有的数据，通常是通过克隆。 Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

将给定值转换为 String。 Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

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

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

执行转换。
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

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

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

执行转换。