# Primitive Type str 1.0.0 [−]

String slices.

The `str` type, also called a 'string slice', is the most primitive string type. It is usually seen in its borrowed form, `&str`. It is also the type of string literals, `&'static str`.

Strings slices are always valid UTF-8.

This documentation describes a number of methods and trait implementations on the `str` type. For technical reasons, there is additional, separate documentation in the `std::str` module as well.

# Examples

String literals are string slices:

    let hello = "Hello, world!";

    // with an explicit type annotation
    let hello: &'static str = "Hello, world!";Run

They are `'static` because they're stored directly in the final binary, and so will be valid for the `'static` duration.

# Representation

A `&str` is made up of two components: a pointer to some bytes, and a length. You can look at these with the `.as_ptr()` and `len()` methods:

    use std::slice;
    use std::str;

    let story = "Once upon a time...";

    let ptr = story.as_ptr();
    let len = story.len();

    // story has nineteen bytes
    assert_eq!(19, len);

    // We can re-build a str out of ptr and len. This is all unsafe because
    // we are responsible for making sure the two components are valid:
    let s = unsafe {
        // First, we build a &[u8]...
        let slice = slice::from_raw_parts(ptr, len);

        // ... and then convert that slice into a string slice
        str::from_utf8(slice)
    };

    assert_eq!(s, Ok(story));Run

Note: This example shows the internals of `&str`. `unsafe` should not be used to get a string slice under normal circumstances. Use `.as_slice()` instead.

## Methods

### `impl str`
[src]

Methods for string slices.

#### `fn len(&self) -> usize`

Returns the length of `self`.

This length is in bytes, not `char`s or graphemes. In other words, it may not be what a human considers the length of the string.

# Examples

Basic usage:

    let len = "foo".len();
    assert_eq!(3, len);

    let len = "ƒoo".len(); // fancy f!
    assert_eq!(4, len);Run

#### `fn is_empty(&self) -> bool`

Returns true if this slice has a length of zero bytes.

# Examples

Basic usage:

    let s = "";
    assert!(s.is_empty());

    let s = "not empty";
    assert!(!s.is_empty());Run

#### `fn is_char_boundary(&self, index: usize) -> bool`
1.9.0

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

    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));Run

#### `fn as_bytes(&self) -> &[u8]`

Converts a string slice to a byte slice.

# Examples

Basic usage:

    let bytes = "bors".as_bytes();
    assert_eq!(b"bors", bytes);Run

#### `fn as_ptr(&self) -> *const u8`

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.

# Examples

Basic usage:

    let s = "Hello";
    let ptr = s.as_ptr();Run

#### `unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str`

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.

# Safety

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.

# Examples

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));
    }Run

#### `unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut str`
1.5.0

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.

# Safety

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.

#### `fn split_at(&self, mid: usize) -> (&str, &str)`
1.4.0

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

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.

# Examples

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);Run

#### `fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)`
1.4.0

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

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.

# Examples

Basic usage:

    let mut s = "Per Martin-Löf".to_string();

    let (first, last) = s.split_at_mut(3);

    assert_eq!("Per", first);
    assert_eq!(" Martin-Löf", last);Run

#### `fn chars(&self) -> Chars`

Returns an iterator over the `char`s 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.

# Examples

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());Run

Remember, `char`s may not match your human intuition about characters:

    let y = "y̆";

    let mut chars = y.chars();

    assert_eq!(Some('y'), chars.next()); // not 'y̆'
    assert_eq!(Some('\u{0306}'), chars.next());

    assert_eq!(None, chars.next());Run

#### `fn char_indices(&self) -> CharIndices`

Returns an iterator over the `char`s 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 `char`s, as well as their byte positions.

The iterator yields tuples. The position is first, the `char` is second.

# Examples

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());Run

Remember, `char`s 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()); // not (0, 'y̆')
    assert_eq!(Some((1, '\u{0306}')), char_indices.next());

    assert_eq!(None, char_indices.next());Run

#### `fn bytes(&self) -> Bytes`

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.

# Examples

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());Run

#### `fn split_whitespace(&self) -> SplitWhitespace`
1.1.0

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`.

