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
:
// 未定义的行为
unsafe { char::from_u32_unchecked(0x110000) };
RunUSV 也是可以在 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[..]));
RunImplementations§
source§impl char
impl char
1.52.0 · sourcepub const REPLACEMENT_CHARACTER: char = '�'
pub const REPLACEMENT_CHARACTER: char = '�'
U+FFFD REPLACEMENT CHARACTER
() 在 Unicode 中用于表示解码错误。
例如,当将格式错误的 UTF-8 字节提供给 String::from_utf8_lossy
时,就会发生这种情况。
1.52.0 · sourcepub const UNICODE_VERSION: (u8, u8, u8) = crate::unicode::UNICODE_VERSION
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 · sourcepub fn decode_utf16<I: IntoIterator<Item = u16>>(
iter: I
) -> DecodeUtf16<I::IntoIter> ⓘ
pub fn decode_utf16<I: IntoIterator<Item = u16>>( iter: I ) -> DecodeUtf16<I::IntoIter> ⓘ
在 iter
中的 UTF-16 编码的代码点上创建一个迭代器,将不成对的代理返回为 Err
s。
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�"
);
Run1.52.0 (const: 1.67.0) · sourcepub const fn from_u32(i: u32) -> Option<char>
pub const fn from_u32(i: u32) -> Option<char>
将 u32
转换为 char
。
请注意,所有的 char
s 都是有效的 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);
Run1.52.0 (const: unstable) · sourcepub unsafe fn from_u32_unchecked(i: u32) -> char
pub unsafe fn from_u32_unchecked(i: u32) -> char
将 u32
转换为 char
,而忽略有效性。
请注意,所有的 char
s 都是有效的 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);
Run1.52.0 (const: 1.67.0) · sourcepub const fn from_digit(num: u32, radix: u32) -> Option<char>
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:
sourcepub fn is_digit(self, radix: u32) -> bool
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:
const: 1.67.0 · sourcepub const fn to_digit(self, radix: u32) -> Option<u32>
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:
sourcepub fn escape_unicode(self) -> EscapeUnicode ⓘ
pub fn escape_unicode(self) -> EscapeUnicode ⓘ
返回一个迭代器,该迭代器将字符的十六进制 Unicode 转义生成为 char
s。
这将使用 \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}");
Run1.20.0 · sourcepub fn escape_debug(self) -> EscapeDebug ⓘ
pub fn escape_debug(self) -> EscapeDebug ⓘ
sourcepub fn escape_default(self) -> EscapeDefault ⓘ
pub fn escape_default(self) -> EscapeDefault ⓘ
返回一个迭代器,该迭代器将字符的字面量转义码生成为 char
s。
选择默认值时会偏向于生成在多种语言 (包括 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(), "\\\"");
Runconst: 1.52.0 · sourcepub const fn len_utf8(self) -> usize
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());
Runconst: 1.52.0 · sourcepub const fn len_utf16(self) -> usize
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);
Run1.15.0 · sourcepub fn encode_utf8(self, dst: &mut [u8]) -> &mut str
pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str
1.15.0 · sourcepub fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16]
pub fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16]
sourcepub fn is_alphabetic(self) -> bool
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());
Runconst: unstable · sourcepub fn is_lowercase(self) -> bool
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);
Runconst: unstable · sourcepub fn is_uppercase(self) -> bool
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);
Runsourcepub fn is_whitespace(self) -> bool
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());
Runsourcepub fn is_alphanumeric(self) -> bool
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());
Runsourcepub fn is_control(self) -> bool
pub fn is_control(self) -> bool
如果此 char
具有控制代码的常规类别,则返回 true
。
[Unicode 标准] 的第 4 章 (字符属性) 中描述了控制代码 (具有 Cc
的常规类别的代码点),并在 Unicode 字符数据库 UnicodeData.txt
中进行了指定。
Examples
基本用法:
// U+009C,字符串终止符
assert!(''.is_control());
assert!(!'q'.is_control());
Runsourcepub fn is_numeric(self) -> bool
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());
Runsourcepub fn to_lowercase(self) -> ToLowercase ⓘ
pub fn to_lowercase(self) -> ToLowercase ⓘ
返回一个迭代器,该迭代器将这个 char
的小写字母映射为一个或多个
char
s.
如果此 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(), "山");
Runsourcepub fn to_uppercase(self) -> ToUppercase ⓘ
pub fn to_uppercase(self) -> ToUppercase ⓘ
返回一个迭代器,该迭代器将这个 char
的大写映射生成为一个或多个
char
s.
如果此 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();
Runupper_i
的值在此取决于文本的语言:如果我们在 en-US
中,则应为 "I"
,但如果我们在 tr_TR
中,则应为 "İ"
。
to_uppercase()
没有考虑到这一点,因此:
let upper_i = 'i'.to_uppercase().to_string();
assert_eq!(upper_i, "I");
Run适用于多种语言。
sourcepub const fn as_ascii(&self) -> Option<Char>
🔬This is a nightly-only experimental API. (ascii_char
#110998)
pub const fn as_ascii(&self) -> Option<Char>
ascii_char
#110998)如果值在 ASCII 范围内,则返回 Some
,否则返回 None
。
当您将值传递给可以采用 ascii::Char
的其他东西时,这比 Self::is_ascii
更受欢迎,而不是需要再次检查其自身是否为 ASCII 值。
1.23.0 (const: 1.52.0) · sourcepub const fn to_ascii_uppercase(&self) -> char
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());
Run1.23.0 (const: 1.52.0) · sourcepub const fn to_ascii_lowercase(&self) -> char
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());
Run1.23.0 (const: 1.52.0) · sourcepub const fn eq_ignore_ascii_case(&self, other: &char) -> bool
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));
Run1.23.0 · sourcepub fn make_ascii_uppercase(&mut self)
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);
Run1.23.0 · sourcepub fn make_ascii_lowercase(&mut self)
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);
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_alphabetic(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_uppercase(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_lowercase(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_alphanumeric(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_digit(&self) -> bool
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());
Runconst: unstable · sourcepub fn is_ascii_octdigit(&self) -> bool
🔬This is a nightly-only experimental API. (is_ascii_octdigit
#101288)
pub fn is_ascii_octdigit(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_hexdigit(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_punctuation(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_graphic(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_whitespace(&self) -> bool
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());
Run1.24.0 (const: 1.47.0) · sourcepub const fn is_ascii_control(&self) -> bool
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());
RunTrait Implementations§
1.13.0 · source§impl From<u8> for char
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§impl<'a> Pattern<'a> for char
impl<'a> Pattern<'a> for char
§type Searcher = CharSearcher<'a>
type Searcher = CharSearcher<'a>
pattern
#27721)source§fn into_searcher(self, haystack: &'a str) -> Self::Searcher
fn into_searcher(self, haystack: &'a str) -> Self::Searcher
pattern
#27721)self
和 haystack
构造关联的搜索器以进行搜索。source§fn is_contained_in(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
pattern
#27721)source§fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern
#27721)source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)source§fn is_suffix_of(self, haystack: &'a str) -> boolwhere
Self::Searcher: ReverseSearcher<'a>,
fn is_suffix_of(self, haystack: &'a str) -> boolwhere Self::Searcher: ReverseSearcher<'a>,
pattern
#27721)source§fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
Self::Searcher: ReverseSearcher<'a>,
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where Self::Searcher: ReverseSearcher<'a>,
pattern
#27721)source§impl Step for char
impl Step for char
source§fn steps_between(start: &char, end: &char) -> Option<usize>
fn steps_between(start: &char, end: &char) -> Option<usize>
step_trait
#42168)source§fn forward_checked(start: char, count: usize) -> Option<char>
fn forward_checked(start: char, count: usize) -> Option<char>
step_trait
#42168)source§fn backward_checked(start: char, count: usize) -> Option<char>
fn backward_checked(start: char, count: usize) -> Option<char>
step_trait
#42168)count
次的 predecessor 而获得的值。 Read moresource§unsafe fn forward_unchecked(start: char, count: usize) -> char
unsafe fn forward_unchecked(start: char, count: usize) -> char
step_trait
#42168)source§unsafe fn backward_unchecked(start: char, count: usize) -> char
unsafe fn backward_unchecked(start: char, count: usize) -> char
step_trait
#42168)count
次的 predecessor 而获得的值。 Read more1.59.0 · source§impl TryFrom<char> for u8
impl TryFrom<char> for u8
将 U+0000..=U+00FF 中代码点的 char
映射到 0x00..=0xFF 中具有相同值的字节,如果代码点大于 U+00FF 则失败。
有关编码的详细信息,请参见 impl From<u8> for char
。