Primitive Type char1.0.0[−]

Expand description

一个字符类型。

char 类型代表一个字符。 更具体地说，由于 ‘character’ 不是 Unicode 中定义明确的概念，因此 char 是 [Unicode 标量值]，与 [Unicode 代码点] 相似但不相同。

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

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

char 可以具有的最高有效代码点。

char 是 Unicode Scalar Value，这意味着它是 Code Point，但仅在一定范围内。 MAX 是有效 Unicode Scalar Value 的最高有效代码点。

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

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

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

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

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

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

Examples

基本用法:

use std::char::decode_utf16;

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

assert_eq!(
    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 结果，可以获得有损解码器:

use std::char::{decode_utf16, REPLACEMENT_CHARACTER};

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

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

将 u32 转换为 char。

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

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

assert_eq!(128175, i);
Run

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

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

Examples

基本用法:

use std::char;

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

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

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

use std::char;

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

assert_eq!(None, c);
Run

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

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

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

assert_eq!(128175, i);
Run

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

Safety

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

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

Examples

基本用法:

use std::char;

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

assert_eq!('❤', c);
Run

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

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

支持任意基数。

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

Panics

Panics (如果基数大于 36)。

Examples

基本用法:

use std::char;

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:

use std::char;

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

assert_eq!(None, c);
Run

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

ⓘ
use std::char;

// 这个 panics
char::from_digit(1, 37);
Run

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

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

支持任意基数。

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

‘Digit’ 被定义为仅以下字符:

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

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

Panics

Panics (如果基数大于 36)。

Examples

基本用法:

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

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

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

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

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

支持任意基数。

‘Digit’ 被定义为仅以下字符:

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

Errors

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

Panics

Panics (如果基数大于 36)。

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
'1'.to_digit(37);
Run

返回一个迭代器，该迭代器将字符的十六进制 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

返回一个迭代器，该迭代器将字符的字面量转义码生成为 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

返回一个迭代器，该迭代器将字符的字面量转义码生成为 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

返回以 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

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

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

Examples

基本用法:

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

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

将此字符编码为 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

将此字符编码为 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

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

Alphabetic 在 [Unicode 标准] 的第 4 章 (字符属性) 中进行了说明，并在 Unicode 字符数据库 DerivedCoreProperties.txt 中进行了指定。

Examples

基本用法:

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

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

如果此 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

如果此 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

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

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

Examples

基本用法:

assert!(' '.is_whitespace());

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

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

如果此 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

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

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

Examples

基本用法:

// U+009C, 终止符
assert!('œ'.is_control());
assert!(!'q'.is_control());
Run

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

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

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

返回一个迭代器，该迭代器将这个 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

返回一个迭代器，该迭代器将这个 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

适用于多种语言。

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

Examples

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

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

使值的副本等效于其 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

以等效的 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

检查两个值是否为 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

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

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

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

Examples

let mut ascii = 'a';

ascii.make_ascii_uppercase();

assert_eq!('A', ascii);
Run

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

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

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

Examples

let mut ascii = 'A';

ascii.make_ascii_lowercase();

assert_eq!('a', ascii);
Run

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

  • U+0041 ‘A’ ..= U+005A ‘Z’，或
  • 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: char = 0x1b_u8.into();

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

检查值是否为 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: char = 0x1b_u8.into();

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

检查值是否为 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: char = 0x1b_u8.into();

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

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

  • U+0041 ‘A’ ..= U+005A ‘Z’，或
  • U+0061 ‘a’ ..= U+007A ‘z’，或
  • 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: char = 0x1b_u8.into();

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

检查值是否为 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: char = 0x1b_u8.into();

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

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

  • U+0030 ‘0’ ..= U+0039 ‘9’，或
  • U+0041 ‘A’ ..= U+0046 ‘F’，或
  • 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: char = 0x1b_u8.into();

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

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

  • U+0021 ..= U+002F ! " # $ % & ' ( ) * + , - . /，或
  • U+003A ..= U+0040 : ; < = > ? @，或
  • U+005B ..= U+0060`[] ^ _```，或
  • 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: char = 0x1b_u8.into();

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

检查值是否为 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: char = 0x1b_u8.into();

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

检查值是否为 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: char = 0x1b_u8.into();

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

检查值是否为 ASCII 控制字符: U+0000 NUL ..= U+001F 单元分隔符，或 U+007F DELETE。 请注意，大多数 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: char = 0x1b_u8.into();

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

👎 Deprecated since 1.26.0:

use inherent methods instead

复制的 ASCII 字符的容器类型。

👎 Deprecated since 1.26.0:

use inherent methods instead

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

👎 Deprecated since 1.26.0:

use inherent methods instead

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

👎 Deprecated since 1.26.0:

use inherent methods instead

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

👎 Deprecated since 1.26.0:

use inherent methods instead

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

👎 Deprecated since 1.26.0:

use inherent methods instead

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

👎 Deprecated since 1.26.0:

use inherent methods instead

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

返回值的副本。 Read more

从 source 执行复制分配。 Read more

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

Returns the default value of \x00

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

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

将 u8 转换为 char。

Examples

use std::mem;

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

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

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

将该值输入给定的 Hasher。 Read more

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

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

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

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

将值限制为一定的时间间隔。 Read more

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

此方法测试 !=。

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

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

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

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

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

搜索等于给定 char 的字符。

Examples

assert_eq!("Hello world".find('o'), Some(4));
Run
🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

此模式的关联搜索者

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

recently redesigned

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

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

recently redesigned

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

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

recently redesigned

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

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

recently redesigned

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

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

recently redesigned

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

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

recently redesigned

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

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

recently redesigned

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

将给定值转换为 String。 Read more

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

执行转换。

Auto Trait Implementations

Blanket Implementations

获取 self 的 TypeId。 Read more

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

从拥有的值中借用。 Read more

执行转换。

执行转换。

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

通常通过克隆从借用数据中创建拥有的数据。 Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into #41263)

recently added

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

将给定值转换为 String。 Read more

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

执行转换。

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

执行转换。