# Examples

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());Run

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());Run

#### `fn lines(&self) -> Lines`

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.

# Examples

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());Run

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());Run

#### `fn lines_any(&self) -> LinesAny`

Deprecated since 1.4.0

: use lines() instead now

An iterator over the lines of a string.

#### `fn encode_utf16(&self) -> EncodeUtf16`
1.8.0

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 the given pattern matches a sub-slice of this string slice.

Returns `false` if it does not.

# Examples

Basic usage:

    let bananas = "bananas";

    assert!(bananas.contains("nana"));
    assert!(!bananas.contains("apples"));Run

#### `fn 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.

# Examples

Basic usage:

    let bananas = "bananas";

    assert!(bananas.starts_with("bana"));
    assert!(!bananas.starts_with("nana"));Run

#### `fn ends_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>`

Returns `true` if the given pattern matches a suffix of this string slice.

Returns `false` if it does not.

# Examples

Basic usage:

    let bananas = "bananas";

    assert!(bananas.ends_with("anas"));
    assert!(!bananas.ends_with("nana"));Run

#### `fn 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.

# Examples

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));Run

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));Run

Not finding the pattern:

    let s = "Löwe 老虎 Léopard";
    let x: &[_] = &['1', '2'];

    assert_eq!(s.find(x), None);Run

#### `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 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.

# Examples

Simple patterns:

    let s = "Löwe 老虎 Léopard";

    assert_eq!(s.rfind('L'), Some(13));
    assert_eq!(s.rfind('é'), Some(14));Run

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));Run

Not finding the pattern:

    let s = "Löwe 老虎 Léopard";
    let x: &[_] = &['1', '2'];

    assert_eq!(s.rfind(x), None);Run

#### `fn 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.

# Iterator behavior

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.

# Examples

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"]);Run

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"]);Run

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"]);Run

Contiguous separators are separated by the empty string.

    let x = "(///)".to_string();
    let d: Vec<_> = x.split('/').collect();;

    assert_eq!(d, &["(", "", "", ")"]);Run

Separators at the start or end of a string are neighbored by empty strings.

    let d: Vec<_> = "010".split("0").collect();
    assert_eq!(d, &["", "1", ""]);Run

When the empty string is used as a separator, it separates every character in the string, along with the beginning and end of the string.

    let f: Vec<_> = "rust".split("").collect();
    assert_eq!(f, &["", "r", "u", "s", "t", ""]);Run

Contiguous separators 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"]);Run

It does not give you:

    assert_eq!(d, &["a", "b", "c"]);Run

Use `split_whitespace()` for this behavior.

#### `fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>`

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.

# Iterator behavior

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.

# Examples

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"]);Run

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"]);Run

#### `fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where P: Pattern<'a>`

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.

# Iterator behavior

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.

# Examples

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", ""]);Run

#### `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, the `split_terminator()` method can be used.

# Examples

    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"]);Run

#### `fn splitn<'a, P>(&'a self, n: 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 `n` items.

If `n` substrings are returned, the last substring (the `n`th substring) will contain the remainder of the string.

The pattern can be a `&str`, `char`, or a closure that determines the split.

# Iterator behavior

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.

# Examples

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, [""]);Run

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"]);Run

#### `fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>`

An iterator over substrings of this string slice, separated by a pattern, starting from the end of the string, restricted to returning at most `n` items.

If `n` substrings are returned, the last substring (the `n`th substring) will contain the remainder of the string.

The pattern can be a `&str`, `char`, or a closure that determines the split.

# Iterator behavior

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.

# Examples

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"]);Run

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"]);Run

#### `fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>`
1.2.0

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.

# Iterator behavior

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.

