Struct collections::string::String
[−]
[src]
pub struct String { // some fields omitted }
A growable string stored as a UTF-8 encoded buffer.
Methods
impl String
fn new() -> String
Creates a new string buffer initialized with the empty string.
Examples
fn main() { let mut s = String::new(); }let mut s = String::new();
fn with_capacity(capacity: usize) -> String
Creates a new string buffer with the given capacity.
The string will be able to hold exactly capacity
`capacitybytes without reallocating. If
` bytes without
reallocating. If capacity
`capacity` is 0, the string will not allocate.
Examples
fn main() { let mut s = String::with_capacity(10); }let mut s = String::with_capacity(10);
fn from_str(string: &str) -> String
: needs investigation to see if to_string() can match perf
Creates a new string buffer from the given string.
Examples
#![feature(collections, core)] extern crate collections; fn main() { let s = String::from_str("hello"); assert_eq!(&s[..], "hello"); }let s = String::from_str("hello"); assert_eq!(&s[..], "hello");
fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>
Returns the vector as a string buffer, if possible, taking care not to copy it.
Failure
If the given vector is not valid UTF-8, then the original vector and the corresponding error is returned.
Examples
#![feature(core)] fn main() { use std::str::Utf8Error; let hello_vec = vec![104, 101, 108, 108, 111]; let s = String::from_utf8(hello_vec).unwrap(); assert_eq!(s, "hello"); let invalid_vec = vec![240, 144, 128]; let s = String::from_utf8(invalid_vec).err().unwrap(); let err = s.utf8_error(); assert_eq!(s.into_bytes(), [240, 144, 128]); }use std::str::Utf8Error; let hello_vec = vec![104, 101, 108, 108, 111]; let s = String::from_utf8(hello_vec).unwrap(); assert_eq!(s, "hello"); let invalid_vec = vec![240, 144, 128]; let s = String::from_utf8(invalid_vec).err().unwrap(); let err = s.utf8_error(); assert_eq!(s.into_bytes(), [240, 144, 128]);
fn from_utf8_lossy<'a>(v: &'a [u8]) -> Cow<'a, str>
Converts a vector of bytes to a new UTF-8 string. Any invalid UTF-8 sequences are replaced with U+FFFD REPLACEMENT CHARACTER.
Examples
fn main() { let input = b"Hello \xF0\x90\x80World"; let output = String::from_utf8_lossy(input); assert_eq!(output, "Hello \u{FFFD}World"); }let input = b"Hello \xF0\x90\x80World"; let output = String::from_utf8_lossy(input); assert_eq!(output, "Hello \u{FFFD}World");
fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>
Decode a UTF-16 encoded vector v
`vinto a
` into a String
`String, returning
`, returning None
`Noneif
`
if v
`v` contains any invalid data.
Examples
fn main() { // 𝄞music let mut v = &mut [0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063]; assert_eq!(String::from_utf16(v).unwrap(), "𝄞music".to_string()); // 𝄞mu<invalid>ic v[4] = 0xD800; assert!(String::from_utf16(v).is_err()); }// 𝄞music let mut v = &mut [0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063]; assert_eq!(String::from_utf16(v).unwrap(), "𝄞music".to_string()); // 𝄞mu<invalid>ic v[4] = 0xD800; assert!(String::from_utf16(v).is_err());
fn from_utf16_lossy(v: &[u16]) -> String
Decode a UTF-16 encoded vector v
`v` into a string, replacing
invalid data with the replacement character (U+FFFD).
Examples
fn main() { // 𝄞mus<invalid>ic<invalid> let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834]; assert_eq!(String::from_utf16_lossy(v), "𝄞mus\u{FFFD}ic\u{FFFD}".to_string()); }// 𝄞mus<invalid>ic<invalid> let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834]; assert_eq!(String::from_utf16_lossy(v), "𝄞mus\u{FFFD}ic\u{FFFD}".to_string());
unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String
Creates a new String
`String` from a length, capacity, and pointer.
This is unsafe because:
- We call
Vec::from_raw_parts
`Vec::from_raw_partsto get a
` to get aVec<u8>
`Vec`; - We assume that the
Vec
`Vec` contains valid UTF-8.
unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String
Converts a vector of bytes to a new String
`String` without checking if
it contains valid UTF-8. This is unsafe because it assumes that
the UTF-8-ness of the vector has already been validated.
fn into_bytes(self) -> Vec<u8>
Returns the underlying byte buffer, encoded as UTF-8.
Examples
#![feature(collections)] extern crate collections; fn main() { let s = String::from_str("hello"); let bytes = s.into_bytes(); assert_eq!(bytes, [104, 101, 108, 108, 111]); }let s = String::from_str("hello"); let bytes = s.into_bytes(); assert_eq!(bytes, [104, 101, 108, 108, 111]);
fn as_str(&self) -> &str
: waiting on RFC revision
Extracts a string slice containing the entire string.
fn push_str(&mut self, string: &str)
Pushes the given string onto this string buffer.
Examples
#![feature(collections)] extern crate collections; fn main() { let mut s = String::from_str("foo"); s.push_str("bar"); assert_eq!(s, "foobar"); }let mut s = String::from_str("foo"); s.push_str("bar"); assert_eq!(s, "foobar");
fn capacity(&self) -> usize
Returns the number of bytes that this string buffer can hold without reallocating.
Examples
fn main() { let s = String::with_capacity(10); assert!(s.capacity() >= 10); }let s = String::with_capacity(10); assert!(s.capacity() >= 10);
fn reserve(&mut self, additional: usize)
Reserves capacity for at least additional
`additionalmore bytes to be inserted in the given
` more bytes to be inserted
in the given String
`String`. The collection may reserve more space to avoid
frequent reallocations.
Panics
Panics if the new capacity overflows usize
`usize`.
Examples
fn main() { let mut s = String::new(); s.reserve(10); assert!(s.capacity() >= 10); }let mut s = String::new(); s.reserve(10); assert!(s.capacity() >= 10);
fn reserve_exact(&mut self, additional: usize)
Reserves the minimum capacity for exactly additional
`additionalmore bytes to be inserted in the given
` more bytes to be
inserted in the given String
`String`. Does nothing if the capacity is already
sufficient.
Note that the allocator may give the collection more space than it
requests. Therefore capacity can not be relied upon to be precisely
minimal. Prefer reserve
`reserve` if future insertions are expected.
Panics
Panics if the new capacity overflows usize
`usize`.
Examples
fn main() { let mut s = String::new(); s.reserve(10); assert!(s.capacity() >= 10); }let mut s = String::new(); s.reserve(10); assert!(s.capacity() >= 10);
fn shrink_to_fit(&mut self)
Shrinks the capacity of this string buffer to match its length.
Examples
#![feature(collections)] extern crate collections; fn main() { let mut s = String::from_str("foo"); s.reserve(100); assert!(s.capacity() >= 100); s.shrink_to_fit(); assert_eq!(s.capacity(), 3); }let mut s = String::from_str("foo"); s.reserve(100); assert!(s.capacity() >= 100); s.shrink_to_fit(); assert_eq!(s.capacity(), 3);
fn push(&mut self, ch: char)
Adds the given character to the end of the string.
Examples
#![feature(collections)] extern crate collections; fn main() { let mut s = String::from_str("abc"); s.push('1'); s.push('2'); s.push('3'); assert_eq!(s, "abc123"); }let mut s = String::from_str("abc"); s.push('1'); s.push('2'); s.push('3'); assert_eq!(s, "abc123");
fn as_bytes(&self) -> &[u8]
Works with the underlying buffer as a byte slice.
Examples
#![feature(collections)] extern crate collections; fn main() { let s = String::from_str("hello"); let b: &[_] = &[104, 101, 108, 108, 111]; assert_eq!(s.as_bytes(), b); }let s = String::from_str("hello"); let b: &[_] = &[104, 101, 108, 108, 111]; assert_eq!(s.as_bytes(), b);
fn truncate(&mut self, new_len: usize)
Shortens a string to the specified length.
Panics
Panics if new_len
`new_len> current length, or if
` > current length,
or if new_len
`new_len` is not a character boundary.
Examples
#![feature(collections)] extern crate collections; fn main() { let mut s = String::from_str("hello"); s.truncate(2); assert_eq!(s, "he"); }let mut s = String::from_str("hello"); s.truncate(2); assert_eq!(s, "he");
fn pop(&mut self) -> Option<char>
Removes the last character from the string buffer and returns it.
Returns None
`None` if this string buffer is empty.
Examples
#![feature(collections)] extern crate collections; fn main() { let mut s = String::from_str("foo"); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('f')); assert_eq!(s.pop(), None); }let mut s = String::from_str("foo"); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('f')); assert_eq!(s.pop(), None);
fn remove(&mut self, idx: usize) -> char
Removes the character from the string buffer at byte position idx
`idx` and
returns it.
Warning
This is an O(n) operation as it requires copying every element in the buffer.
Panics
If idx
`idx` does not lie on a character boundary, or if it is out of
bounds, then this function will panic.
Examples
#![feature(collections)] extern crate collections; fn main() { let mut s = String::from_str("foo"); assert_eq!(s.remove(0), 'f'); assert_eq!(s.remove(1), 'o'); assert_eq!(s.remove(0), 'o'); }let mut s = String::from_str("foo"); assert_eq!(s.remove(0), 'f'); assert_eq!(s.remove(1), 'o'); assert_eq!(s.remove(0), 'o');
fn insert(&mut self, idx: usize, ch: char)
Inserts a character into the string buffer at byte position idx
`idx`.
Warning
This is an O(n) operation as it requires copying every element in the buffer.
Panics
If idx
`idx` does not lie on a character boundary or is out of bounds, then
this function will panic.
unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>
Views the string buffer as a mutable sequence of bytes.
This is unsafe because it does not check to ensure that the resulting string will be valid UTF-8.
Examples
#![feature(collections)] extern crate collections; fn main() { let mut s = String::from_str("hello"); unsafe { let vec = s.as_mut_vec(); assert!(vec == &[104, 101, 108, 108, 111]); vec.reverse(); } assert_eq!(s, "olleh"); }let mut s = String::from_str("hello"); unsafe { let vec = s.as_mut_vec(); assert!(vec == &[104, 101, 108, 108, 111]); vec.reverse(); } assert_eq!(s, "olleh");
fn len(&self) -> usize
Returns the number of bytes in this string.
Examples
fn main() { let a = "foo".to_string(); assert_eq!(a.len(), 3); }let a = "foo".to_string(); assert_eq!(a.len(), 3);
fn is_empty(&self) -> bool
Returns true if the string contains no bytes
Examples
fn main() { let mut v = String::new(); assert!(v.is_empty()); v.push('a'); assert!(!v.is_empty()); }let mut v = String::new(); assert!(v.is_empty()); v.push('a'); assert!(!v.is_empty());
fn clear(&mut self)
Truncates the string, returning it to 0 length.
Examples
fn main() { let mut s = "foo".to_string(); s.clear(); assert!(s.is_empty()); }let mut s = "foo".to_string(); s.clear(); assert!(s.is_empty());
fn drain<R>(&mut self, range: R) -> Drain where R: RangeArgument<usize>
: recently added, matches RFC
Create a draining iterator that removes the specified range in the string and yields the removed chars from start to end. The element range is removed even if the iterator is not consumed until the end.
Panics
Panics if the starting point or end point are not on character boundaries, or if they are out of bounds.
Examples
#![feature(collections_drain)] extern crate collections; fn main() { let mut s = String::from("α is alpha, β is beta"); let beta_offset = s.find('β').unwrap_or(s.len()); // Remove the range up until the β from the string let t: String = s.drain(..beta_offset).collect(); assert_eq!(t, "α is alpha, "); assert_eq!(s, "β is beta"); // A full range clears the string s.drain(..); assert_eq!(s, ""); }let mut s = String::from("α is alpha, β is beta"); let beta_offset = s.find('β').unwrap_or(s.len()); // Remove the range up until the β from the string let t: String = s.drain(..beta_offset).collect(); assert_eq!(t, "α is alpha, "); assert_eq!(s, "β is beta"); // A full range clears the string s.drain(..); assert_eq!(s, "");
Methods from Deref<Target=str>
fn escape_default(&self) -> String
: return type may change to be an iterator
Escapes each char in s
`swith
` with char::escape_default
`char::escape_default`.
fn escape_unicode(&self) -> String
: return type may change to be an iterator
Escapes each char in s
`swith
` with char::escape_unicode
`char::escape_unicode`.
fn replace(&self, from: &str, to: &str) -> String
Replaces all occurrences of one string with another.
replace
`replacetakes two arguments, a sub-
` takes two arguments, a sub-&str
`&strto find in
` to find in self
`self, and a second
`, and a
second &str
`&strto replace it with. If the original
` to
replace it with. If the original &str
`&str` isn't found, no change occurs.
Examples
fn main() { let s = "this is old"; assert_eq!(s.replace("old", "new"), "this is new"); }let s = "this is old"; assert_eq!(s.replace("old", "new"), "this is new");
When a &str
`&str` isn't found:
let s = "this is old"; assert_eq!(s.replace("cookie monster", "little lamb"), s);
fn nfd_chars(&self) -> Decompositions
: use the crates.io unicode-normalization
`unicode-normalization` library instead
Returns an iterator over the string in Unicode Normalization Form D (canonical decomposition).
fn nfkd_chars(&self) -> Decompositions
: use the crates.io unicode-normalization
`unicode-normalization` library instead
Returns an iterator over the string in Unicode Normalization Form KD (compatibility decomposition).
fn nfc_chars(&self) -> Recompositions
: use the crates.io unicode-normalization
`unicode-normalization` library instead
An Iterator over the string in Unicode Normalization Form C (canonical decomposition followed by canonical composition).
fn nfkc_chars(&self) -> Recompositions
: use the crates.io unicode-normalization
`unicode-normalization` library instead
An Iterator over the string in Unicode Normalization Form KC (compatibility decomposition followed by canonical composition).
fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
Returns true
`trueif
` if self
`selfcontains another
` contains another &str
`&str`.
Examples
fn main() { assert!("bananas".contains("nana")); assert!(!"bananas".contains("foobar")); }assert!("bananas".contains("nana")); assert!(!"bananas".contains("foobar"));
fn chars(&self) -> Chars
An iterator over the codepoints of self
`self`.
Examples
fn main() { let v: Vec<char> = "abc åäö".chars().collect(); assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']); }let v: Vec<char> = "abc åäö".chars().collect(); assert_eq!(v, ['a', 'b', 'c', ' ', 'å', 'ä', 'ö']);
fn bytes(&self) -> Bytes
An iterator over the bytes of self
`self`.
Examples
fn main() { let v: Vec<u8> = "bors".bytes().collect(); assert_eq!(v, b"bors".to_vec()); }let v: Vec<u8> = "bors".bytes().collect(); assert_eq!(v, b"bors".to_vec());
fn char_indices(&self) -> CharIndices
An iterator over the characters of self
`self` and their byte offsets.
Examples
fn main() { let v: Vec<(usize, char)> = "abc".char_indices().collect(); let b = vec![(0, 'a'), (1, 'b'), (2, 'c')]; assert_eq!(v, b); }let v: Vec<(usize, char)> = "abc".char_indices().collect(); let b = vec![(0, 'a'), (1, 'b'), (2, 'c')]; assert_eq!(v, b);
fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P>
An iterator over substrings of self
`self`, separated by characters
matched by a pattern.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator will be double ended if the pattern allows a
reverse search and forward/reverse search yields the same elements.
This is true for, eg, char
`charbut not for
` but not
for &str
`&str`.
If the pattern allows a reverse search but its results might differ
from a forward search, rsplit()
`rsplit()` can be used.
Examples
Simple patterns:
fn main() { let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); let v: Vec<&str> = "".split('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); assert_eq!(v, ["lion", "", "tiger", "leopard"]); let v: Vec<&str> = "lion::tiger::leopard".split("::").collect(); assert_eq!(v, ["lion", "tiger", "leopard"]); }let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); let v: Vec<&str> = "".split('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); assert_eq!(v, ["lion", "", "tiger", "leopard"]); let v: Vec<&str> = "lion::tiger::leopard".split("::").collect(); assert_eq!(v, ["lion", "tiger", "leopard"]);
More complex patterns with closures:
fn main() { let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def", "ghi"]); let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect(); assert_eq!(v, ["lion", "tiger", "leopard"]); }let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def", "ghi"]); let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect(); assert_eq!(v, ["lion", "tiger", "leopard"]);
fn rsplit<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplit<'a, P> where P: ReverseSearcher<'a>
An iterator over substrings of self
`self`, separated by characters
matched by a pattern and yielded in reverse order.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.
For iterating from the front, split()
`split()` can be used.
Examples
Simple patterns:
fn main() { let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect(); assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]); let v: Vec<&str> = "".rsplit('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect(); assert_eq!(v, ["leopard", "tiger", "", "lion"]); let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect(); assert_eq!(v, ["leopard", "tiger", "lion"]); }let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect(); assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]); let v: Vec<&str> = "".rsplit('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect(); assert_eq!(v, ["leopard", "tiger", "", "lion"]); let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect(); assert_eq!(v, ["leopard", "tiger", "lion"]);
More complex patterns with closures:
fn main() { let v: Vec<&str> = "abc1def2ghi".rsplit(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "def", "abc"]); let v: Vec<&str> = "lionXtigerXleopard".rsplit(char::is_uppercase).collect(); assert_eq!(v, ["leopard", "tiger", "lion"]); }let v: Vec<&str> = "abc1def2ghi".rsplit(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "def", "abc"]); let v: Vec<&str> = "lionXtigerXleopard".rsplit(char::is_uppercase).collect(); assert_eq!(v, ["leopard", "tiger", "lion"]);
fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P>
An iterator over substrings of self
`self`, separated by characters
matched by a pattern.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns
like regular expressions.
Equivalent to split
`split`, except that the trailing substring
is skipped if empty.
This method can be used for string data that is terminated, rather than separated by a pattern.
Iterator behavior
The returned iterator will be double ended if the pattern allows a
reverse search
and forward/reverse search yields the same elements. This is true
for, eg, char
`charbut not for
` but not for &str
`&str`.
If the pattern allows a reverse search but its results might differ
from a forward search, rsplit_terminator()
`rsplit_terminator()` can be used.
Examples
Simple patterns:
fn main() { let v: Vec<&str> = "A.B.".split_terminator('.').collect(); assert_eq!(v, ["A", "B"]); let v: Vec<&str> = "A..B..".split_terminator(".").collect(); assert_eq!(v, ["A", "", "B", ""]); }let v: Vec<&str> = "A.B.".split_terminator('.').collect(); assert_eq!(v, ["A", "B"]); let v: Vec<&str> = "A..B..".split_terminator(".").collect(); assert_eq!(v, ["A", "", "B", ""]);
More complex patterns with closures:
fn main() { let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def", "ghi"]); }let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def", "ghi"]);
fn rsplit_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: ReverseSearcher<'a>
An iterator over substrings of self
`self`, separated by characters
matched by a pattern and yielded in reverse order.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns like
regular expressions.
Equivalent to split
`split`, except that the trailing substring is
skipped if empty.
This method can be used for string data that is terminated, rather than separated by a pattern.
Iterator behavior
The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.
For iterating from the front, split_terminator()
`split_terminator()` can be used.
Examples
Simple patterns:
fn main() { let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect(); assert_eq!(v, ["B", "A"]); let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect(); assert_eq!(v, ["", "B", "", "A"]); }let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect(); assert_eq!(v, ["B", "A"]); let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect(); assert_eq!(v, ["", "B", "", "A"]);
More complex patterns with closures:
fn main() { let v: Vec<&str> = "abc1def2ghi3".rsplit_terminator(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "def", "abc"]); }let v: Vec<&str> = "abc1def2ghi3".rsplit_terminator(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "def", "abc"]);
fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P>
An iterator over substrings of self
`self, separated by a pattern, restricted to returning at most
`, separated by a pattern,
restricted to returning
at most count
`count` items.
The last element returned, if any, will contain the remainder of the
string.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator will not be double ended, because it is not efficient to support.
If the pattern allows a reverse search, rsplitn()
`rsplitn()` can be used.
Examples
Simple patterns:
fn main() { let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect(); assert_eq!(v, ["Mary", "had", "a little lambda"]); let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect(); assert_eq!(v, ["lion", "", "tigerXleopard"]); let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect(); assert_eq!(v, ["abcXdef"]); let v: Vec<&str> = "".splitn(1, 'X').collect(); assert_eq!(v, [""]); }let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect(); assert_eq!(v, ["Mary", "had", "a little lambda"]); let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect(); assert_eq!(v, ["lion", "", "tigerXleopard"]); let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect(); assert_eq!(v, ["abcXdef"]); let v: Vec<&str> = "".splitn(1, 'X').collect(); assert_eq!(v, [""]);
More complex patterns with closures:
fn main() { let v: Vec<&str> = "abc1def2ghi".splitn(2, |c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def2ghi"]); }let v: Vec<&str> = "abc1def2ghi".splitn(2, |c: char| c.is_numeric()).collect(); assert_eq!(v, ["abc", "def2ghi"]);
fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> where P: ReverseSearcher<'a>
An iterator over substrings of self
`self, separated by a pattern, starting from the end of the string, restricted to returning at most
`, separated by a pattern,
starting from the end of the string, restricted to returning
at most count
`count` items.
The last element returned, if any, will contain the remainder of the string.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator will not be double ended, because it is not efficient to support.
splitn()
`splitn()` can be used for splitting from the front.
Examples
Simple patterns:
fn main() { let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect(); assert_eq!(v, ["lamb", "little", "Mary had a"]); let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect(); assert_eq!(v, ["leopard", "tiger", "lionX"]); let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect(); assert_eq!(v, ["leopard", "lion::tiger"]); }let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect(); assert_eq!(v, ["lamb", "little", "Mary had a"]); let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect(); assert_eq!(v, ["leopard", "tiger", "lionX"]); let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect(); assert_eq!(v, ["leopard", "lion::tiger"]);
More complex patterns with closures:
fn main() { let v: Vec<&str> = "abc1def2ghi".rsplitn(2, |c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "abc1def"]); }let v: Vec<&str> = "abc1def2ghi".rsplitn(2, |c: char| c.is_numeric()).collect(); assert_eq!(v, ["ghi", "abc1def"]);
fn matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> Matches<'a, P>
: method got recently added
An iterator over the matches of a pattern within self
`self`.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator will be double ended if the pattern allows
a reverse search
and forward/reverse search yields the same elements. This is true
for, eg, char
`charbut not for
` but not
for &str
`&str`.
If the pattern allows a reverse search but its results might differ
from a forward search, rmatches()
`rmatches()` can be used.
Examples
#![feature(collections)] extern crate collections; fn main() { let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".matches(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["1", "2", "3"]); }let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".matches(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["1", "2", "3"]);
fn rmatches<'a, P: Pattern<'a>>(&'a self, pat: P) -> RMatches<'a, P> where P: ReverseSearcher<'a>
: method got recently added
An iterator over the matches of a pattern within self
`self`, yielded in
reverse order.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.
For iterating from the front, matches()
`matches()` can be used.
Examples
#![feature(collections)] extern crate collections; fn main() { let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".rmatches(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["3", "2", "1"]); }let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".rmatches(|c: char| c.is_numeric()).collect(); assert_eq!(v, ["3", "2", "1"]);
fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P>
: might have its iterator type changed
An iterator over the start and end indices of the disjoint matches
of a pattern within self
`self`.
For matches of pat
`patwithin
` within self
`self` that overlap, only the indices
corresponding to the first
match are returned.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines
the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator will be double ended if the pattern allows a
reverse search
and forward/reverse search yields the same elements. This is true for,
eg, char
`charbut not for
` but not
for &str
`&str`.
If the pattern allows a reverse search but its results might differ
from a forward search, rmatch_indices()
`rmatch_indices()` can be used.
Examples
#![feature(collections)] extern crate collections; fn main() { let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); assert_eq!(v, [(0, 3), (6, 9), (12, 15)]); let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); assert_eq!(v, [(1, 4), (4, 7)]); let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); assert_eq!(v, [(0, 3)]); // only the first `aba` }let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); assert_eq!(v, [(0, 3), (6, 9), (12, 15)]); let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); assert_eq!(v, [(1, 4), (4, 7)]); let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); assert_eq!(v, [(0, 3)]); // only the first `aba`
fn rmatch_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: ReverseSearcher<'a>
: might have its iterator type changed
An iterator over the start and end indices of the disjoint matches of
a pattern within
self
`self`, yielded in reverse order.
For matches of pat
`patwithin
` within self
`self` that overlap, only the indices
corresponding to the last
match are returned.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines
the split.
Additional libraries might provide more complex patterns like
regular expressions.
Iterator behavior
The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.
For iterating from the front, match_indices()
`match_indices()` can be used.
Examples
#![feature(collections)] extern crate collections; fn main() { let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect(); assert_eq!(v, [(12, 15), (6, 9), (0, 3)]); let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect(); assert_eq!(v, [(4, 7), (1, 4)]); let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect(); assert_eq!(v, [(2, 5)]); // only the last `aba` }let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect(); assert_eq!(v, [(12, 15), (6, 9), (0, 3)]); let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect(); assert_eq!(v, [(4, 7), (1, 4)]); let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect(); assert_eq!(v, [(2, 5)]); // only the last `aba`
fn lines(&self) -> Lines
An iterator over the lines of a string, separated by \n
`\n`.
This does not include the empty string after a trailing \n
`\n`.
Examples
fn main() { let four_lines = "foo\nbar\n\nbaz"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }let four_lines = "foo\nbar\n\nbaz"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]);
Leaving off the trailing character:
fn main() { let four_lines = "foo\nbar\n\nbaz\n"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }let four_lines = "foo\nbar\n\nbaz\n"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]);
fn lines_any(&self) -> LinesAny
An iterator over the lines of a string, separated by either
\n
`\nor
` or \r\n
`\r\n`.
As with .lines()
`.lines()`, this does not include an empty trailing line.
Examples
fn main() { let four_lines = "foo\r\nbar\n\r\nbaz"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }let four_lines = "foo\r\nbar\n\r\nbaz"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]);
Leaving off the trailing character:
fn main() { let four_lines = "foo\r\nbar\n\r\nbaz\n"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }let four_lines = "foo\r\nbar\n\r\nbaz\n"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]);
fn slice_chars(&self, begin: usize, end: usize) -> &str
: may have yet to prove its worth
Returns a slice of the string from the character range [begin
`begin..
`..end
`end`).
That is, start at the begin
`begin-th code point of the string and continue to the
`-th code point of the string and continue
to the end
`end`-th code point. This does not detect or handle edge cases
such as leaving a combining character as the first code point of the
string.
Due to the design of UTF-8, this operation is O(end)
`O(end). See
`. See slice
`slice,
`,
slice_to
`slice_toand
` and slice_from
`slice_fromfor
` for O(1)
`O(1)` variants that use byte indices
rather than code point indices.
Panics
Panics if begin
`begin>
` > end
`endor the either
` or the either begin
`beginor
` or end
`end` are beyond the
last character of the string.
Examples
#![feature(collections)] extern crate collections; fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.slice_chars(0, 4), "Löwe"); assert_eq!(s.slice_chars(5, 7), "老虎"); }let s = "Löwe 老虎 Léopard"; assert_eq!(s.slice_chars(0, 4), "Löwe"); assert_eq!(s.slice_chars(5, 7), "老虎");
unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str
Takes a bytewise slice from a string.
Returns the substring from [begin
`begin..
`..end
`end`).
Unsafety
Caller must check both UTF-8 character boundaries and the boundaries of the entire slice as well.
Examples
fn main() { let s = "Löwe 老虎 Léopard"; unsafe { assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); } }let s = "Löwe 老虎 Léopard"; unsafe { assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); }
fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
Returns true
`trueif the given
` if the given &str
`&str` is a prefix of the string.
Examples
fn main() { assert!("banana".starts_with("ba")); }assert!("banana".starts_with("ba"));
fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool where P: ReverseSearcher<'a>
Returns true if the given &str
`&str` is a suffix of the string.
Examples
fn main() { assert!("banana".ends_with("nana")); }assert!("banana".ends_with("nana"));
fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str where P: DoubleEndedSearcher<'a>
Returns a string with all pre- and suffixes that match a pattern repeatedly removed.
The pattern can be a simple char
`char`, or a closure that determines
the split.
Examples
Simple patterns:
fn main() { assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_matches(x), "foo1bar"); }assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
More complex patterns with closures:
fn main() { assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar"); }assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
Returns a string with all prefixes that match a pattern repeatedly removed.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Examples
Simple patterns:
fn main() { assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12"); }assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
More complex patterns with closures:
fn main() { assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123"); }assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str where P: ReverseSearcher<'a>
Returns a string with all suffixes that match a pattern repeatedly removed.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the split.
Examples
Simple patterns:
fn main() { assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar"); }assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");
More complex patterns with closures:
fn main() { assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar"); }assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
fn is_char_boundary(&self, index: usize) -> bool
: it is unclear whether this method pulls its weight with the existence of the char_indices iterator or this method may want to be replaced with checked slicing
Checks that index
`index`-th byte lies at the start and/or end of a
UTF-8 code point sequence.
The start and end of the string (when index == self.len()
`index == self.len()`) are
considered to be
boundaries.
Panics
Panics if index
`indexis greater than
` is greater than self.len()
`self.len()`.
Examples
#![feature(str_char)] fn main() { let s = "Löwe 老虎 Léopard"; assert!(s.is_char_boundary(0)); // start of `老` assert!(s.is_char_boundary(6)); assert!(s.is_char_boundary(s.len())); // second byte of `ö` assert!(!s.is_char_boundary(2)); // third byte of `老` assert!(!s.is_char_boundary(8)); }let s = "Löwe 老虎 Léopard"; assert!(s.is_char_boundary(0)); // start of `老` assert!(s.is_char_boundary(6)); assert!(s.is_char_boundary(s.len())); // second byte of `ö` assert!(!s.is_char_boundary(2)); // third byte of `老` assert!(!s.is_char_boundary(8));
fn char_range_at(&self, start: usize) -> CharRange
: often replaced by char_indices, this method may be removed in favor of just char_at() or eventually removed altogether
Given a byte position, return the next char and its index.
This can be used to iterate over the Unicode characters of a string.
Panics
If i
`iis greater than or equal to the length of the string. If
` is greater than or equal to the length of the string.
If i
`i` is not the index of the beginning of a valid UTF-8 character.
Examples
This example manually iterates through the characters of a string;
this should normally be
done by .chars()
`.chars()or
` or .char_indices()
`.char_indices()`.
use std::str::CharRange; let s = "中华Việt Nam"; let mut i = 0; while i < s.len() { let CharRange {ch, next} = s.char_range_at(i); println!("{}: {}", i, ch); i = next; }
This outputs:
0: 中
3: 华
6: V
7: i
8: ệ
11: t
12:
13: N
14: a
15: m
fn char_range_at_reverse(&self, start: usize) -> CharRange
: often replaced by char_indices, this method may be removed in favor of just char_at_reverse() or eventually removed altogether
Given a byte position, return the previous char
`char` and its position.
This function can be used to iterate over a Unicode string in reverse.
Returns 0 for next index if called on start index 0.
Panics
If i
`iis greater than the length of the string. If
` is greater than the length of the string.
If i
`i` is not an index following a valid UTF-8 character.
Examples
This example manually iterates through the characters of a string;
this should normally be
done by .chars().rev()
`.chars().rev()or
` or .char_indices()
`.char_indices()`.
use std::str::CharRange; let s = "中华Việt Nam"; let mut i = s.len(); while i > 0 { let CharRange {ch, next} = s.char_range_at_reverse(i); println!("{}: {}", i, ch); i = next; }
This outputs:
16: m
15: a
14: N
13:
12: t
11: ệ
8: i
7: V
6: 华
3: 中
fn char_at(&self, i: usize) -> char
: frequently replaced by the chars() iterator, this method may be removed or possibly renamed in the future; it is normally replaced by chars/char_indices iterators or by getting the first char from a subslice
Given a byte position, return the char
`char` at that position.
Panics
If i
`iis greater than or equal to the length of the string. If
` is greater than or equal to the length of the string.
If i
`i` is not the index of the beginning of a valid UTF-8 character.
Examples
#![feature(str_char)] fn main() { let s = "abπc"; assert_eq!(s.char_at(1), 'b'); assert_eq!(s.char_at(2), 'π'); }let s = "abπc"; assert_eq!(s.char_at(1), 'b'); assert_eq!(s.char_at(2), 'π');
fn char_at_reverse(&self, i: usize) -> char
: see char_at for more details, but reverse semantics are also somewhat unclear, especially with which cases generate panics
Given a byte position, return the char
`char` at that position, counting
from the end.
Panics
If i
`iis greater than the length of the string. If
` is greater than the length of the string.
If i
`i` is not an index following a valid UTF-8 character.
Examples
#![feature(str_char)] fn main() { let s = "abπc"; assert_eq!(s.char_at_reverse(1), 'a'); assert_eq!(s.char_at_reverse(2), 'b'); }let s = "abπc"; assert_eq!(s.char_at_reverse(1), 'a'); assert_eq!(s.char_at_reverse(2), 'b');
fn as_bytes(&self) -> &[u8]
Converts self
`self` to a byte slice.
Examples
fn main() { assert_eq!("bors".as_bytes(), b"bors"); }assert_eq!("bors".as_bytes(), b"bors");
fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>
Returns the byte index of the first character of self
`self` that matches
the pattern, if it
exists.
Returns None
`None` if it doesn't exist.
The pattern can be a simple &str
`&str,
`, char
`char`, or a closure that
determines the
split.
Examples
Simple patterns:
fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.find('L'), Some(0)); assert_eq!(s.find('é'), Some(14)); assert_eq!(s.find("Léopard"), Some(13)); }let s = "Löwe 老虎 Léopard"; assert_eq!(s.find('L'), Some(0)); assert_eq!(s.find('é'), Some(14)); assert_eq!(s.find("Léopard"), Some(13));
More complex patterns with closures:
fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5)); assert_eq!(s.find(char::is_lowercase), Some(1)); }let s = "Löwe 老虎 Léopard"; assert_eq!(s.find(|c: char| c.is_whitespace()), Some(5)); assert_eq!(s.find(char::is_lowercase), Some(1));
Not finding the pattern:
fn main() { let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.find(x), None); }let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.find(x), None);
fn rfind<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize> where P: ReverseSearcher<'a>
Returns the byte index of the last character of self
`self` that
matches the pattern, if it
exists.
Returns None
`None` if it doesn't exist.
The pattern can be a simple &str
`&str,
`, char
`char`,
or a closure that determines the split.
Examples
Simple patterns:
fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind('L'), Some(13)); assert_eq!(s.rfind('é'), Some(14)); }let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind('L'), Some(13)); assert_eq!(s.rfind('é'), Some(14));
More complex patterns with closures:
fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12)); assert_eq!(s.rfind(char::is_lowercase), Some(20)); }let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind(|c: char| c.is_whitespace()), Some(12)); assert_eq!(s.rfind(char::is_lowercase), Some(20));
Not finding the pattern:
fn main() { let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.rfind(x), None); }let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.rfind(x), None);
fn slice_shift_char(&self) -> Option<(char, &str)>
: awaiting conventions about shifting and slices and may not be warranted with the existence of the chars and/or char_indices iterators
Retrieves the first character from a &str
`&str` and returns it.
This does not allocate a new string; instead, it returns a slice that points one character beyond the character that was shifted.
If the slice does not contain any characters, None is returned instead.
Examples
#![feature(str_char)] fn main() { let s = "Löwe 老虎 Léopard"; let (c, s1) = s.slice_shift_char().unwrap(); assert_eq!(c, 'L'); assert_eq!(s1, "öwe 老虎 Léopard"); let (c, s2) = s1.slice_shift_char().unwrap(); assert_eq!(c, 'ö'); assert_eq!(s2, "we 老虎 Léopard"); }let s = "Löwe 老虎 Léopard"; let (c, s1) = s.slice_shift_char().unwrap(); assert_eq!(c, 'L'); assert_eq!(s1, "öwe 老虎 Léopard"); let (c, s2) = s1.slice_shift_char().unwrap(); assert_eq!(c, 'ö'); assert_eq!(s2, "we 老虎 Léopard");
fn subslice_offset(&self, inner: &str) -> usize
: awaiting convention about comparability of arbitrary slices
Returns the byte offset of an inner slice relative to an enclosing outer slice.
Panics
Panics if inner
`inner` is not a direct slice contained within self.
Examples
#![feature(collections)] extern crate collections; fn main() { let string = "a\nb\nc"; let lines: Vec<&str> = string.lines().collect(); assert!(string.subslice_offset(lines[0]) == 0); // &"a" assert!(string.subslice_offset(lines[1]) == 2); // &"b" assert!(string.subslice_offset(lines[2]) == 4); // &"c" }let string = "a\nb\nc"; let lines: Vec<&str> = string.lines().collect(); assert!(string.subslice_offset(lines[0]) == 0); // &"a" assert!(string.subslice_offset(lines[1]) == 2); // &"b" assert!(string.subslice_offset(lines[2]) == 4); // &"c"
fn as_ptr(&self) -> *const u8
Returns an unsafe pointer to the &str
`&str`'s buffer.
The caller must ensure that the string outlives this pointer, and that it is not reallocated (e.g. by pushing to the string).
Examples
fn main() { let s = "Hello"; let p = s.as_ptr(); }let s = "Hello"; let p = s.as_ptr();
fn utf16_units(&self) -> Utf16Units
: this functionality may only be provided by libunicode
Returns an iterator of u16
`u16` over the string encoded as UTF-16.
fn len(&self) -> usize
Returns the length of self
`self` in bytes.
Examples
fn main() { assert_eq!("foo".len(), 3); assert_eq!("ƒoo".len(), 4); // fancy f! }assert_eq!("foo".len(), 3); assert_eq!("ƒoo".len(), 4); // fancy f!
fn is_empty(&self) -> bool
Returns true if this slice has a length of zero bytes.
Examples
fn main() { assert!("".is_empty()); }assert!("".is_empty());
fn parse<F: FromStr>(&self) -> Result<F, F>
Parses self
`self` into the specified type.
Failure
Will return Err
`Errif it's not possible to parse
` if it's not possible to parse self
`self` into the type.
Example
fn main() { assert_eq!("4".parse::<u32>(), Ok(4)); }assert_eq!("4".parse::<u32>(), Ok(4));
Failing:
fn main() { assert!("j".parse::<u32>().is_err()); }assert!("j".parse::<u32>().is_err());
fn graphemes(&self, is_extended: bool) -> Graphemes
: use the crates.io unicode-segmentation
`unicode-segmentation` library instead
Returns an iterator over the grapheme clusters of self
`self`.
If is_extended
`is_extended` is true, the iterator is over the
extended grapheme clusters;
otherwise, the iterator is over the legacy grapheme clusters.
UAX#29
recommends extended grapheme cluster boundaries for general processing.
Examples
#![feature(unicode, core)] fn main() { let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; assert_eq!(&gr1[..], b); let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; assert_eq!(&gr2[..], b); }let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; assert_eq!(&gr1[..], b); let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; assert_eq!(&gr2[..], b);
fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices
: use the crates.io unicode-segmentation
`unicode-segmentation` library instead
Returns an iterator over the grapheme clusters of self
`selfand their byte offsets. See
` and their
byte offsets. See
graphemes()
`graphemes()` for more information.
Examples
#![feature(unicode, core)] fn main() { let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>(); let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; assert_eq!(&gr_inds[..], b); }let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>(); let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; assert_eq!(&gr_inds[..], b);
fn words(&self) -> Words
: words() will be removed. Use split_whitespace() instead
An iterator over the non-empty substrings of self
`self` which contain no whitespace,
and which are separated by any amount of whitespace.
Examples
#![feature(str_words)] fn main() { #![allow(deprecated)] let some_words = " Mary had\ta little \n\t lamb"; let v: Vec<&str> = some_words.words().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); }let some_words = " Mary had\ta little \n\t lamb"; let v: Vec<&str> = some_words.words().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);
fn split_whitespace(&self) -> SplitWhitespace
An iterator over the non-empty substrings of self
`self` which contain no whitespace,
and which are separated by any amount of whitespace.
Examples
fn main() { let some_words = " Mary had\ta little \n\t lamb"; let v: Vec<&str> = some_words.split_whitespace().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); }let some_words = " Mary had\ta little \n\t lamb"; let v: Vec<&str> = some_words.split_whitespace().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);
fn width(&self, is_cjk: bool) -> usize
: use the crates.io unicode-width
`unicode-width` library instead
Returns a string's displayed width in columns.
Control characters have zero width.
is_cjk
`is_cjkdetermines behavior for characters in the Ambiguous category: if
` determines behavior for characters in the Ambiguous category:
if is_cjk
`is_cjkis
` is
true
`true, these are 2 columns wide; otherwise, they are 1. In CJK locales,
`, these are 2 columns wide; otherwise, they are 1.
In CJK locales, is_cjk
`is_cjkshould be
` should be
true
`true, else it should be
`, else it should be false
`false. [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) recommends that these characters be treated as 1 column (i.e.,
`.
Unicode Standard Annex #11
recommends that these
characters be treated as 1 column (i.e., is_cjk = false
`is_cjk = false`) if the
locale is unknown.
fn trim(&self) -> &str
Returns a &str
`&str` with leading and trailing whitespace removed.
Examples
fn main() { let s = " Hello\tworld\t"; assert_eq!(s.trim(), "Hello\tworld"); }let s = " Hello\tworld\t"; assert_eq!(s.trim(), "Hello\tworld");
fn trim_left(&self) -> &str
Returns a &str
`&str` with leading whitespace removed.
Examples
fn main() { let s = " Hello\tworld\t"; assert_eq!(s.trim_left(), "Hello\tworld\t"); }let s = " Hello\tworld\t"; assert_eq!(s.trim_left(), "Hello\tworld\t");
fn trim_right(&self) -> &str
Returns a &str
`&str` with trailing whitespace removed.
Examples
fn main() { let s = " Hello\tworld\t"; assert_eq!(s.trim_right(), " Hello\tworld"); }let s = " Hello\tworld\t"; assert_eq!(s.trim_right(), " Hello\tworld");
fn to_lowercase(&self) -> String
Returns the lowercase equivalent of this string.
Examples
let s = "HELLO"; assert_eq!(s.to_lowercase(), "hello");
fn to_uppercase(&self) -> String
Returns the uppercase equivalent of this string.
Examples
let s = "hello"; assert_eq!(s.to_uppercase(), "HELLO");
Trait Implementations
impl Borrow<str> for String
impl FromIterator<char> for String
fn from_iter<I: IntoIterator<Item=char>>(iter: I) -> String
impl<'a> FromIterator<&'a str> for String
fn from_iter<I: IntoIterator<Item=&'a str>>(iter: I) -> String
impl Extend<char> for String
fn extend<I: IntoIterator<Item=char>>(&mut self, iterable: I)
impl<'a> Extend<&'a str> for String
fn extend<I: IntoIterator<Item=&'a str>>(&mut self, iterable: I)
impl<'a, 'b> Pattern<'a> for &'b String
A convenience impl that delegates to the impl for &str
`&str`