Primitive Type char [−]
A Unicode scalar value.
A char
represents a
Unicode scalar
value, as it can
contain any Unicode code point except high-surrogate and low-surrogate code
points.
As such, only values in the ranges [0x0,0xD7FF] and [0xE000,0x10FFFF]
(inclusive) are allowed. A char
can always be safely cast to a u32
;
however the converse is not always true due to the above range limits
and, as such, should be performed via the from_u32
function.
Methods
impl char
fn is_digit(self, radix: u32) -> bool
Checks if a char
parses as a numeric digit in the given radix.
Compared to is_numeric()
, this function only recognizes the characters
0-9
, a-z
and A-Z
.
Return value
Returns true
if c
is a valid digit under radix
, and false
otherwise.
Panics
Panics if given a radix > 36.
Examples
fn main() { let c = '1'; assert!(c.is_digit(10)); assert!('f'.is_digit(16)); }let c = '1'; assert!(c.is_digit(10)); assert!('f'.is_digit(16));
fn to_digit(self, radix: u32) -> Option<u32>
Converts a character to the corresponding digit.
Return value
If c
is between '0' and '9', the corresponding value between 0 and
9. If c
is 'a' or 'A', 10. If c
is 'b' or 'B', 11, etc. Returns
none if the character does not refer to a digit in the given radix.
Panics
Panics if given a radix outside the range [0..36].
Examples
fn main() { let c = '1'; assert_eq!(c.to_digit(10), Some(1)); assert_eq!('f'.to_digit(16), Some(15)); }let c = '1'; assert_eq!(c.to_digit(10), Some(1)); assert_eq!('f'.to_digit(16), Some(15));
fn escape_unicode(self) -> EscapeUnicode
Returns an iterator that yields the hexadecimal Unicode escape of a
character, as char
s.
All characters are escaped with Rust syntax of the form \\u{NNNN}
where NNNN
is the shortest hexadecimal representation of the code
point.
Examples
fn main() { for c in '❤'.escape_unicode() { print!("{}", c); } println!(""); }for c in '❤'.escape_unicode() { print!("{}", c); } println!("");
This prints:
\u{2764}
Collecting into a String
:
let heart: String = '❤'.escape_unicode().collect(); assert_eq!(heart, r"\u{2764}");
fn escape_default(self) -> EscapeDefault
Returns an iterator that yields the 'default' ASCII and
C++11-like literal escape of a character, as char
s.
The default is chosen with a bias toward producing literals that are legal in a variety of languages, including C++11 and similar C-family languages. The exact rules are:
- Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
- Single-quote, double-quote and backslash chars are backslash- escaped.
- Any other chars in the range [0x20,0x7e] are not escaped.
- Any other chars are given hex Unicode escapes; see
escape_unicode
.
Examples
fn main() { for i in '"'.escape_default() { println!("{}", i); } }for i in '"'.escape_default() { println!("{}", i); }
This prints:
\
"
Collecting into a String
:
let quote: String = '"'.escape_default().collect(); assert_eq!(quote, "\\\"");
fn len_utf8(self) -> usize
Returns the number of bytes this character would need if encoded in UTF-8.
Examples
fn main() { let n = 'ß'.len_utf8(); assert_eq!(n, 2); }let n = 'ß'.len_utf8(); assert_eq!(n, 2);
fn len_utf16(self) -> usize
Returns the number of 16-bit code units this character would need if encoded in UTF-16.
Examples
fn main() { let n = 'ß'.len_utf16(); assert_eq!(n, 1); }let n = 'ß'.len_utf16(); assert_eq!(n, 1);
fn encode_utf8(self, dst: &mut [u8]) -> Option<usize>
Encodes this character as UTF-8 into the provided byte buffer, and then returns the number of bytes written.
If the buffer is not large enough, nothing will be written into it and a
None
will be returned. A buffer of length four is large enough to
encode any char
.
Examples
In both of these examples, 'ß' takes two bytes to encode.
#![feature(unicode)] fn main() { let mut b = [0; 2]; let result = 'ß'.encode_utf8(&mut b); assert_eq!(result, Some(2)); }#![feature(unicode)] let mut b = [0; 2]; let result = 'ß'.encode_utf8(&mut b); assert_eq!(result, Some(2));
A buffer that's too small:
#![feature(unicode)] fn main() { let mut b = [0; 1]; let result = 'ß'.encode_utf8(&mut b); assert_eq!(result, None); }#![feature(unicode)] let mut b = [0; 1]; let result = 'ß'.encode_utf8(&mut b); assert_eq!(result, None);
fn encode_utf16(self, dst: &mut [u16]) -> Option<usize>
Encodes this character as UTF-16 into the provided u16
buffer, and
then returns the number of u16
s written.
If the buffer is not large enough, nothing will be written into it and a
None
will be returned. A buffer of length 2 is large enough to encode
any char
.
Examples
In both of these examples, 'ß' takes one u16
to encode.
#![feature(unicode)] let mut b = [0; 1]; let result = 'ß'.encode_utf16(&mut b); assert_eq!(result, Some(1));
A buffer that's too small:
#![feature(unicode)] fn main() { let mut b = [0; 0]; let result = 'ß'.encode_utf8(&mut b); assert_eq!(result, None); }#![feature(unicode)] let mut b = [0; 0]; let result = 'ß'.encode_utf8(&mut b); assert_eq!(result, None);
fn is_alphabetic(self) -> bool
Returns whether the specified character is considered a Unicode alphabetic code point.
fn is_xid_start(self) -> bool
Returns whether the specified character satisfies the 'XID_Start' Unicode property.
'XID_Start' is a Unicode Derived Property specified in UAX #31, mostly similar to ID_Start but modified for closure under NFKx.
fn is_xid_continue(self) -> bool
Returns whether the specified char
satisfies the 'XID_Continue'
Unicode property.
'XID_Continue' is a Unicode Derived Property specified in UAX #31, mostly similar to 'ID_Continue' but modified for closure under NFKx.
fn is_lowercase(self) -> bool
Indicates whether a character is in lowercase.
This is defined according to the terms of the Unicode Derived Core
Property Lowercase
.
fn is_uppercase(self) -> bool
Indicates whether a character is in uppercase.
This is defined according to the terms of the Unicode Derived Core
Property Uppercase
.
fn is_whitespace(self) -> bool
Indicates whether a character is whitespace.
Whitespace is defined in terms of the Unicode Property White_Space
.
fn is_alphanumeric(self) -> bool
Indicates whether a character is alphanumeric.
Alphanumericness is defined in terms of the Unicode General Categories 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
fn is_control(self) -> bool
Indicates whether a character is a control code point.
Control code points are defined in terms of the Unicode General
Category Cc
.
fn is_numeric(self) -> bool
Indicates whether the character is numeric (Nd, Nl, or No).
fn to_lowercase(self) -> ToLowercase
Converts a character to its lowercase equivalent.
This performs complex unconditional mappings with no tailoring.
See to_uppercase()
for references and more information.
Return value
Returns an iterator which yields the characters corresponding to the lowercase equivalent of the character. If no conversion is possible then an iterator with just the input character is returned.
Examples
fn main() { assert_eq!(Some('c'), 'C'.to_lowercase().next()); }assert_eq!(Some('c'), 'C'.to_lowercase().next());
fn to_uppercase(self) -> ToUppercase
Converts a character to its uppercase equivalent.
This performs complex unconditional mappings with no tailoring:
it maps one Unicode character to its uppercase equivalent
according to the Unicode database 1
and the additional complex mappings SpecialCasing.txt
.
Conditional mappings (based on context or language) are not considered here.
A full reference can be found here 2.
Return value
Returns an iterator which yields the characters corresponding to the uppercase equivalent of the character. If no conversion is possible then an iterator with just the input character is returned.
Examples
fn main() { assert_eq!(Some('C'), 'c'.to_uppercase().next()); }assert_eq!(Some('C'), 'c'.to_uppercase().next());
Trait Implementations
impl PartialEq<char> for char
impl Eq for char
impl PartialOrd<char> for char
fn partial_cmp(&self, other: &char) -> Option<Ordering>
fn lt(&self, other: &char) -> bool
fn le(&self, other: &char) -> bool
fn ge(&self, other: &char) -> bool
fn gt(&self, other: &char) -> bool
impl Ord for char
impl Clone for char
fn clone(&self) -> char
fn clone_from(&mut self, source: &Self)
impl Default for char
impl<'a> Pattern<'a> for char
Searches for chars that are equal to a given char