# Examples

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"]);Run

#### `fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>`
1.2.0

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.

# Iterator behavior

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.

# Examples

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"]);Run

#### `fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where P: Pattern<'a>`
1.5.0

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.

# Iterator behavior

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.

# Examples

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")]); // only the first `aba`Run

#### `fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>`
1.5.0

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.

# Iterator behavior

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.

# Examples

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")]); // only the last `aba`Run

#### `fn 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`.

# Examples

Basic usage:

    let s = " Hello\tworld\t";

    assert_eq!("Hello\tworld", s.trim());Run

#### `fn trim_left(&self) -> &str`

Returns a string slice with leading whitespace removed.

'Whitespace' is defined according to the terms of the Unicode Derived Core Property `White_Space`.

# Text directionality

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.

# Examples

Basic usage:

    let s = " Hello\tworld\t";

    assert_eq!("Hello\tworld\t", s.trim_left());Run

Directionality:

    let s = "  English";
    assert!(Some('E') == s.trim_left().chars().next());

    let s = "  עברית";
    assert!(Some('ע') == s.trim_left().chars().next());Run

#### `fn trim_right(&self) -> &str`

Returns a string slice with trailing whitespace removed.

'Whitespace' is defined according to the terms of the Unicode Derived Core Property `White_Space`.

# Text directionality

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.

# Examples

Basic usage:

    let s = " Hello\tworld\t";

    assert_eq!(" Hello\tworld", s.trim_right());Run

Directionality:

    let s = "English  ";
    assert!(Some('h') == s.trim_right().chars().rev().next());

    let s = "עברית  ";
    assert!(Some('ת') == s.trim_right().chars().rev().next());Run

#### `fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: DoubleEndedSearcher<'a>`

Returns a string slice with all prefixes and suffixes that match a pattern repeatedly removed.

The pattern can be a `char` or a closure that determines if a character matches.

# Examples

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");Run

A more complex pattern, using a closure:

    assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");Run

#### `fn 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.

# Text directionality

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.

# Examples

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");Run

#### `fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>`

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.

# Text directionality

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.

# Examples

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");Run

A more complex pattern, using a closure:

    assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX");Run

#### `fn parse<F>(&self) -> Result<F, F::Err> where F: FromStr`

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.

# Errors

Will return `Err` if it's not possible to parse this string slice into the desired type.

# Example

Basic usage

    let four: u32 = "4".parse().unwrap();

    assert_eq!(4, four);Run

Using the 'turbofish' instead of annotating `four`:

    let four = "4".parse::<u32>();

    assert_eq!(Ok(4), four);Run

Failing to parse:

    let nope = "j".parse::<u32>();

    assert!(nope.is_err());Run

#### `fn 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.

# Examples

Basic usage:

    let s = "this is old";

    assert_eq!("this is new", s.replace("old", "new"));Run

When the pattern doesn't match:

    let s = "this is old";
    assert_eq!(s, s.replace("cookie monster", "little lamb"));Run

#### `fn replacen<'a, P>(&'a self, pat: P, to: &str, count: usize) -> String where P: Pattern<'a>`
1.16.0

Replaces first N matches of a pattern with another string.

`replacen` 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 at most `N` times.

# Examples

Basic usage:

    let s = "foo foo 123 foo";
    assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
    assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
    assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));Run

When the pattern doesn't match:

    let s = "this is old";
    assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));Run

#### `fn to_lowercase(&self) -> String`
1.2.0

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`.

# Examples

Basic usage:

    let s = "HELLO";

    assert_eq!("hello", s.to_lowercase());Run

A tricky example, with sigma:

    let sigma = "Σ";

    assert_eq!("σ", sigma.to_lowercase());

    // but at the end of a word, it's ς, not σ:
    let odysseus = "ὈΔΥΣΣΕΎΣ";

    assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());Run

Languages without case are not changed:

    let new_year = "农历新年";

    assert_eq!(new_year, new_year.to_lowercase());Run

#### `fn to_uppercase(&self) -> String`
1.2.0

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`.

