1.0.0fn len(&self) -> usize
+
Returns the length of self.
+
+
This length is in bytes, not chars or graphemes. In other words,
+it may not be what a human considers the length of the string.
+
+
+
Basic usage:
+
+
+let len = "foo".len();
+assert_eq!(3, len);
+
+let len = "ƒoo".len();
+assert_eq!(4, len);
+
+
Returns true if this slice has a length of zero bytes.
+
+
+
Basic usage:
+
+
+let s = "";
+assert!(s.is_empty());
+
+let s = "not empty";
+assert!(!s.is_empty());
+
+
Unstable (str_char): 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-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()) are
+considered to be
+boundaries.
+
+
Returns false if index is greater than self.len().
+
+
+
+#![feature(str_char)]
+
+let s = "Löwe 老虎 Léopard";
+assert!(s.is_char_boundary(0));
+
+assert!(s.is_char_boundary(6));
+assert!(s.is_char_boundary(s.len()));
+
+
+assert!(!s.is_char_boundary(2));
+
+
+assert!(!s.is_char_boundary(8));
+
+
Converts a string slice to a byte slice.
+
+
+
Basic usage:
+
+
+let bytes = "bors".as_bytes();
+assert_eq!(b"bors", bytes);
+
+
Converts a string slice to a raw pointer.
+
+
As string slices are a slice of bytes, the raw pointer points to a
+u8. This pointer will be pointing to the first byte of the string
+slice.
+
+
+
Basic usage:
+
+
+let s = "Hello";
+let ptr = s.as_ptr();
+
+
Creates a string slice from another string slice, bypassing safety
+checks.
+
+
This new slice goes from begin to end, including begin but
+excluding end.
+
+
To get a mutable string slice instead, see the
+slice_mut_unchecked() method.
+
+
+
Callers of this function are responsible that three preconditions are
+satisfied:
+
+
+begin must come before end.begin and end must be byte positions within the string slice.begin and end must lie on UTF-8 sequence boundaries.
+
+
+
Basic usage:
+
+
+let s = "Löwe 老虎 Léopard";
+
+unsafe {
+ assert_eq!("Löwe 老虎 Léopard", s.slice_unchecked(0, 21));
+}
+
+let s = "Hello, world!";
+
+unsafe {
+ assert_eq!("world", s.slice_unchecked(7, 12));
+}
+
+
Creates a string slice from another string slice, bypassing safety
+checks.
+
+
This new slice goes from begin to end, including begin but
+excluding end.
+
+
To get an immutable string slice instead, see the
+slice_unchecked() method.
+
+
+
Callers of this function are responsible that three preconditions are
+satisfied:
+
+
+begin must come before end.begin and end must be byte positions within the string slice.begin and end must lie on UTF-8 sequence boundaries.
+
+
Unstable (str_char): often replaced by char_indices, this method may be removed in favor of just char_at() or eventually removed altogether
+ Given a byte position, returns the next char and its index.
+
+
+
If i is greater than or equal to the length of the string.
+If i is not the index of the beginning of a valid UTF-8 sequence.
+
+
+
This example manually iterates through the code points of a string;
+this should normally be
+done by .chars() or .char_indices().
+
+
+#![feature(str_char)]
+
+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: e
+9:
+11:
+13: t
+14:
+15: N
+16: a
+17: m
+
+
+
Unstable (str_char): 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, returns the previous char and its position.
+
+
Note that Unicode has many features, such as combining marks, ligatures,
+and direction marks, that need to be taken into account to correctly reverse a string.
+
+
Returns 0 for next index if called on start index 0.
+
+
+
If i is greater than the length of the string.
+If i is not an index following a valid UTF-8 sequence.
+
+
+
This example manually iterates through the code points of a string;
+this should normally be
+done by .chars().rev() or .char_indices().
+
+
+#![feature(str_char)]
+
+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:
+
+
18: m
+17: a
+16: N
+15:
+14: t
+13:
+11:
+9: e
+8: i
+7: V
+6: 华
+3: 中
+
+
+
Unstable (str_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, returns the char at that position.
+
+
+
If i is greater than or equal to the length of the string.
+If i is not the index of the beginning of a valid UTF-8 sequence.
+
+
+
+#![feature(str_char)]
+
+let s = "abπc";
+assert_eq!(s.char_at(1), 'b');
+assert_eq!(s.char_at(2), 'π');
+assert_eq!(s.char_at(4), 'c');
+
+
Unstable (str_char): see char_at for more details, but reverse semantics are also somewhat unclear, especially with which cases generate panics
+ Given a byte position, returns the char at that position, counting
+from the end.
+
+
+
If i is greater than the length of the string.
+If i is not an index following a valid UTF-8 sequence.
+
+
+
+#![feature(str_char)]
+
+let s = "abπc";
+assert_eq!(s.char_at_reverse(1), 'a');
+assert_eq!(s.char_at_reverse(2), 'b');
+assert_eq!(s.char_at_reverse(3), 'π');
+
+
Unstable (str_char): 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 char from a &str and returns it.
+
+
Note that a single Unicode character (grapheme cluster)
+can be composed of multiple chars.
+
+
This does not allocate a new string; instead, it returns a slice that
+points one code point beyond the code point that was shifted.
+
+
None is returned if the slice is empty.
+
+
+
+#![feature(str_char)]
+
+let s = "Łódź";
+let (c, s1) = s.slice_shift_char().unwrap();
+
+assert_eq!(c, 'Ł');
+assert_eq!(s1, "ódź");
+
+let (c, s2) = s1.slice_shift_char().unwrap();
+
+assert_eq!(c, 'o');
+assert_eq!(s2, "\u{301}dz\u{301}");
+
+
Divide one string slice into two at an index.
+
+
The argument, mid, should be a byte offset from the start of the
+string. It must also be on the boundary of a UTF-8 code point.
+
+
The two slices returned go from the start of the string slice to mid,
+and from mid to the end of the string slice.
+
+
To get mutable string slices instead, see the split_at_mut()
+method.
+
+
+
Panics if mid is not on a UTF-8 code point boundary, or if it is
+beyond the last code point of the string slice.
+
+
+
Basic usage:
+
+
+let s = "Per Martin-Löf";
+
+let (first, last) = s.split_at(3);
+
+assert_eq!("Per", first);
+assert_eq!(" Martin-Löf", last);
+
+
Divide one mutable string slice into two at an index.
+
+
The argument, mid, should be a byte offset from the start of the
+string. It must also be on the boundary of a UTF-8 code point.
+
+
The two slices returned go from the start of the string slice to mid,
+and from mid to the end of the string slice.
+
+
To get immutable string slices instead, see the split_at() method.
+
+
+
Panics if mid is not on a UTF-8 code point boundary, or if it is
+beyond the last code point of the string slice.
+
+
+
Basic usage:
+
+
+let s = "Per Martin-Löf";
+
+let (first, last) = s.split_at(3);
+
+assert_eq!("Per", first);
+assert_eq!(" Martin-Löf", last);
+
+
Returns an iterator over the chars of a string slice.
+
+
As a string slice consists of valid UTF-8, we can iterate through a
+string slice by char. This method returns such an iterator.
+
+
It's important to remember that char represents a Unicode Scalar
+Value, and may not match your idea of what a 'character' is. Iteration
+over grapheme clusters may be what you actually want.
+
+
+
Basic usage:
+
+
+let word = "goodbye";
+
+let count = word.chars().count();
+assert_eq!(7, count);
+
+let mut chars = word.chars();
+
+assert_eq!(Some('g'), chars.next());
+assert_eq!(Some('o'), chars.next());
+assert_eq!(Some('o'), chars.next());
+assert_eq!(Some('d'), chars.next());
+assert_eq!(Some('b'), chars.next());
+assert_eq!(Some('y'), chars.next());
+assert_eq!(Some('e'), chars.next());
+
+assert_eq!(None, chars.next());
+
+
Remember, chars may not match your human intuition about characters:
+
+
+let y = "y̆";
+
+let mut chars = y.chars();
+
+assert_eq!(Some('y'), chars.next());
+assert_eq!(Some('\u{0306}'), chars.next());
+
+assert_eq!(None, chars.next());
+
+
Returns an iterator over the chars of a string slice, and their
+positions.
+
+
As a string slice consists of valid UTF-8, we can iterate through a
+string slice by char. This method returns an iterator of both
+these chars, as well as their byte positions.
+
+
The iterator yields tuples. The position is first, the char is
+second.
+
+
+
Basic usage:
+
+
+let word = "goodbye";
+
+let count = word.char_indices().count();
+assert_eq!(7, count);
+
+let mut char_indices = word.char_indices();
+
+assert_eq!(Some((0, 'g')), char_indices.next());
+assert_eq!(Some((1, 'o')), char_indices.next());
+assert_eq!(Some((2, 'o')), char_indices.next());
+assert_eq!(Some((3, 'd')), char_indices.next());
+assert_eq!(Some((4, 'b')), char_indices.next());
+assert_eq!(Some((5, 'y')), char_indices.next());
+assert_eq!(Some((6, 'e')), char_indices.next());
+
+assert_eq!(None, char_indices.next());
+
+
Remember, chars may not match your human intuition about characters:
+
+
+let y = "y̆";
+
+let mut char_indices = y.char_indices();
+
+assert_eq!(Some((0, 'y')), char_indices.next());
+assert_eq!(Some((1, '\u{0306}')), char_indices.next());
+
+assert_eq!(None, char_indices.next());
+
+
An iterator over the bytes of a string slice.
+
+
As a string slice consists of a sequence of bytes, we can iterate
+through a string slice by byte. This method returns such an iterator.
+
+
+
Basic usage:
+
+
+let mut bytes = "bors".bytes();
+
+assert_eq!(Some(b'b'), bytes.next());
+assert_eq!(Some(b'o'), bytes.next());
+assert_eq!(Some(b'r'), bytes.next());
+assert_eq!(Some(b's'), bytes.next());
+
+assert_eq!(None, bytes.next());
+
+
Split a string slice by whitespace.
+
+
The iterator returned will return string slices that are sub-slices of
+the original string slice, separated by any amount of whitespace.
+
+
'Whitespace' is defined according to the terms of the Unicode Derived
+Core Property White_Space.
+
+
+
Basic usage:
+
+
+let mut iter = "A few words".split_whitespace();
+
+assert_eq!(Some("A"), iter.next());
+assert_eq!(Some("few"), iter.next());
+assert_eq!(Some("words"), iter.next());
+
+assert_eq!(None, iter.next());
+
+
All kinds of whitespace are considered:
+
+
+let mut iter = " Mary had\ta\u{2009}little \n\t lamb".split_whitespace();
+assert_eq!(Some("Mary"), iter.next());
+assert_eq!(Some("had"), iter.next());
+assert_eq!(Some("a"), iter.next());
+assert_eq!(Some("little"), iter.next());
+assert_eq!(Some("lamb"), iter.next());
+
+assert_eq!(None, iter.next());
+
+
An iterator over the lines of a string, as string slices.
+
+
Lines are ended with either a newline (\n) or a carriage return with
+a line feed (\r\n).
+
+
The final line ending is optional.
+
+
+
Basic usage:
+
+
+let text = "foo\r\nbar\n\nbaz\n";
+let mut lines = text.lines();
+
+assert_eq!(Some("foo"), lines.next());
+assert_eq!(Some("bar"), lines.next());
+assert_eq!(Some(""), lines.next());
+assert_eq!(Some("baz"), lines.next());
+
+assert_eq!(None, lines.next());
+
+
The final line ending isn't required:
+
+
+let text = "foo\nbar\n\r\nbaz";
+let mut lines = text.lines();
+
+assert_eq!(Some("foo"), lines.next());
+assert_eq!(Some("bar"), lines.next());
+assert_eq!(Some(""), lines.next());
+assert_eq!(Some("baz"), lines.next());
+
+assert_eq!(None, lines.next());
+
+
Deprecated since 1.4.0: use lines() instead now
+ An iterator over the lines of a string.
+
+
Deprecated since 1.8.0: renamed to encode_utf16
+ Returns an iterator of u16 over the string encoded as UTF-16.
+
+
Returns an iterator of u16 over the string encoded as UTF-16.
+
1.0.0fn contains<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>
+
Returns true if the given pattern matches a sub-slice of
+this string slice.
+
+
Returns false if it does not.
+
+
+
Basic usage:
+
+
+let bananas = "bananas";
+
+assert!(bananas.contains("nana"));
+assert!(!bananas.contains("apples"));
+
1.0.0fn starts_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>
+
Returns true if the given pattern matches a prefix of this
+string slice.
+
+
Returns false if it does not.
+
+
+
Basic usage:
+
+
+let bananas = "bananas";
+
+assert!(bananas.starts_with("bana"));
+assert!(!bananas.starts_with("nana"));
+
+
Returns true if the given pattern matches a suffix of this
+string slice.
+
+
Returns false if it does not.
+
+
+
Basic usage:
+
+
+let bananas = "bananas";
+
+assert!(bananas.ends_with("anas"));
+assert!(!bananas.ends_with("nana"));
+
1.0.0fn find<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>
+
Returns the byte index of the first character of this string slice that
+matches the pattern.
+
+
Returns None if the pattern doesn't match.
+
+
The pattern can be a &str, char, or a closure that determines if
+a character matches.
+
+
+
Simple patterns:
+
+
+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:
+
+
+let s = "Löwe 老虎 Léopard";
+
+assert_eq!(s.find(char::is_whitespace), Some(5));
+assert_eq!(s.find(char::is_lowercase), Some(1));
+
+
Not finding the pattern:
+
+
+let s = "Löwe 老虎 Léopard";
+let x: &[_] = &['1', '2'];
+
+assert_eq!(s.find(x), None);
+
+
Returns the byte index of the last character of this string slice that
+matches the pattern.
+
+
Returns None if the pattern doesn't match.
+
+
The pattern can be a &str, char, or a closure that determines if
+a character matches.
+
+
+
Simple patterns:
+
+
+let s = "Löwe 老虎 Léopard";
+
+assert_eq!(s.rfind('L'), Some(13));
+assert_eq!(s.rfind('é'), Some(14));
+
+
More complex patterns with closures:
+
+
+let s = "Löwe 老虎 Léopard";
+
+assert_eq!(s.rfind(char::is_whitespace), Some(12));
+assert_eq!(s.rfind(char::is_lowercase), Some(20));
+
+
Not finding the pattern:
+
+
+let s = "Löwe 老虎 Léopard";
+let x: &[_] = &['1', '2'];
+
+assert_eq!(s.rfind(x), None);
+
1.0.0fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>
+
An iterator over substrings of this string slice, separated by
+characters matched by a pattern.
+
+
The pattern can be a &str, char, or a closure that determines the
+split.
+
+
+
The returned iterator will be a DoubleEndedIterator if the pattern
+allows a reverse search and forward/reverse search yields the same
+elements. This is true for, eg, char but not for &str.
+
+
If the pattern allows a reverse search but its results might differ
+from a forward search, the rsplit() method can be used.
+
+
+
Simple patterns:
+
+
+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> = "abc1def2ghi".split(char::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"]);
+
+
A more complex pattern, using a closure:
+
+
+let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
+assert_eq!(v, ["abc", "def", "ghi"]);
+
+
If a string contains multiple contiguous separators, you will end up
+with empty strings in the output:
+
+
+let x = "||||a||b|c".to_string();
+let d: Vec<_> = x.split('|').collect();
+
+assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
+
+
This can lead to possibly surprising behavior when whitespace is used
+as the separator. This code is correct:
+
+
+let x = " a b c".to_string();
+let d: Vec<_> = x.split(' ').collect();
+
+assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
+
+
It does not give you:
+
+
+assert_eq!(d, &["a", "b", "c"]);
+
+
Use split_whitespace() for this behavior.
+
+
An iterator over substrings of the given string slice, separated by
+characters matched by a pattern and yielded in reverse order.
+
+
The pattern can be a &str, char, or a closure that determines the
+split.
+
+
+
The returned iterator requires that the pattern supports a reverse
+search, and it will be a DoubleEndedIterator if a forward/reverse
+search yields the same elements.
+
+
For iterating from the front, the split() method can be used.
+
+
+
Simple patterns:
+
+
+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"]);
+
+
A more complex pattern, using a closure:
+
+
+let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
+assert_eq!(v, ["ghi", "def", "abc"]);
+
+
An iterator over substrings of the given string slice, separated by
+characters matched by a pattern.
+
+
The pattern can be a &str, char, or a closure that determines the
+split.
+
+
Equivalent to 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.
+
+
+
The returned iterator will be a DoubleEndedIterator if the pattern
+allows a reverse search and forward/reverse search yields the same
+elements. This is true for, eg, char but not for &str.
+
+
If the pattern allows a reverse search but its results might differ
+from a forward search, the rsplit_terminator() method can be used.
+
+
+
Basic usage:
+
+
+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", ""]);
+
+
An iterator over substrings of self, separated by characters
+matched by a pattern and yielded in reverse order.
+
+
The pattern can be a simple &str, char, or a closure that
+determines the split.
+Additional libraries might provide more complex patterns like
+regular expressions.
+
+
Equivalent to 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.
+
+
+
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, the split_terminator() method can be
+used.
+
+
+
+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"]);
+
1.0.0fn splitn<'a, P>(&'a self, count: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>
+
An iterator over substrings of the given string slice, separated by a
+pattern, restricted to returning at most count items.
+
+
The last element returned, if any, will contain the remainder of the
+string slice.
+
+
The pattern can be a &str, char, or a closure that determines the
+split.
+
+
+
The returned iterator will not be double ended, because it is
+not efficient to support.
+
+
If the pattern allows a reverse search, the rsplitn() method can be
+used.
+
+
+
Simple patterns:
+
+
+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, [""]);
+
+
A more complex pattern, using a closure:
+
+
+let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
+assert_eq!(v, ["abc", "defXghi"]);
+
+
An iterator over substrings of this string slice, separated by a
+pattern, starting from the end of the string, restricted to returning
+at most count items.
+
+
The last element returned, if any, will contain the remainder of the
+string slice.
+
+
The pattern can be a &str, char, or a closure that
+determines the split.
+
+
+
The returned iterator will not be double ended, because it is not
+efficient to support.
+
+
For splitting from the front, the splitn() method can be used.
+
+
+
Simple patterns:
+
+
+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"]);
+
+
A more complex pattern, using a closure:
+
+
+let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
+assert_eq!(v, ["ghi", "abc1def"]);
+
1.2.0fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>
+
An iterator over the matches of a pattern within the given string
+slice.
+
+
The pattern can be a &str, char, or a closure that
+determines if a character matches.
+
+
+
The returned iterator will be a DoubleEndedIterator if the pattern
+allows a reverse search and forward/reverse search yields the same
+elements. This is true for, eg, char but not for &str.
+
+
If the pattern allows a reverse search but its results might differ
+from a forward search, the rmatches() method can be used.
+
+
+
Basic usage:
+
+
+let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
+assert_eq!(v, ["abc", "abc", "abc"]);
+
+let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
+assert_eq!(v, ["1", "2", "3"]);
+
+
An iterator over the matches of a pattern within this string slice,
+yielded in reverse order.
+
+
The pattern can be a &str, char, or a closure that determines if
+a character matches.
+
+
+
The returned iterator requires that the pattern supports a reverse
+search, and it will be a DoubleEndedIterator if a forward/reverse
+search yields the same elements.
+
+
For iterating from the front, the matches() method can be used.
+
+
+
Basic usage:
+
+
+let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
+assert_eq!(v, ["abc", "abc", "abc"]);
+
+let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
+assert_eq!(v, ["3", "2", "1"]);
+
+
An iterator over the disjoint matches of a pattern within this string
+slice as well as the index that the match starts at.
+
+
For matches of pat within self that overlap, only the indices
+corresponding to the first match are returned.
+
+
The pattern can be a &str, char, or a closure that determines
+if a character matches.
+
+
+
The returned iterator will be a DoubleEndedIterator if the pattern
+allows a reverse search and forward/reverse search yields the same
+elements. This is true for, eg, char but not for &str.
+
+
If the pattern allows a reverse search but its results might differ
+from a forward search, the rmatch_indices() method can be used.
+
+
+
Basic usage:
+
+
+let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
+assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
+
+let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
+assert_eq!(v, [(1, "abc"), (4, "abc")]);
+
+let v: Vec<_> = "ababa".match_indices("aba").collect();
+assert_eq!(v, [(0, "aba")]);
+
+
An iterator over the disjoint matches of a pattern within self,
+yielded in reverse order along with the index of the match.
+
+
For matches of pat within self that overlap, only the indices
+corresponding to the last match are returned.
+
+
The pattern can be a &str, char, or a closure that determines if a
+character matches.
+
+
+
The returned iterator requires that the pattern supports a reverse
+search, and it will be a DoubleEndedIterator if a forward/reverse
+search yields the same elements.
+
+
For iterating from the front, the match_indices() method can be used.
+
+
+
Basic usage:
+
+
+let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
+assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
+
+let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
+assert_eq!(v, [(4, "abc"), (1, "abc")]);
+
+let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
+assert_eq!(v, [(2, "aba")]);
+
1.0.0fn trim(&self) -> &str
+
Returns a string slice with leading and trailing whitespace removed.
+
+
'Whitespace' is defined according to the terms of the Unicode Derived
+Core Property White_Space.
+
+
+
Basic usage:
+
+
+let s = " Hello\tworld\t";
+
+assert_eq!("Hello\tworld", s.trim());
+
+
Returns a string slice with leading whitespace removed.
+
+
'Whitespace' is defined according to the terms of the Unicode Derived
+Core Property White_Space.
+
+
+
A string is a sequence of bytes. 'Left' in this context means the first
+position of that byte string; for a language like Arabic or Hebrew
+which are 'right to left' rather than 'left to right', this will be
+the right side, not the left.
+
+
+
Basic usage:
+
+
+let s = " Hello\tworld\t";
+
+assert_eq!("Hello\tworld\t", s.trim_left());
+
+
Directionality:
+
+
+let s = " English";
+assert!(Some('E') == s.trim_left().chars().next());
+
+let s = " עברית";
+assert!(Some('ע') == s.trim_left().chars().next());
+
+
Returns a string slice with trailing whitespace removed.
+
+
'Whitespace' is defined according to the terms of the Unicode Derived
+Core Property White_Space.
+
+
+
A string is a sequence of bytes. 'Right' in this context means the last
+position of that byte string; for a language like Arabic or Hebrew
+which are 'right to left' rather than 'left to right', this will be
+the left side, not the right.
+
+
+
Basic usage:
+
+
+let s = " Hello\tworld\t";
+
+assert_eq!(" Hello\tworld", s.trim_right());
+
+
Directionality:
+
+
+let s = "English ";
+assert!(Some('h') == s.trim_right().chars().rev().next());
+
+let s = "עברית ";
+assert!(Some('ת') == s.trim_right().chars().rev().next());
+
+
Returns a string slice with all prefixes and suffixes that match a
+pattern repeatedly removed.
+
+
The pattern can be a &str, char, or a closure that determines
+if a character matches.
+
+
+
Simple patterns:
+
+
+assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
+assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");
+
+let x: &[_] = &['1', '2'];
+assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
+
+
A more complex pattern, using a closure:
+
+
+assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
+
1.0.0fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>
+
Returns a string slice with all prefixes that match a pattern
+repeatedly removed.
+
+
The pattern can be a &str, char, or a closure that determines if
+a character matches.
+
+
+
A string is a sequence of bytes. 'Left' in this context means the first
+position of that byte string; for a language like Arabic or Hebrew
+which are 'right to left' rather than 'left to right', this will be
+the right side, not the left.
+
+
+
Basic usage:
+
+
+assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
+assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");
+
+let x: &[_] = &['1', '2'];
+assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
+
+
Returns a string slice with all suffixes that match a pattern
+repeatedly removed.
+
+
The pattern can be a &str, char, or a closure that
+determines if a character matches.
+
+
+
A string is a sequence of bytes. 'Right' in this context means the last
+position of that byte string; for a language like Arabic or Hebrew
+which are 'right to left' rather than 'left to right', this will be
+the left side, not the right.
+
+
+
Simple patterns:
+
+
+assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
+assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");
+
+let x: &[_] = &['1', '2'];
+assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");
+
+
A more complex pattern, using a closure:
+
+
+assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX");
+
+
Parses this string slice into another type.
+
+
Because parse() is so general, it can cause problems with type
+inference. As such, parse() is one of the few times you'll see
+the syntax affectionately known as the 'turbofish': ::<>. This
+helps the inference algorithm understand specifically which type
+you're trying to parse into.
+
+
parse() can parse any type that implements the FromStr trait.
+
+
+
Will return Err if it's not possible to parse this string slice into
+the desired type.
+
+
+
Basic usage
+
+
+let four: u32 = "4".parse().unwrap();
+
+assert_eq!(4, four);
+
+
Using the 'turbofish' instead of annotating four:
+
+
+let four = "4".parse::<u32>();
+
+assert_eq!(Ok(4), four);
+
+
Failing to parse:
+
+
+let nope = "j".parse::<u32>();
+
+assert!(nope.is_err());
+
1.0.0fn replace<'a, P>(&'a self, from: P, to: &str) -> String where P: Pattern<'a>
+
Replaces all matches of a pattern with another string.
+
+
replace creates a new String, and copies the data from this string slice into it.
+While doing so, it attempts to find matches of a pattern. If it finds any, it
+replaces them with the replacement string slice.
+
+
+
Basic usage:
+
+
+let s = "this is old";
+
+assert_eq!("this is new", s.replace("old", "new"));
+
+
When the pattern doesn't match:
+
+
+let s = "this is old";
+assert_eq!(s, s.replace("cookie monster", "little lamb"));
+
+
Returns the lowercase equivalent of this string slice, as a new String.
+
+
'Lowercase' is defined according to the terms of the Unicode Derived Core Property
+Lowercase.
+
+
+
Basic usage:
+
+
+let s = "HELLO";
+
+assert_eq!("hello", s.to_lowercase());
+
+
A tricky example, with sigma:
+
+
+let sigma = "Σ";
+
+assert_eq!("σ", sigma.to_lowercase());
+
+
+let odysseus = "ὈΔΥΣΣΕΎΣ";
+
+assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());
+
+
Languages without case are not changed:
+
+
+let new_year = "农历新年";
+
+assert_eq!(new_year, new_year.to_lowercase());
+
+
Returns the uppercase equivalent of this string slice, as a new String.
+
+
'Uppercase' is defined according to the terms of the Unicode Derived Core Property
+Uppercase.
+
+
+
Basic usage:
+
+
+let s = "hello";
+
+assert_eq!("HELLO", s.to_uppercase());
+
+
Scripts without case are not changed:
+
+
+let new_year = "农历新年";
+
+assert_eq!(new_year, new_year.to_uppercase());
+
+
Unstable (str_escape): return type may change to be an iterator
+ Escapes each char in s with char::escape_default.
+
+
Unstable (str_escape): return type may change to be an iterator
+ Escapes each char in s with char::escape_unicode.
+
+
Converts a Box<str> into a String without copying or allocating.
+
+
+
Basic usage:
+
+
+let string = String::from("birthday gift");
+let boxed_str = string.clone().into_boxed_str();
+
+assert_eq!(boxed_str.into_string(), string);
+
