Primitive Type str [−]
Unicode string slices.
Rust's str
type is one of the core primitive types of the language. &str
is the borrowed string type. This type of string can only be created from
other strings, unless it is a &'static str
(see below). It is not possible
to move out of borrowed strings because they are owned elsewhere.
Examples
Here's some code that uses a &str
:
let s = "Hello, world.";
This &str
is a &'static str
, which is the type of string literals.
They're 'static
because literals are available for the entire lifetime of
the program.
You can get a non-'static
&str
by taking a slice of a String
:
let some_string = "Hello, world.".to_string(); let s = &some_string;
Representation
Rust's string type, str
, is a sequence of Unicode scalar values encoded as
a stream of UTF-8 bytes. All strings are
guaranteed to be validly encoded UTF-8 sequences. Additionally, strings are
not null-terminated and can thus contain null bytes.
The actual representation of str
s have direct mappings to slices: &str
is the same as &[u8]
.
Methods
impl str
Any string that can be represented as a slice.
fn len(&self) -> usize
Returns the length of 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 is_char_boundary(&self, index: usize) -> bool
str_char
#27754): 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()
.
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)); }#![feature(str_char)] 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 as_bytes(&self) -> &[u8]
Converts self
to a byte slice.
Examples
fn main() { assert_eq!("bors".as_bytes(), b"bors"); }assert_eq!("bors".as_bytes(), b"bors");
fn as_ptr(&self) -> *const u8
Returns a raw pointer to the &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();
unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str
Takes a bytewise slice from a string.
Returns the substring from [begin
..end
).
Unsafety
Caller must check both UTF-8 sequence 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"); }
unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut str
Takes a bytewise mutable slice from a string.
Same as slice_unchecked
, but works with &mut str
instead of &str
.
fn char_range_at(&self, start: usize) -> CharRange
str_char
#27754): 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 code point and its index.
This can be used to iterate over the Unicode code points of a string.
Panics
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.
Examples
This example manually iterates through the code points of a string;
this should normally be
done by .chars()
or .char_indices()
.
#![feature(str_char, core)] 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
fn char_range_at_reverse(&self, start: usize) -> CharRange
str_char
#27754): 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
and its position.
This function can be used to iterate over a Unicode code points in reverse.
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.
Panics
If i
is greater than the length of the string.
If i
is not an index following a valid UTF-8 sequence.
Examples
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, core)] 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: 中
fn char_at(&self, i: usize) -> char
str_char
#27754): 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
at that position.
Panics
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.
Examples
#![feature(str_char)] fn main() { let s = "abπc"; assert_eq!(s.char_at(1), 'b'); assert_eq!(s.char_at(2), 'π'); assert_eq!(s.char_at(4), 'c'); }#![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');
fn char_at_reverse(&self, i: usize) -> char
str_char
#27754): 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
at that position, counting
from the end.
Panics
If i
is greater than the length of the string.
If i
is not an index following a valid UTF-8 sequence.
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'); assert_eq!(s.char_at_reverse(3), 'π'); }#![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), 'π');
fn slice_shift_char(&self) -> Option<(char, &str)>
str_char
#27754): 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 code point from a &str
and returns it.
Note that a single Unicode character (grapheme cluster)
can be composed of multiple char
s.
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.
Examples
#![feature(str_char)] fn main() { let s = "Łódź"; // \u{141}o\u{301}dz\u{301} 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}"); }#![feature(str_char)] let s = "Łódź"; // \u{141}o\u{301}dz\u{301} 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}");
fn split_at(&self, mid: usize) -> (&str, &str)
Divide one string slice into two at an index.
The index mid
is a byte offset from the start of the string
that must be on a char
boundary.
Return slices &self[..mid]
and &self[mid..]
.
Panics
Panics if mid
is beyond the last code point of the string,
or if it is not on a char
boundary.
Examples
#![feature(str_split_at)] fn main() { let s = "Löwe 老虎 Léopard"; let first_space = s.find(' ').unwrap_or(s.len()); let (a, b) = s.split_at(first_space); assert_eq!(a, "Löwe"); assert_eq!(b, " 老虎 Léopard"); }#![feature(str_split_at)] let s = "Löwe 老虎 Léopard"; let first_space = s.find(' ').unwrap_or(s.len()); let (a, b) = s.split_at(first_space); assert_eq!(a, "Löwe"); assert_eq!(b, " 老虎 Léopard");
fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)
Divide one mutable string slice into two at an index.
fn chars(&self) -> Chars
An iterator over the code points of self
.
In Unicode relationship between code points and characters is complex. A single character may be composed of multiple code points (e.g. diacritical marks added to a letter), and a single code point (e.g. Hangul syllable) may contain multiple characters.
For iteration over human-readable characters a grapheme cluster iterator may be more appropriate. See the unicode-segmentation crate.
Examples
fn main() { let v: Vec<char> = "ASCII żółć 🇨🇭 한".chars().collect(); assert_eq!(v, ['A', 'S', 'C', 'I', 'I', ' ', 'z', '\u{307}', 'o', '\u{301}', 'ł', 'c', '\u{301}', ' ', '\u{1f1e8}', '\u{1f1ed}', ' ', '한']); }let v: Vec<char> = "ASCII żółć 🇨🇭 한".chars().collect(); assert_eq!(v, ['A', 'S', 'C', 'I', 'I', ' ', 'z', '\u{307}', 'o', '\u{301}', 'ł', 'c', '\u{301}', ' ', '\u{1f1e8}', '\u{1f1ed}', ' ', '한']);
fn char_indices(&self) -> CharIndices
An iterator over the char
s of self
and their byte offsets.
Examples
fn main() { let v: Vec<(usize, char)> = "A🇨🇭".char_indices().collect(); let b = vec![(0, 'A'), (1, '\u{1f1e8}'), (5, '\u{1f1ed}')]; assert_eq!(v, b); }let v: Vec<(usize, char)> = "A🇨🇭".char_indices().collect(); let b = vec![(0, 'A'), (1, '\u{1f1e8}'), (5, '\u{1f1ed}')]; assert_eq!(v, b);
fn bytes(&self) -> Bytes
An iterator over the bytes of 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 split_whitespace(&self) -> SplitWhitespace
An iterator over the non-empty substrings of self
which contain no whitespace,
and which are separated by any amount of whitespace.
Examples
fn main() { let some_words = " Mary had\ta\u{2009}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\u{2009}little \n\t lamb"; let v: Vec<&str> = some_words.split_whitespace().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);
fn lines(&self) -> Lines
An iterator over the lines of a string, separated by \n
.
This does not include the empty string after a trailing \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
or \r\n
.
As with .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 utf16_units(&self) -> Utf16Units
Returns an iterator of u16
over the string encoded as UTF-16.
fn contains<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>
Returns true
if self
contains another &str
.
Examples
fn main() { assert!("bananas".contains("nana")); assert!(!"bananas".contains("foobar")); }assert!("bananas".contains("nana")); assert!(!"bananas".contains("foobar"));
fn starts_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>
Returns true
if the given &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>(&'a self, pat: P) -> bool where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
Returns true if the given &str
is a suffix of the string.
Examples
fn main() { assert!("banana".ends_with("nana")); }assert!("banana".ends_with("nana"));
fn find<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>
Returns the byte index of the first character of self
that matches
the pattern, if it
exists.
Returns None
if it doesn't exist.
The pattern can be a simple &str
, 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(char::is_whitespace), Some(5)); assert_eq!(s.find(char::is_lowercase), Some(1)); }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:
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>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
Returns the byte index of the last character of self
that
matches the pattern, if it
exists.
Returns None
if it doesn't exist.
The pattern can be a simple &str
, 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(char::is_whitespace), Some(12)); assert_eq!(s.rfind(char::is_lowercase), Some(20)); }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:
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 split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>
An iterator over substrings of self
, separated by characters
matched by a pattern.
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.
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
but not
for &str
.
If the pattern allows a reverse search but its results might differ
from a forward search, 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> = "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"]); }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:
fn main() { let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect(); assert_eq!(v, ["abc", "def", "ghi"]); }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:
fn main() { let x = "||||a||b|c".to_string(); let d: Vec<_> = x.split('|').collect(); assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); }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:
fn main() { let x = " a b c".to_string(); let d: Vec<_> = x.split(' ').collect(); assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); }let x = " a b c".to_string(); let d: Vec<_> = x.split(' ').collect(); assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
It does not give you:
fn main() { assert_eq!(d, &["a", "b", "c"]); }assert_eq!(d, &["a", "b", "c"]);
fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
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.
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()
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"]);
A more complex pattern, using a closure:
fn main() { let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect(); assert_eq!(v, ["ghi", "def", "abc"]); }let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect(); assert_eq!(v, ["ghi", "def", "abc"]);
fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where P: Pattern<'a>
An iterator over substrings of self
, separated by characters
matched by a pattern.
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.
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
but not for &str
.
If the pattern allows a reverse search but its results might differ
from a forward search, rsplit_terminator()
can be used.
Examples
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", ""]);
fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
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.
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()
can be used.
Examples
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"]);
fn splitn<'a, P>(&'a self, count: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>
An iterator over substrings of self
, separated by a pattern,
restricted to returning
at most count
items.
The last element returned, if any, will contain the remainder of the
string.
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.
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()
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, [""]);
A more complex pattern, using a closure:
fn main() { let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect(); assert_eq!(v, ["abc", "defXghi"]); }let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect(); assert_eq!(v, ["abc", "defXghi"]);
fn rsplitn<'a, P>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
An iterator over substrings of self
, 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.
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.
Iterator behavior
The returned iterator will not be double ended, because it is not efficient to support.
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"]);
A more complex pattern, using a closure:
fn main() { let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect(); assert_eq!(v, ["ghi", "abc1def"]); }let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect(); assert_eq!(v, ["ghi", "abc1def"]);
fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>
An iterator over the matches of a pattern within self
.
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.
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
but not
for &str
.
If the pattern allows a reverse search but its results might differ
from a forward search, rmatches()
can be used.
Examples
fn main() { 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"]); }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"]);
fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
An iterator over the matches of a pattern within self
, 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.
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()
can be used.
Examples
fn main() { 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"]); }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"]);
fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where P: Pattern<'a>
An iterator over the start and end indices of the disjoint matches
of a pattern within self
.
For matches of pat
within self
that overlap, only the indices
corresponding to the first
match are returned.
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.
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
but not
for &str
.
If the pattern allows a reverse search but its results might differ
from a forward search, rmatch_indices()
can be used.
Examples
#![feature(str_match_indices)] 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` }#![feature(str_match_indices)] 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>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
An iterator over the start and end indices of the disjoint matches of
a pattern within
self
, yielded in reverse order.
For matches of pat
within self
that overlap, only the indices
corresponding to the last
match are returned.
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.
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()
can be used.
Examples
#![feature(str_match_indices)] 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` }#![feature(str_match_indices)] 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 trim(&self) -> &str
Returns a &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
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
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 trim_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: DoubleEndedSearcher<'a>
Returns a string with all pre- and suffixes that match a pattern repeatedly removed.
The pattern can be a simple char
, or a closure that determines
the split.
Examples
Simple patterns:
fn main() { 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"); }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:
fn main() { assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar"); }assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>
Returns a string with all prefixes that match a pattern repeatedly removed.
The pattern can be a simple &str
, char
, or a closure that
determines the split.
Examples
fn main() { 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"); }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");
fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>
Returns a string with all suffixes that match a pattern repeatedly removed.
The pattern can be a simple &str
, char
, or a closure that
determines the split.
Examples
Simple patterns:
fn main() { 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"); }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:
fn main() { assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX"); }assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX");
fn parse<F>(&self) -> Result<F, F::Err> where F: FromStr
Parses self
into the specified type.
Failure
Will return Err
if it's not possible to parse 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 replace(&self, from: &str, to: &str) -> String
Replaces all occurrences of one string with another.
replace
takes two arguments, a sub-&str
to find in self
, and a
second &str
to
replace it with. If the original &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
isn't found:
let s = "this is old"; assert_eq!(s.replace("cookie monster", "little lamb"), s);
fn to_lowercase(&self) -> String
Returns the lowercase equivalent of this string.
Examples
fn main() { let s = "HELLO"; assert_eq!(s.to_lowercase(), "hello"); }let s = "HELLO"; assert_eq!(s.to_lowercase(), "hello");
fn to_uppercase(&self) -> String
Returns the uppercase equivalent of this string.
Examples
fn main() { let s = "hello"; assert_eq!(s.to_uppercase(), "HELLO"); }let s = "hello"; assert_eq!(s.to_uppercase(), "HELLO");
fn escape_default(&self) -> String
Escapes each char in s
with char::escape_default
.
fn escape_unicode(&self) -> String
Escapes each char in s
with char::escape_unicode
.
fn into_string(self: Box<str>) -> String
Converts the Box<str>
into a String
without copying or allocating.
Trait Implementations
impl AsRef<str> for str
impl Repr<Slice<u8>> for str
fn repr(&self) -> T
impl<'a, 'b> Pattern<'a> for &'b str
Non-allocating substring search.
Will handle the pattern ""
as returning empty matches at each character
boundary.
type Searcher = StrSearcher<'a, 'b>
fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>
fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_suffix_of(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
impl Ord for str
impl PartialEq<str> for str
impl Eq for str
impl PartialOrd<str> for str
fn partial_cmp(&self, other: &str) -> Option<Ordering>
fn lt(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
fn gt(&self, other: &Rhs) -> bool
fn ge(&self, other: &Rhs) -> bool
impl Index<Range<usize>> for str
Returns a slice of the given string from the byte range
[begin
..end
).
This operation is O(1)
.
Panics when begin
and end
do not point to valid characters
or point beyond the last character of the string.
Examples
fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(&s[0 .. 1], "L"); assert_eq!(&s[1 .. 9], "öwe 老"); // these will panic: // byte 2 lies within `ö`: // &s[2 ..3]; // byte 8 lies within `老` // &s[1 .. 8]; // byte 100 is outside the string // &s[3 .. 100]; }let s = "Löwe 老虎 Léopard"; assert_eq!(&s[0 .. 1], "L"); assert_eq!(&s[1 .. 9], "öwe 老"); // these will panic: // byte 2 lies within `ö`: // &s[2 ..3]; // byte 8 lies within `老` // &s[1 .. 8]; // byte 100 is outside the string // &s[3 .. 100];
impl IndexMut<Range<usize>> for str
Returns a mutable slice of the given string from the byte range
[begin
..end
).
impl Index<RangeTo<usize>> for str
Returns a slice of the string from the beginning to byte
end
.
Equivalent to self[0 .. end]
.
Panics when end
does not point to a valid character, or is
out of bounds.
impl IndexMut<RangeTo<usize>> for str
Returns a mutable slice of the string from the beginning to byte
end
.
impl Index<RangeFrom<usize>> for str
Returns a slice of the string from begin
to its end.
Equivalent to self[begin .. self.len()]
.
Panics when begin
does not point to a valid character, or is
out of bounds.
impl IndexMut<RangeFrom<usize>> for str
Returns a slice of the string from begin
to its end.