# Examples

Basic usage:

    let s = "hello";

    assert_eq!("HELLO", s.to_uppercase());Run

Scripts without case are not changed:

    let new_year = "农历新年";

    assert_eq!(new_year, new_year.to_uppercase());Run

#### `fn escape_debug(&self) -> String`

🔬 This is a nightly-only experimental API. (`str_escape` #27791)

return type may change to be an iterator

Escapes each char in `s` with `char::escape_debug`.

#### `fn escape_default(&self) -> String`

🔬 This is a nightly-only experimental API. (`str_escape` #27791)

return type may change to be an iterator

Escapes each char in `s` with `char::escape_default`.

#### `fn escape_unicode(&self) -> String`

🔬 This is a nightly-only experimental API. (`str_escape` #27791)

return type may change to be an iterator

Escapes each char in `s` with `char::escape_unicode`.

#### `fn into_string(self: Box<str>) -> String`
1.4.0

Converts a `Box<str>` into a `String` without copying or allocating.

# Examples

Basic usage:

    let string = String::from("birthday gift");
    let boxed_str = string.clone().into_boxed_str();

    assert_eq!(boxed_str.into_string(), string);Run

#### `fn repeat(&self, n: usize) -> String`
1.16.0

Create a `String` by repeating a string `n` times.

# Examples

Basic usage:

    assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));Run

## Trait Implementations

### `impl ToString for str`
1.9.0
[src]

#### `fn to_string(&self) -> String`

Converts the given value to a `String`. Read more

### `impl ToOwned for str`
[src]

#### `type Owned = String`

#### `fn to_owned(&self) -> String`

Creates owned data from borrowed data, usually by cloning. Read more

### `impl<'a, 'b> PartialEq<String> for str`
[src]

#### `fn eq(&self, other: &String) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &String) -> bool`

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<String> for &'a str`
[src]

#### `fn eq(&self, other: &String) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &String) -> bool`

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'a, str>> for str`
[src]

#### `fn eq(&self, other: &Cow<'a, str>) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Cow<'a, str>) -> bool`

This method tests for `!=`.

### `impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str`
[src]

#### `fn eq(&self, other: &Cow<'a, str>) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Cow<'a, str>) -> bool`

This method tests for `!=`.

### `impl Index<Range<usize>> for str`
[src]

Implements substring slicing with syntax `&self[begin .. end]`.

Returns a slice of the given string from the byte range [`begin`..`end`).

This operation is `O(1)`.

# Panics

Panics if `begin` or `end` does not point to the starting byte offset of a character (as defined by `is_char_boundary`). Requires that `begin <= end` and `end <= len` where `len` is the length of the string.

# Examples

    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];Run

#### `type Output = str`

The returned type after indexing

#### `fn index(&self, index: Range<usize>) -> &str`

The method for the indexing (`container[index]`) operation

### `impl Index<RangeTo<usize>> for str`
[src]

Implements substring slicing with syntax `&self[.. end]`.

Returns a slice of the string from the beginning to byte offset `end`.

Equivalent to `&self[0 .. end]`.

#### `type Output = str`

The returned type after indexing

#### `fn index(&self, index: RangeTo<usize>) -> &str`

The method for the indexing (`container[index]`) operation

### `impl Index<RangeFrom<usize>> for str`
[src]

Implements substring slicing with syntax `&self[begin ..]`.

Returns a slice of the string from byte offset `begin` to the end of the string.

Equivalent to `&self[begin .. len]`.

#### `type Output = str`

The returned type after indexing

#### `fn index(&self, index: RangeFrom<usize>) -> &str`

The method for the indexing (`container[index]`) operation

### `impl Index<RangeFull> for str`
[src]

Implements substring slicing with syntax `&self[..]`.

