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 可以具有的最高有效代码点。

charUnicode 标量值,这意味着它是 代码点,但仅在一定范围内。 MAX 是有效的 Unicode 标量值 的最高有效代码点。

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

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

charstr 方法的 Unicode 部分所基于的 Unicode 版本。

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

版本编号方案在 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。 如果输入不是 char 的有效值,from_u32() 将返回 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,可能会创建一个无效的。

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

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

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
let _c = char::from_digit(1, 37);
Run

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

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

支持任意基数。

is_numeric() 相比,此函数仅识别字符 0-9a-zA-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

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

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

这将转义类似于 strcharDebug 实现的字符。

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

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

Examples

基本用法:

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

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

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

LowercaseUnicode 标准 的第 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

UppercaseUnicode 标准 的第 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_SpaceUnicode 字符数据库 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’, 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

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

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

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

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

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

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

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

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

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

返回值的副本。 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 上 asciiiso-8859-1windows-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

将该值输入给定的 HasherRead more

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

此方法返回 selfother 之间的 OrderingRead more

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

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

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

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

如果存在,则此方法返回 selfother 值之间的顺序。 Read more

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

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

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

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 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

selfhaystack 构造关联的搜索器以进行搜索。 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

返回从 startend 所需的 successor 步骤的数量。 Read more

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

recently redesigned

返回通过将 self countsuccessor 而获得的值。 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 countsuccessor 而获得的值。 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 countsuccessor 而获得的值。 Read more

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

recently redesigned

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

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

执行转换。