# Primitive Type str [−]

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:

fn main() { let hello = "Hello, world!"; // with an explicit type annotation let hello: &'static str = "Hello, world!"; }

    let hello = "Hello, world!";

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

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:

fn main() { 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 becuase // 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)); }

    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 becuase
    // 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));

## Methods

### `impl str`

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:

fn main() { let len = "foo".len(); assert_eq!(3, len); let len = "ƒoo".len(); // fancy f! assert_eq!(4, len); }

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

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

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

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

# Examples

Basic usage:

fn main() { let s = ""; assert!(s.is_empty()); let s = "not empty"; assert!(!s.is_empty()); }

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

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

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

Unstable (`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 a string slice to a byte slice.

# Examples

Basic usage:

fn main() { let bytes = "bors".as_bytes(); assert_eq!(b"bors", bytes); }

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

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

fn main() { let s = "Hello"; let ptr = s.as_ptr(); }

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

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

fn main() { 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)); } }

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

#### `unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut 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 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 char_range_at(&self, start: usize) -> CharRange`

Unstable (`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, returns the next `char` and its index.

# 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)] fn main() { use std::str::CharRange; let s = "中华Việt Nam"; let mut i = 0; while i < s.len() { let CharRange {ch, next} = s.char_range_at(i); println!("{}: {}", i, ch); i = next; } }

    #![feature(str_char)]

    use std::str::CharRange;

    let s = "中华Việ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`

Unstable (`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, 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.

# 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)] fn main() { use std::str::CharRange; let s = "中华Việ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; } }

    #![feature(str_char)]

    use std::str::CharRange;

    let s = "中华Việ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`

Unstable (`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, returns 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`

Unstable (`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, returns 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)>`

Unstable (`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 `char` 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 = "Łódź"; // \u{141}o\u{301}dz\u{301} let (c, s1) = s.slice_shift_char().unwrap(); assert_eq!(c, 'Ł'); assert_eq!(s1, "ódź"); 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 = "Łódź"; // \u{141}o\u{301}dz\u{301}
    let (c, s1) = s.slice_shift_char().unwrap();

    assert_eq!(c, 'Ł');
    assert_eq!(s1, "ódź");

    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 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:

fn main() { let s = "Per Martin-Löf"; let (first, last) = s.split_at(3); assert_eq!("Per", first); assert_eq!(" Martin-Löf", last); }

    let s = "Per Martin-Löf";

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

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

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

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:

fn main() { let s = "Per Martin-Löf"; let (first, last) = s.split_at(3); assert_eq!("Per", first); assert_eq!(" Martin-Löf", last); }

    let s = "Per Martin-Löf";

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

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

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

fn main() { 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()); }

    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, `char`s may not match your human intuition about characters:

fn main() { 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()); }

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

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

fn main() { 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()); }

    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, `char`s may not match your human intuition about characters:

fn main() { 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()); }

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

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

fn main() { 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()); }

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

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

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:

fn main() { 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()); }

    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:

fn main() { 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()); }

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

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

fn main() { 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()); }

    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:

fn main() { 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()); }

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

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

Deprecated since 1.4.0

: use lines() instead now

An iterator over the lines of a string.

#### `fn utf16_units(&self) -> Utf16Units`

Unstable (`str_utf16` #27714)

: this functionality may only be provided by libunicode

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:

fn main() { let bananas = "bananas"; assert!(bananas.contains("nana")); assert!(!bananas.contains("apples")); }

    let bananas = "bananas";

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

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

fn main() { let bananas = "bananas"; assert!(bananas.starts_with("bana")); assert!(!bananas.starts_with("nana")); }

    let bananas = "bananas";

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

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

fn main() { let bananas = "bananas"; assert!(bananas.ends_with("anas")); assert!(!bananas.ends_with("nana")); }

    let bananas = "bananas";

    assert!(bananas.ends_with("anas"));
    assert!(!bananas.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 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:

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 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:

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 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:

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

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:

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 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:

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

# 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:

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

# 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:

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 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:

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 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:

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 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:

fn main() { 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` }

    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`

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

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:

fn main() { 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` }

    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`

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

fn main() { let s = " Hello\tworld\t"; assert_eq!("Hello\tworld", s.trim()); }

    let s = " Hello\tworld\t";

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

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

# Examples

Basic usage:

fn main() { let s = " Hello\tworld\t"; assert_eq!("Hello\tworld\t", s.trim_left()); }

    let s = " Hello\tworld\t";

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

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

# Examples

Basic usage:

fn main() { let s = " Hello\tworld\t"; assert_eq!(" Hello\tworld", s.trim_right()); }

    let s = " Hello\tworld\t";

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

#### `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 `&str`, `char`, or a closure that determines if a character matches.

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

# Examples

Basic usage:

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

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

# Failure

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

# Example

Basic usage

fn main() { let four: u32 = "4".parse().unwrap(); assert_eq!(4, four); }

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

    assert_eq!(4, four);

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

fn main() { let four = "4".parse::<u32>(); assert_eq!(Ok(4), four); }

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

    assert_eq!(Ok(4), four);

Failing to parse:

fn main() { let nope = "j".parse::<u32>(); assert!(nope.is_err()); }

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

    assert!(nope.is_err());

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

fn main() { let s = "this is old"; assert_eq!("this is new", s.replace("old", "new")); }

    let s = "this is old";

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

When the pattern doesn't match:

fn main() { let s = "this is old"; assert_eq!(s, s.replace("cookie monster", "little lamb")); }

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

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

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:

fn main() { let s = "HELLO"; assert_eq!("hello", s.to_lowercase()); }

    let s = "HELLO";

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

A tricky example, with sigma:

fn main() { let sigma = "Σ"; assert_eq!("σ", sigma.to_lowercase()); // but at the end of a word, it's ς, not σ: let odysseus = "ὈΔΥΣΣΕΎΣ"; assert_eq!("ὀδυσσεύς", odysseus.to_lowercase()); }

    let sigma = "Σ";

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

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

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

Languages without case are not changed:

fn main() { let new_year = "农历新年"; assert_eq!(new_year, new_year.to_lowercase()); }

    let new_year = "农历新年";

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

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

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:

fn main() { let s = "hello"; assert_eq!("HELLO", s.to_uppercase()); }

    let s = "hello";

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

Scripts without case are not changed:

fn main() { let new_year = "农历新年"; assert_eq!(new_year, new_year.to_uppercase()); }

    let new_year = "农历新年";

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

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

Unstable (`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`

Unstable (`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`

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

# Examples

Basic usage:

fn main() { let string = String::from("birthday gift"); let boxed_str = string.clone().into_boxed_str(); assert_eq!(boxed_str.into_string(), string); }

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

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

## Trait Implementations

### `impl AsRef<str> for str`

#### `fn as_ref(&self) -> &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`

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

### `impl PartialEq<str> for str`

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

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

### `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];

#### `type Output = str`

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

### `impl IndexMut<Range<usize>> for str`

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

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

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

#### `type Output = str`

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

### `impl IndexMut<RangeTo<usize>> for str`

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

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

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

#### `type Output = str`

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

### `impl IndexMut<RangeFrom<usize>> for str`

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

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

### `impl Index<RangeFull> for str`

#### `type Output = str`

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

### `impl IndexMut<RangeFull> for str`

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

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

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

### `impl<'a> Default for &'a str`

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

### `impl Hash for str`

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

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

### `impl Debug for str`

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

### `impl Display for str`

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

### `impl ToOwned for str`

#### `type Owned = String`

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

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

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

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

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

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

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

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

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

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

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

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

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

### `impl<'a> IntoCow<'a, str> for &'a str`

#### `fn into_cow(self) -> Cow<'a, str>`

### `impl UnicodeStr for str`

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

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

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

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

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

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

### `impl AsciiExt for str`

#### `type Owned = String`

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

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

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

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

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

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

### `impl PartialEq<OsString> for str`

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

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

### `impl PartialEq<OsStr> for str`

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

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

### `impl AsRef<OsStr> for str`

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

### `impl ToSocketAddrs for str`

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

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

### `impl AsRef<Path> for str`

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

# 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

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