Returns a slice of the whole string. This operation can never panic.

Equivalent to `&self[0 .. len]`.

#### `type Output = str`

The returned type after indexing

#### `fn index(&self, _index: RangeFull) -> &str`

The method for the indexing (`container[index]`) operation

### `impl Index<RangeInclusive<usize>> for str`
[src]

#### `type Output = str`

The returned type after indexing

#### `fn index(&self, index: RangeInclusive<usize>) -> &str`

The method for the indexing (`container[index]`) operation

### `impl Index<RangeToInclusive<usize>> for str`
[src]

#### `type Output = str`

The returned type after indexing

#### `fn index(&self, index: RangeToInclusive<usize>) -> &str`

The method for the indexing (`container[index]`) operation

### `impl PartialEq<str> for str`
[src]

#### `fn eq(&self, other: &str) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &str) -> bool`

This method tests for `!=`.

### `impl<'a> Default for &'a str`
[src]

#### `fn default() -> &'a str`

Creates an empty str

### `impl Display for str`
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

### `impl Eq for str`
[src]

### `impl<'a, 'b> Pattern<'a> for &'b str`
[src]

Non-allocating substring search.

Will handle the pattern `""` as returning empty matches at each character boundary.

#### `type Searcher = StrSearcher<'a, 'b>`

🔬 This is a nightly-only experimental API. (`pattern` #27721)

API not fully fleshed out and ready to be stabilized

Associated searcher for this pattern

#### `fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>`

🔬 This is a nightly-only experimental API. (`pattern` #27721)

API not fully fleshed out and ready to be stabilized

Constructs the associated searcher from `self` and the `haystack` to search in. Read more

#### `fn is_prefix_of(self, haystack: &'a str) -> bool`

🔬 This is a nightly-only experimental API. (`pattern` #27721)

API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches at the front of the haystack

#### `fn is_suffix_of(self, haystack: &'a str) -> bool`

🔬 This is a nightly-only experimental API. (`pattern` #27721)

API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches at the back of the haystack

#### `fn is_contained_in(self, haystack: &'a str) -> bool`

🔬 This is a nightly-only experimental API. (`pattern` #27721)

API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches anywhere in the haystack

### `impl AsRef<str> for str`
[src]

#### `fn as_ref(&self) -> &str`

Performs the conversion.

### `impl AsRef<[u8]> for str`
[src]

#### `fn as_ref(&self) -> &[u8]`

Performs the conversion.

### `impl Debug for str`
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

### `impl Ord for str`
[src]

#### `fn cmp(&self, other: &str) -> Ordering`

This method returns an `Ordering` between `self` and `other`. Read more

### `impl Hash for str`
[src]

#### `fn hash<H>(&self, state: &mut H) where H: Hasher`

Feeds this value into the state given, updating the hasher as necessary.

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher`
1.3.0

Feeds a slice of this type into the state provided.

### `impl PartialOrd<str> for str`
[src]

#### `fn partial_cmp(&self, other: &str) -> Option<Ordering>`

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `fn lt(&self, other: &Rhs) -> bool`

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `fn le(&self, other: &Rhs) -> bool`

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `fn gt(&self, other: &Rhs) -> bool`

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `fn ge(&self, other: &Rhs) -> bool`

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl IndexMut<Range<usize>> for str`
1.2.0
[src]

Implements mutable substring slicing with syntax `&mut self[begin .. end]`.

Returns a mutable slice of the given string from the byte range [`begin`..`end`).

This operation is `O(1)`.

# Panics

Panics if `begin` or `end` does not point to the starting byte offset of a character (as defined by `is_char_boundary`). Requires that `begin <= end` and `end <= len` where `len` is the length of the string.

#### `fn index_mut(&mut self, index: Range<usize>) -> &mut str`

The method for the mutable indexing (`container[index]`) operation

### `impl IndexMut<RangeTo<usize>> for str`
1.2.0
[src]

Implements mutable substring slicing with syntax `&mut self[.. end]`.

Returns a mutable slice of the string from the beginning to byte offset `end`.

Equivalent to `&mut self[0 .. end]`.

#### `fn index_mut(&mut self, index: RangeTo<usize>) -> &mut str`

The method for the mutable indexing (`container[index]`) operation

### `impl IndexMut<RangeFrom<usize>> for str`
1.2.0
[src]

Implements mutable substring slicing with syntax `&mut self[begin ..]`.

Returns a mutable slice of the string from byte offset `begin` to the end of the string.

Equivalent to `&mut self[begin .. len]`.

#### `fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut str`

The method for the mutable indexing (`container[index]`) operation

### `impl IndexMut<RangeFull> for str`
1.2.0
[src]

Implements mutable substring slicing with syntax `&mut self[..]`.

Returns a mutable slice of the whole string. This operation can never panic.

Equivalent to `&mut self[0 .. len]`.

#### `fn index_mut(&mut self, _index: RangeFull) -> &mut str`

The method for the mutable indexing (`container[index]`) operation

### `impl IndexMut<RangeInclusive<usize>> for str`
[src]

#### `fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str`

The method for the mutable indexing (`container[index]`) operation

### `impl IndexMut<RangeToInclusive<usize>> for str`
[src]

#### `fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut str`

The method for the mutable indexing (`container[index]`) operation

### `impl UnicodeStr for str`
[src]

#### `fn split_whitespace(&self) -> SplitWhitespace`

🔬 This is a nightly-only experimental API. (`unicode` #27783)

#### `fn is_whitespace(&self) -> bool`

🔬 This is a nightly-only experimental API. (`unicode` #27783)

#### `fn is_alphanumeric(&self) -> bool`

🔬 This is a nightly-only experimental API. (`unicode` #27783)

#### `fn trim(&self) -> &str`

🔬 This is a nightly-only experimental API. (`unicode` #27783)

#### `fn trim_left(&self) -> &str`

🔬 This is a nightly-only experimental API. (`unicode` #27783)

#### `fn trim_right(&self) -> &str`

🔬 This is a nightly-only experimental API. (`unicode` #27783)

### `impl AsciiExt for str`
[src]

#### `type Owned = String`

Container type for copied ASCII characters.

#### `fn is_ascii(&self) -> bool`

Checks if the value is within the ASCII range. Read more

#### `fn to_ascii_uppercase(&self) -> String`

Makes a copy of the string in ASCII upper case. Read more

#### `fn to_ascii_lowercase(&self) -> String`

Makes a copy of the string in ASCII lower case. Read more

#### `fn eq_ignore_ascii_case(&self, other: &str) -> bool`

Checks that two strings are an ASCII case-insensitive match. Read more

#### `fn make_ascii_uppercase(&mut self)`

Converts this type to its ASCII upper case equivalent in-place. Read more

#### `fn make_ascii_lowercase(&mut self)`

Converts this type to its ASCII lower case equivalent in-place. Read more

### `impl PartialEq<OsString> for str`
[src]

#### `fn eq(&self, other: &OsString) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Rhs) -> bool`

This method tests for `!=`.

### `impl PartialEq<OsStr> for str`
[src]

#### `fn eq(&self, other: &OsStr) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, other: &Rhs) -> bool`

This method tests for `!=`.

### `impl AsRef<OsStr> for str`
[src]

#### `fn as_ref(&self) -> &OsStr`

Performs the conversion.

### `impl ToSocketAddrs for str`
[src]

#### `type Iter = IntoIter<SocketAddr>`

Returned iterator over socket addresses which this type may correspond to. Read more

#### `fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>`

Converts this object to an iterator of resolved `SocketAddr`s. Read more

### `impl AsRef<Path> for str`
[src]

#### `fn as_ref(&self) -> &Path`

Performs the conversion.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)