Struct std::string::String [] [src]

pub struct String {
    // some fields omitted
}

A growable string stored as a UTF-8 encoded buffer.

Methods

impl String

fn new() -> String

Creates a new string buffer initialized with the empty string.

Examples

fn main() { let mut s = String::new(); }
let mut s = String::new();

fn with_capacity(capacity: usize) -> String

Creates a new string buffer with the given capacity. The string will be able to hold exactly capacity bytes without reallocating. If capacity is 0, the string will not allocate.

Examples

fn main() { let mut s = String::with_capacity(10); }
let mut s = String::with_capacity(10);

fn from_str(string: &str) -> String

Deprecated since 1.2.0

: use String::from instead

Creates a new string buffer from the given string.

Examples

#![feature(collections)] fn main() { let s = String::from("hello"); assert_eq!(&s[..], "hello"); }
#![feature(collections)]

let s = String::from("hello");
assert_eq!(&s[..], "hello");

fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>

Returns the vector as a string buffer, if possible, taking care not to copy it.

Failure

If the given vector is not valid UTF-8, then the original vector and the corresponding error is returned.

Examples

fn main() { let hello_vec = vec![104, 101, 108, 108, 111]; let s = String::from_utf8(hello_vec).unwrap(); assert_eq!(s, "hello"); let invalid_vec = vec![240, 144, 128]; let s = String::from_utf8(invalid_vec).err().unwrap(); let err = s.utf8_error(); assert_eq!(s.into_bytes(), [240, 144, 128]); }
let hello_vec = vec![104, 101, 108, 108, 111];
let s = String::from_utf8(hello_vec).unwrap();
assert_eq!(s, "hello");

let invalid_vec = vec![240, 144, 128];
let s = String::from_utf8(invalid_vec).err().unwrap();
let err = s.utf8_error();
assert_eq!(s.into_bytes(), [240, 144, 128]);

fn from_utf8_lossy(v: &'a [u8]) -> Cow<'a, str>

Converts a vector of bytes to a new UTF-8 string. Any invalid UTF-8 sequences are replaced with U+FFFD REPLACEMENT CHARACTER.

Examples

fn main() { let input = b"Hello \xF0\x90\x80World"; let output = String::from_utf8_lossy(input); assert_eq!(output, "Hello \u{FFFD}World"); }
let input = b"Hello \xF0\x90\x80World";
let output = String::from_utf8_lossy(input);
assert_eq!(output, "Hello \u{FFFD}World");

fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>

Decode a UTF-16 encoded vector v into a String, returning None if v contains any invalid data.

Examples

fn main() { // 𝄞music let mut v = &mut [0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0x0069, 0x0063]; assert_eq!(String::from_utf16(v).unwrap(), "𝄞music".to_string()); // 𝄞mu<invalid>ic v[4] = 0xD800; assert!(String::from_utf16(v).is_err()); }
// 𝄞music
let mut v = &mut [0xD834, 0xDD1E, 0x006d, 0x0075,
                  0x0073, 0x0069, 0x0063];
assert_eq!(String::from_utf16(v).unwrap(),
           "𝄞music".to_string());

// 𝄞mu<invalid>ic
v[4] = 0xD800;
assert!(String::from_utf16(v).is_err());

fn from_utf16_lossy(v: &[u16]) -> String

Decode a UTF-16 encoded vector v into a string, replacing invalid data with the replacement character (U+FFFD).

Examples

fn main() { // 𝄞mus<invalid>ic<invalid> let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, 0x0073, 0xDD1E, 0x0069, 0x0063, 0xD834]; assert_eq!(String::from_utf16_lossy(v), "𝄞mus\u{FFFD}ic\u{FFFD}".to_string()); }
// 𝄞mus<invalid>ic<invalid>
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0x0073, 0xDD1E, 0x0069, 0x0063,
          0xD834];

assert_eq!(String::from_utf16_lossy(v),
           "𝄞mus\u{FFFD}ic\u{FFFD}".to_string());

unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String

Creates a new String from a length, capacity, and pointer.

Unsafety

This is very unsafe because:

  • We call Vec::from_raw_parts to get a Vec<u8>. Therefore, this function inherits all of its unsafety, see its documentation for the invariants it expects, they also apply to this function.
  • We assume that the Vec contains valid UTF-8.

unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String

Converts a vector of bytes to a new String without checking if it contains valid UTF-8. This is unsafe because it assumes that the UTF-8-ness of the vector has already been validated.

fn into_bytes(self) -> Vec<u8>

Returns the underlying byte buffer, encoded as UTF-8.

Examples

fn main() { let s = String::from("hello"); let bytes = s.into_bytes(); assert_eq!(bytes, [104, 101, 108, 108, 111]); }
let s = String::from("hello");
let bytes = s.into_bytes();
assert_eq!(bytes, [104, 101, 108, 108, 111]);

fn as_str(&self) -> &str

Unstable

: waiting on RFC revision

Extracts a string slice containing the entire string.

fn push_str(&mut self, string: &str)

Pushes the given string onto this string buffer.

Examples

fn main() { let mut s = String::from("foo"); s.push_str("bar"); assert_eq!(s, "foobar"); }
let mut s = String::from("foo");
s.push_str("bar");
assert_eq!(s, "foobar");

fn capacity(&self) -> usize

Returns the number of bytes that this string buffer can hold without reallocating.

Examples

fn main() { let s = String::with_capacity(10); assert!(s.capacity() >= 10); }
let s = String::with_capacity(10);
assert!(s.capacity() >= 10);

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more bytes to be inserted in the given String. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new capacity overflows usize.

Examples

fn main() { let mut s = String::new(); s.reserve(10); assert!(s.capacity() >= 10); }
let mut s = String::new();
s.reserve(10);
assert!(s.capacity() >= 10);

fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for exactly additional more bytes to be inserted in the given String. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity overflows usize.

Examples

fn main() { let mut s = String::new(); s.reserve_exact(10); assert!(s.capacity() >= 10); }
let mut s = String::new();
s.reserve_exact(10);
assert!(s.capacity() >= 10);

fn shrink_to_fit(&mut self)

Shrinks the capacity of this string buffer to match its length.

Examples

fn main() { let mut s = String::from("foo"); s.reserve(100); assert!(s.capacity() >= 100); s.shrink_to_fit(); assert_eq!(s.capacity(), 3); }
let mut s = String::from("foo");
s.reserve(100);
assert!(s.capacity() >= 100);
s.shrink_to_fit();
assert_eq!(s.capacity(), 3);

fn push(&mut self, ch: char)

Adds the given character to the end of the string.

Examples

fn main() { let mut s = String::from("abc"); s.push('1'); s.push('2'); s.push('3'); assert_eq!(s, "abc123"); }
let mut s = String::from("abc");
s.push('1');
s.push('2');
s.push('3');
assert_eq!(s, "abc123");

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

Works with the underlying buffer as a byte slice.

Examples

fn main() { let s = String::from("hello"); assert_eq!(s.as_bytes(), [104, 101, 108, 108, 111]); }
let s = String::from("hello");
assert_eq!(s.as_bytes(), [104, 101, 108, 108, 111]);

fn truncate(&mut self, new_len: usize)

Shortens a string to the specified length.

Panics

Panics if new_len > current length, or if new_len is not a character boundary.

Examples

fn main() { let mut s = String::from("hello"); s.truncate(2); assert_eq!(s, "he"); }
let mut s = String::from("hello");
s.truncate(2);
assert_eq!(s, "he");

fn pop(&mut self) -> Option<char>

Removes the last character from the string buffer and returns it. Returns None if this string buffer is empty.

Examples

fn main() { let mut s = String::from("foo"); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('o')); assert_eq!(s.pop(), Some('f')); assert_eq!(s.pop(), None); }
let mut s = String::from("foo");
assert_eq!(s.pop(), Some('o'));
assert_eq!(s.pop(), Some('o'));
assert_eq!(s.pop(), Some('f'));
assert_eq!(s.pop(), None);

fn remove(&mut self, idx: usize) -> char

Removes the character from the string buffer at byte position idx and returns it.

Warning

This is an O(n) operation as it requires copying every element in the buffer.

Panics

If idx does not lie on a character boundary, or if it is out of bounds, then this function will panic.

Examples

fn main() { let mut s = String::from("foo"); assert_eq!(s.remove(0), 'f'); assert_eq!(s.remove(1), 'o'); assert_eq!(s.remove(0), 'o'); }
let mut s = String::from("foo");
assert_eq!(s.remove(0), 'f');
assert_eq!(s.remove(1), 'o');
assert_eq!(s.remove(0), 'o');

fn insert(&mut self, idx: usize, ch: char)

Inserts a character into the string buffer at byte position idx.

Warning

This is an O(n) operation as it requires copying every element in the buffer.

Panics

If idx does not lie on a character boundary or is out of bounds, then this function will panic.

unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>

Views the string buffer as a mutable sequence of bytes.

This is unsafe because it does not check to ensure that the resulting string will be valid UTF-8.

Examples

fn main() { let mut s = String::from("hello"); unsafe { let vec = s.as_mut_vec(); assert!(vec == &[104, 101, 108, 108, 111]); vec.reverse(); } assert_eq!(s, "olleh"); }
let mut s = String::from("hello");
unsafe {
    let vec = s.as_mut_vec();
    assert!(vec == &[104, 101, 108, 108, 111]);
    vec.reverse();
}
assert_eq!(s, "olleh");

fn len(&self) -> usize

Returns the number of bytes in this string.

Examples

fn main() { let a = "foo".to_string(); assert_eq!(a.len(), 3); }
let a = "foo".to_string();
assert_eq!(a.len(), 3);

fn is_empty(&self) -> bool

Returns true if the string contains no bytes

Examples

fn main() { let mut v = String::new(); assert!(v.is_empty()); v.push('a'); assert!(!v.is_empty()); }
let mut v = String::new();
assert!(v.is_empty());
v.push('a');
assert!(!v.is_empty());

fn clear(&mut self)

Truncates the string, returning it to 0 length.

Examples

fn main() { let mut s = "foo".to_string(); s.clear(); assert!(s.is_empty()); }
let mut s = "foo".to_string();
s.clear();
assert!(s.is_empty());

fn drain<R>(&mut self, range: R) -> Drain where R: RangeArgument<usize>

Unstable

: recently added, matches RFC

Create a draining iterator that removes the specified range in the string and yields the removed chars from start to end. The element range is removed even if the iterator is not consumed until the end.

Panics

Panics if the starting point or end point are not on character boundaries, or if they are out of bounds.

Examples

#![feature(drain)] fn main() { let mut s = String::from("α is alpha, β is beta"); let beta_offset = s.find('β').unwrap_or(s.len()); // Remove the range up until the β from the string let t: String = s.drain(..beta_offset).collect(); assert_eq!(t, "α is alpha, "); assert_eq!(s, "β is beta"); // A full range clears the string s.drain(..); assert_eq!(s, ""); }
#![feature(drain)]

let mut s = String::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());

// Remove the range up until the β from the string
let t: String = s.drain(..beta_offset).collect();
assert_eq!(t, "α is alpha, ");
assert_eq!(s, "β is beta");

// A full range clears the string
s.drain(..);
assert_eq!(s, "");

fn into_boxed_slice(self) -> Box<str>

Unstable

: recently added, matches RFC

Converts the string into Box<str>.

Note that this will drop any excess capacity.

Methods from Deref<Target=str>

fn len(&self) -> usize

Returns the length of self in bytes.

Examples

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

fn is_empty(&self) -> bool

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

Examples

fn main() { assert!("".is_empty()); }
assert!("".is_empty());

fn width(&self, is_cjk: bool) -> usize

Deprecated since 1.0.0

: use the crates.io unicode-width library instead

Returns a string's displayed width in columns.

Control characters have zero width.

is_cjk determines behavior for characters in the Ambiguous category: if is_cjk is true, these are 2 columns wide; otherwise, they are 1. In CJK locales, is_cjk should be true, else it should be false. Unicode Standard Annex #11 recommends that these characters be treated as 1 column (i.e., is_cjk = false) if the locale is unknown.

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

Unstable

: it is unclear whether this method pulls its weight with the existence of the char_indices iterator or this method may want to be replaced with checked slicing

Checks that index-th byte lies at the start and/or end of a UTF-8 code point sequence.

The start and end of the string (when index == self.len()) are considered to be boundaries.

Returns false if index is greater than self.len().

Examples

#![feature(str_char)] fn main() { let s = "Löwe 老虎 Léopard"; assert!(s.is_char_boundary(0)); // start of `老` assert!(s.is_char_boundary(6)); assert!(s.is_char_boundary(s.len())); // second byte of `ö` assert!(!s.is_char_boundary(2)); // third byte of `老` assert!(!s.is_char_boundary(8)); }
#![feature(str_char)]

let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));

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

Converts self to a byte slice.

Examples

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

fn as_ptr(&self) -> *const u8

Returns a raw pointer to the &str's buffer.

The caller must ensure that the string outlives this pointer, and that it is not reallocated (e.g. by pushing to the string).

Examples

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

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

Takes a bytewise slice from a string.

Returns the substring from [begin..end).

Unsafety

Caller must check both UTF-8 sequence boundaries and the boundaries of the entire slice as well.

Examples

fn main() { let s = "Löwe 老虎 Léopard"; unsafe { assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard"); } }
let s = "Löwe 老虎 Léopard";

unsafe {
    assert_eq!(s.slice_unchecked(0, 21), "Löwe 老虎 Léopard");
}

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

Unstable

: recently added

Takes a bytewise mutable slice from a string.

Same as slice_unchecked, but works with &mut str instead of &str.

fn slice_chars(&self, begin: usize, end: usize) -> &str

Deprecated since 1.3.0

: can be implemented with char_indices and hasn't seen enough use to justify inclusion

Returns a slice of the string from the range [begin..end) where indices are counted in code points.

That is, start at the begin-th code point of the string and continue to the end-th code point. This does not detect or handle edge cases such as leaving a combining character as the first char of the string.

Due to the design of UTF-8, this operation is O(end). Use slicing syntax if you want to use O(1) byte indices instead.

Panics

Panics if begin > end or the either begin or end are beyond the last character of the string.

Examples

#![feature(slice_chars)] fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.slice_chars(0, 4), "Löwe"); assert_eq!(s.slice_chars(5, 7), "老虎"); }
#![feature(slice_chars)]

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

assert_eq!(s.slice_chars(0, 4), "Löwe");
assert_eq!(s.slice_chars(5, 7), "老虎");

fn char_range_at(&self, start: usize) -> CharRange

Unstable

: often replaced by char_indices, this method may be removed in favor of just char_at() or eventually removed altogether

Given a byte position, return the next code point and its index.

This can be used to iterate over the Unicode code points of a string.

Panics

If i is greater than or equal to the length of the string. If i is not the index of the beginning of a valid UTF-8 sequence.

Examples

This example manually iterates through the code points of a string; this should normally be done by .chars() or .char_indices().

#![feature(str_char, core)] fn main() { use std::str::CharRange; let s = "中华Việt Nam"; let mut i = 0; while i < s.len() { let CharRange {ch, next} = s.char_range_at(i); println!("{}: {}", i, ch); i = next; } }
#![feature(str_char, core)]

use std::str::CharRange;

let s = "中华Việt Nam";
let mut i = 0;
while i < s.len() {
    let CharRange {ch, next} = s.char_range_at(i);
    println!("{}: {}", i, ch);
    i = next;
}

This outputs:

0: 中
3: 华
6: V
7: i
8: e
9: ̣
11: ̂
13: t
14:
15: N
16: a
17: m

fn char_range_at_reverse(&self, start: usize) -> CharRange

Unstable

: often replaced by char_indices, this method may be removed in favor of just char_at_reverse() or eventually removed altogether

Given a byte position, return the previous char and its position.

This function can be used to iterate over a Unicode code points in reverse.

Note that Unicode has many features, such as combining marks, ligatures, and direction marks, that need to be taken into account to correctly reverse a string.

Returns 0 for next index if called on start index 0.

Panics

If i is greater than the length of the string. If i is not an index following a valid UTF-8 sequence.

Examples

This example manually iterates through the code points of a string; this should normally be done by .chars().rev() or .char_indices().

#![feature(str_char, core)] fn main() { use std::str::CharRange; let s = "中华Việt Nam"; let mut i = s.len(); while i > 0 { let CharRange {ch, next} = s.char_range_at_reverse(i); println!("{}: {}", i, ch); i = next; } }
#![feature(str_char, core)]

use std::str::CharRange;

let s = "中华Việt Nam";
let mut i = s.len();
while i > 0 {
    let CharRange {ch, next} = s.char_range_at_reverse(i);
    println!("{}: {}", i, ch);
    i = next;
}

This outputs:

18: m
17: a
16: N
15:
14: t
13: ̂
11: ̣
9: e
8: i
7: V
6: 华
3: 中

fn char_at(&self, i: usize) -> char

Unstable

: frequently replaced by the chars() iterator, this method may be removed or possibly renamed in the future; it is normally replaced by chars/char_indices iterators or by getting the first char from a subslice

Given a byte position, return the char at that position.

Panics

If i is greater than or equal to the length of the string. If i is not the index of the beginning of a valid UTF-8 sequence.

Examples

#![feature(str_char)] fn main() { let s = "abπc"; assert_eq!(s.char_at(1), 'b'); assert_eq!(s.char_at(2), 'π'); assert_eq!(s.char_at(4), 'c'); }
#![feature(str_char)]

let s = "abπc";
assert_eq!(s.char_at(1), 'b');
assert_eq!(s.char_at(2), 'π');
assert_eq!(s.char_at(4), 'c');

fn char_at_reverse(&self, i: usize) -> char

Unstable

: see char_at for more details, but reverse semantics are also somewhat unclear, especially with which cases generate panics

Given a byte position, return the char at that position, counting from the end.

Panics

If i is greater than the length of the string. If i is not an index following a valid UTF-8 sequence.

Examples

#![feature(str_char)] fn main() { let s = "abπc"; assert_eq!(s.char_at_reverse(1), 'a'); assert_eq!(s.char_at_reverse(2), 'b'); assert_eq!(s.char_at_reverse(3), 'π'); }
#![feature(str_char)]

let s = "abπc";
assert_eq!(s.char_at_reverse(1), 'a');
assert_eq!(s.char_at_reverse(2), 'b');
assert_eq!(s.char_at_reverse(3), 'π');

fn slice_shift_char(&self) -> Option<(char, &str)>

Unstable

: awaiting conventions about shifting and slices and may not be warranted with the existence of the chars and/or char_indices iterators

Retrieves the first code point from a &str and returns it.

Note that a single Unicode character (grapheme cluster) can be composed of multiple chars.

This does not allocate a new string; instead, it returns a slice that points one code point beyond the code point that was shifted.

None is returned if the slice is empty.

Examples

#![feature(str_char)] fn main() { let s = "Łódź"; // \u{141}o\u{301}dz\u{301} let (c, s1) = s.slice_shift_char().unwrap(); assert_eq!(c, 'Ł'); assert_eq!(s1, "ódź"); let (c, s2) = s1.slice_shift_char().unwrap(); assert_eq!(c, 'o'); assert_eq!(s2, "\u{301}dz\u{301}"); }
#![feature(str_char)]

let s = "Łódź"; // \u{141}o\u{301}dz\u{301}
let (c, s1) = s.slice_shift_char().unwrap();

assert_eq!(c, 'Ł');
assert_eq!(s1, "ódź");

let (c, s2) = s1.slice_shift_char().unwrap();

assert_eq!(c, 'o');
assert_eq!(s2, "\u{301}dz\u{301}");

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

Unstable

: recently added

Divide one string slice into two at an index.

The index mid is a byte offset from the start of the string that must be on a char boundary.

Return slices &self[..mid] and &self[mid..].

Panics

Panics if mid is beyond the last code point of the string, or if it is not on a char boundary.

Examples

#![feature(str_split_at)] fn main() { let s = "Löwe 老虎 Léopard"; let first_space = s.find(' ').unwrap_or(s.len()); let (a, b) = s.split_at(first_space); assert_eq!(a, "Löwe"); assert_eq!(b, " 老虎 Léopard"); }
#![feature(str_split_at)]

let s = "Löwe 老虎 Léopard";
let first_space = s.find(' ').unwrap_or(s.len());
let (a, b) = s.split_at(first_space);

assert_eq!(a, "Löwe");
assert_eq!(b, " 老虎 Léopard");

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

Unstable

: recently added

Divide one mutable string slice into two at an index.

fn chars(&self) -> Chars

An iterator over the code points of self.

In Unicode relationship between code points and characters is complex. A single character may be composed of multiple code points (e.g. diacritical marks added to a letter), and a single code point (e.g. Hangul syllable) may contain multiple characters.

For iteration over human-readable characters a grapheme cluster iterator may be more appropriate. See the unicode-segmentation crate.

Examples

fn main() { let v: Vec<char> = "ASCII żółć 🇨🇭 한".chars().collect(); assert_eq!(v, ['A', 'S', 'C', 'I', 'I', ' ', 'z', '\u{307}', 'o', '\u{301}', 'ł', 'c', '\u{301}', ' ', '\u{1f1e8}', '\u{1f1ed}', ' ', '한']); }
let v: Vec<char> = "ASCII żółć 🇨🇭 한".chars().collect();

assert_eq!(v, ['A', 'S', 'C', 'I', 'I', ' ',
    'z', '\u{307}', 'o', '\u{301}', 'ł', 'c', '\u{301}', ' ',
    '\u{1f1e8}', '\u{1f1ed}', ' ', '한']);

fn char_indices(&self) -> CharIndices

An iterator over the chars of self and their byte offsets.

Examples

fn main() { let v: Vec<(usize, char)> = "A🇨🇭".char_indices().collect(); let b = vec![(0, 'A'), (1, '\u{1f1e8}'), (5, '\u{1f1ed}')]; assert_eq!(v, b); }
let v: Vec<(usize, char)> = "A🇨🇭".char_indices().collect();
let b = vec![(0, 'A'), (1, '\u{1f1e8}'), (5, '\u{1f1ed}')];

assert_eq!(v, b);

fn bytes(&self) -> Bytes

An iterator over the bytes of self.

Examples

fn main() { let v: Vec<u8> = "bors".bytes().collect(); assert_eq!(v, b"bors".to_vec()); }
let v: Vec<u8> = "bors".bytes().collect();

assert_eq!(v, b"bors".to_vec());

fn split_whitespace(&self) -> SplitWhitespace

An iterator over the non-empty substrings of self which contain no whitespace, and which are separated by any amount of whitespace.

Examples

fn main() { let some_words = " Mary had\ta\u{2009}little \n\t lamb"; let v: Vec<&str> = some_words.split_whitespace().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); }
let some_words = " Mary   had\ta\u{2009}little  \n\t lamb";
let v: Vec<&str> = some_words.split_whitespace().collect();

assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

fn words(&self) -> SplitWhitespace

Deprecated since 1.1.0

: words() will be removed. Use split_whitespace() instead

An iterator over the non-empty substrings of self which contain no whitespace, and which are separated by any amount of whitespace.

Examples

#![feature(str_words)] fn main() { #![allow(deprecated)] let some_words = " Mary had\ta\u{2009}little \n\t lamb"; let v: Vec<&str> = some_words.words().collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); }
#![feature(str_words)]
#![allow(deprecated)]

let some_words = " Mary   had\ta\u{2009}little  \n\t lamb";
let v: Vec<&str> = some_words.words().collect();

assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

fn lines(&self) -> Lines

An iterator over the lines of a string, separated by \n.

This does not include the empty string after a trailing \n.

Examples

fn main() { let four_lines = "foo\nbar\n\nbaz"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }
let four_lines = "foo\nbar\n\nbaz";
let v: Vec<&str> = four_lines.lines().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

Leaving off the trailing character:

fn main() { let four_lines = "foo\nbar\n\nbaz\n"; let v: Vec<&str> = four_lines.lines().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }
let four_lines = "foo\nbar\n\nbaz\n";
let v: Vec<&str> = four_lines.lines().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

fn lines_any(&self) -> LinesAny

An iterator over the lines of a string, separated by either \n or \r\n.

As with .lines(), this does not include an empty trailing line.

Examples

fn main() { let four_lines = "foo\r\nbar\n\r\nbaz"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }
let four_lines = "foo\r\nbar\n\r\nbaz";
let v: Vec<&str> = four_lines.lines_any().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

Leaving off the trailing character:

fn main() { let four_lines = "foo\r\nbar\n\r\nbaz\n"; let v: Vec<&str> = four_lines.lines_any().collect(); assert_eq!(v, ["foo", "bar", "", "baz"]); }
let four_lines = "foo\r\nbar\n\r\nbaz\n";
let v: Vec<&str> = four_lines.lines_any().collect();

assert_eq!(v, ["foo", "bar", "", "baz"]);

fn nfd_chars(&self) -> Decompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

Returns an iterator over the string in Unicode Normalization Form D (canonical decomposition).

fn nfkd_chars(&self) -> Decompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

Returns an iterator over the string in Unicode Normalization Form KD (compatibility decomposition).

fn nfc_chars(&self) -> Recompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

An Iterator over the string in Unicode Normalization Form C (canonical decomposition followed by canonical composition).

fn nfkc_chars(&self) -> Recompositions

Deprecated since 1.0.0

: use the crates.io unicode-normalization library instead

An Iterator over the string in Unicode Normalization Form KC (compatibility decomposition followed by canonical composition).

fn graphemes(&self, is_extended: bool) -> Graphemes

Deprecated since 1.0.0

: use the crates.io unicode-segmentation library instead

Returns an iterator over the grapheme clusters of self.

If is_extended is true, the iterator is over the extended grapheme clusters; otherwise, the iterator is over the legacy grapheme clusters. UAX#29 recommends extended grapheme cluster boundaries for general processing.

Examples

#![feature(unicode, core)] fn main() { let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"]; assert_eq!(&gr1[..], b); let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>(); let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; assert_eq!(&gr2[..], b); }
#![feature(unicode, core)]

let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>();
let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];

assert_eq!(&gr1[..], b);

let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>();
let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];

assert_eq!(&gr2[..], b);

fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices

Deprecated since 1.0.0

: use the crates.io unicode-segmentation library instead

Returns an iterator over the grapheme clusters of self and their byte offsets. See graphemes() for more information.

Examples

#![feature(unicode, core)] fn main() { let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>(); let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; assert_eq!(&gr_inds[..], b); }
#![feature(unicode, core)]

let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>();
let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];

assert_eq!(&gr_inds[..], b);

fn utf16_units(&self) -> Utf16Units

Unstable

: 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 self contains another &str.

Examples

fn main() { assert!("bananas".contains("nana")); assert!(!"bananas".contains("foobar")); }
assert!("bananas".contains("nana"));

assert!(!"bananas".contains("foobar"));

fn starts_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>

Returns true if the given &str is a prefix of the string.

Examples

fn main() { assert!("banana".starts_with("ba")); }
assert!("banana".starts_with("ba"));

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

Returns true if the given &str is a suffix of the string.

Examples

fn main() { assert!("banana".ends_with("nana")); }
assert!("banana".ends_with("nana"));

fn find<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>

Returns the byte index of the first character of self that matches the pattern, if it exists.

Returns None if it doesn't exist.

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

Examples

Simple patterns:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.find('L'), Some(0)); assert_eq!(s.find('é'), Some(14)); assert_eq!(s.find("Léopard"), Some(13)); }
let s = "Löwe 老虎 Léopard";

assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("Léopard"), Some(13));

More complex patterns with closures:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.find(char::is_whitespace), Some(5)); assert_eq!(s.find(char::is_lowercase), Some(1)); }
let s = "Löwe 老虎 Léopard";

assert_eq!(s.find(char::is_whitespace), Some(5));
assert_eq!(s.find(char::is_lowercase), Some(1));

Not finding the pattern:

fn main() { let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.find(x), None); }
let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

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

fn rfind<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

Returns the byte index of the last character of self that matches the pattern, if it exists.

Returns None if it doesn't exist.

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

Examples

Simple patterns:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind('L'), Some(13)); assert_eq!(s.rfind('é'), Some(14)); }
let s = "Löwe 老虎 Léopard";

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

More complex patterns with closures:

fn main() { let s = "Löwe 老虎 Léopard"; assert_eq!(s.rfind(char::is_whitespace), Some(12)); assert_eq!(s.rfind(char::is_lowercase), Some(20)); }
let s = "Löwe 老虎 Léopard";

assert_eq!(s.rfind(char::is_whitespace), Some(12));
assert_eq!(s.rfind(char::is_lowercase), Some(20));

Not finding the pattern:

fn main() { let s = "Löwe 老虎 Léopard"; let x: &[_] = &['1', '2']; assert_eq!(s.rfind(x), None); }
let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

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

fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>

An iterator over substrings of self, separated by characters matched by a pattern.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rsplit() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); let v: Vec<&str> = "".split('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); assert_eq!(v, ["lion", "", "tiger", "leopard"]); let v: Vec<&str> = "lion::tiger::leopard".split("::").collect(); assert_eq!(v, ["lion", "tiger", "leopard"]); let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect(); assert_eq!(v, ["abc", "def", "ghi"]); let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect(); assert_eq!(v, ["lion", "tiger", "leopard"]); }
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

A more complex pattern, using a closure:

fn main() { let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect(); assert_eq!(v, ["abc", "def", "ghi"]); }
let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "def", "ghi"]);

If a string contains multiple contiguous separators, you will end up with empty strings in the output:

fn main() { let x = "||||a||b|c".to_string(); let d: Vec<_> = x.split('|').collect(); assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); }
let x = "||||a||b|c".to_string();
let d: Vec<_> = x.split('|').collect();

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

This can lead to possibly surprising behavior when whitespace is used as the separator. This code is correct:

fn main() { let x = " a b c".to_string(); let d: Vec<_> = x.split(' ').collect(); assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]); }
let x = "    a  b c".to_string();
let d: Vec<_> = x.split(' ').collect();

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

It does not give you:

fn main() { assert_eq!(d, &["a", "b", "c"]); }
assert_eq!(d, &["a", "b", "c"]);

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

An iterator over substrings of self, separated by characters matched by a pattern and yielded in reverse order.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, split() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect(); assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]); let v: Vec<&str> = "".rsplit('X').collect(); assert_eq!(v, [""]); let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect(); assert_eq!(v, ["leopard", "tiger", "", "lion"]); let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect(); assert_eq!(v, ["leopard", "tiger", "lion"]); }
let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);

let v: Vec<&str> = "".rsplit('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
assert_eq!(v, ["leopard", "tiger", "", "lion"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);

A more complex pattern, using a closure:

fn main() { let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect(); assert_eq!(v, ["ghi", "def", "abc"]); }
let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "def", "abc"]);

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

An iterator over substrings of self, separated by characters matched by a pattern.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Equivalent to split, except that the trailing substring is skipped if empty.

This method can be used for string data that is terminated, rather than separated by a pattern.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rsplit_terminator() can be used.

Examples

fn main() { let v: Vec<&str> = "A.B.".split_terminator('.').collect(); assert_eq!(v, ["A", "B"]); let v: Vec<&str> = "A..B..".split_terminator(".").collect(); assert_eq!(v, ["A", "", "B", ""]); }
let v: Vec<&str> = "A.B.".split_terminator('.').collect();
assert_eq!(v, ["A", "B"]);

let v: Vec<&str> = "A..B..".split_terminator(".").collect();
assert_eq!(v, ["A", "", "B", ""]);

fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, P::Searcher: ReverseSearcher<'a>

An iterator over substrings of self, separated by characters matched by a pattern and yielded in reverse order.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Equivalent to split, except that the trailing substring is skipped if empty.

This method can be used for string data that is terminated, rather than separated by a pattern.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, split_terminator() can be used.

Examples

fn main() { let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect(); assert_eq!(v, ["B", "A"]); let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect(); assert_eq!(v, ["", "B", "", "A"]); }
let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
assert_eq!(v, ["B", "A"]);

let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
assert_eq!(v, ["", "B", "", "A"]);

fn splitn<'a, P>(&'a self, count: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>

An iterator over substrings of self, separated by a pattern, restricted to returning at most count items.

The last element returned, if any, will contain the remainder of the string. The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will not be double ended, because it is not efficient to support.

If the pattern allows a reverse search, rsplitn() can be used.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect(); assert_eq!(v, ["Mary", "had", "a little lambda"]); let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect(); assert_eq!(v, ["lion", "", "tigerXleopard"]); let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect(); assert_eq!(v, ["abcXdef"]); let v: Vec<&str> = "".splitn(1, 'X').collect(); assert_eq!(v, [""]); }
let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
assert_eq!(v, ["Mary", "had", "a little lambda"]);

let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
assert_eq!(v, ["lion", "", "tigerXleopard"]);

let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
assert_eq!(v, ["abcXdef"]);

let v: Vec<&str> = "".splitn(1, 'X').collect();
assert_eq!(v, [""]);

A more complex pattern, using a closure:

fn main() { let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect(); assert_eq!(v, ["abc", "defXghi"]); }
let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "defXghi"]);

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

An iterator over substrings of self, separated by a pattern, starting from the end of the string, restricted to returning at most count items.

The last element returned, if any, will contain the remainder of the string.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will not be double ended, because it is not efficient to support.

splitn() can be used for splitting from the front.

Examples

Simple patterns:

fn main() { let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect(); assert_eq!(v, ["lamb", "little", "Mary had a"]); let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect(); assert_eq!(v, ["leopard", "tiger", "lionX"]); let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect(); assert_eq!(v, ["leopard", "lion::tiger"]); }
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);

A more complex pattern, using a closure:

fn main() { let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect(); assert_eq!(v, ["ghi", "abc1def"]); }
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);

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

An iterator over the matches of a pattern within self.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rmatches() can be used.

Examples

fn main() { let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect(); assert_eq!(v, ["1", "2", "3"]); }
let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);

let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
assert_eq!(v, ["1", "2", "3"]);

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

An iterator over the matches of a pattern within self, yielded in reverse order.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, matches() can be used.

Examples

fn main() { let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect(); assert_eq!(v, ["abc", "abc", "abc"]); let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect(); assert_eq!(v, ["3", "2", "1"]); }
let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);

let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
assert_eq!(v, ["3", "2", "1"]);

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

Unstable

: might have its iterator type changed

An iterator over the start and end indices of the disjoint matches of a pattern within self.

For matches of pat within self that overlap, only the indices corresponding to the first match are returned.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator will be double ended if the pattern allows a reverse search and forward/reverse search yields the same elements. This is true for, eg, char but not for &str.

If the pattern allows a reverse search but its results might differ from a forward search, rmatch_indices() can be used.

Examples

#![feature(str_match_indices)] fn main() { let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); assert_eq!(v, [(0, 3), (6, 9), (12, 15)]); let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); assert_eq!(v, [(1, 4), (4, 7)]); let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); assert_eq!(v, [(0, 3)]); // only the first `aba` }
#![feature(str_match_indices)]

let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, 3), (6, 9), (12, 15)]);

let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, 4), (4, 7)]);

let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, 3)]); // only the first `aba`

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

Unstable

: might have its iterator type changed

An iterator over the start and end indices of the disjoint matches of a pattern within self, yielded in reverse order.

For matches of pat within self that overlap, only the indices corresponding to the last match are returned.

The pattern can be a simple &str, char, or a closure that determines the split. Additional libraries might provide more complex patterns like regular expressions.

Iterator behavior

The returned iterator requires that the pattern supports a reverse search, and it will be double ended if a forward/reverse search yields the same elements.

For iterating from the front, match_indices() can be used.

Examples

#![feature(str_match_indices)] fn main() { let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect(); assert_eq!(v, [(12, 15), (6, 9), (0, 3)]); let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect(); assert_eq!(v, [(4, 7), (1, 4)]); let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect(); assert_eq!(v, [(2, 5)]); // only the last `aba` }
#![feature(str_match_indices)]

let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, 15), (6, 9), (0, 3)]);

let v: Vec<(usize, usize)> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, 7), (1, 4)]);

let v: Vec<(usize, usize)> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, 5)]); // only the last `aba`

fn subslice_offset(&self, inner: &str) -> usize

Deprecated since 1.3.0

: replaced with other pattern-related methods

Returns the byte offset of an inner slice relative to an enclosing outer slice.

Panics

Panics if inner is not a direct slice contained within self.

Examples

#![feature(subslice_offset)] fn main() { let string = "a\nb\nc"; let lines: Vec<&str> = string.lines().collect(); assert!(string.subslice_offset(lines[0]) == 0); // &"a" assert!(string.subslice_offset(lines[1]) == 2); // &"b" assert!(string.subslice_offset(lines[2]) == 4); // &"c" }
#![feature(subslice_offset)]

let string = "a\nb\nc";
let lines: Vec<&str> = string.lines().collect();

assert!(string.subslice_offset(lines[0]) == 0); // &"a"
assert!(string.subslice_offset(lines[1]) == 2); // &"b"
assert!(string.subslice_offset(lines[2]) == 4); // &"c"

fn trim(&self) -> &str

Returns a &str with leading and trailing whitespace removed.

Examples

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

fn trim_left(&self) -> &str

Returns a &str with leading whitespace removed.

Examples

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

fn trim_right(&self) -> &str

Returns a &str with trailing whitespace removed.

Examples

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

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

Returns a string with all pre- and suffixes that match a pattern repeatedly removed.

The pattern can be a simple char, or a closure that determines the split.

Examples

Simple patterns:

fn main() { assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_matches(x), "foo1bar"); }
assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");

A more complex pattern, using a closure:

fn main() { assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar"); }
assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");

fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>

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

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

Examples

fn main() { assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11"); assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12"); }
assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");

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

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

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

Examples

Simple patterns:

fn main() { assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar"); assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar"); let x: &[_] = &['1', '2']; assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar"); }
assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");

A more complex pattern, using a closure:

fn main() { assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX"); }
assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX");

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

Parses self into the specified type.

Failure

Will return Err if it's not possible to parse self into the type.

Example

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

Failing:

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

fn replace(&self, from: &str, to: &str) -> String

Replaces all occurrences of one string with another.

replace takes two arguments, a sub-&str to find in self, and a second &str to replace it with. If the original &str isn't found, no change occurs.

Examples

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

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

When a &str isn't found:

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

fn to_lowercase(&self) -> String

Returns the lowercase equivalent of this string.

Examples

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

fn to_uppercase(&self) -> String

Returns the uppercase equivalent of this string.

Examples

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

fn escape_default(&self) -> String

Unstable

: return type may change to be an iterator

Escapes each char in s with char::escape_default.

fn escape_unicode(&self) -> String

Unstable

: return type may change to be an iterator

Escapes each char in s with char::escape_unicode.

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

Unstable

: recently added, matches RFC

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

Trait Implementations

impl Borrow<str> for String

fn borrow(&self) -> &str

impl FromIterator<char> for String

fn from_iter<I>(iter: I) -> String where I: IntoIterator<Item=char>

impl<'a> FromIterator<&'a str> for String

fn from_iter<I>(iter: I) -> String where I: IntoIterator<Item=&'a str>

impl Extend<char> for String

fn extend<I>(&mut self, iterable: I) where I: IntoIterator<Item=char>

impl<'a> Extend<&'a char> for String

fn extend<I>(&mut self, iter: I) where I: IntoIterator<Item=&'a char>

impl<'a> Extend<&'a str> for String

fn extend<I>(&mut self, iterable: I) where I: IntoIterator<Item=&'a str>

impl<'a, 'b> Pattern<'a> for &'b String

A convenience impl that delegates to the impl for &str

type Searcher = &'b str::Searcher

fn into_searcher(self, haystack: &'a str) -> &'b str::Searcher

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

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

fn is_suffix_of(self, haystack: &'a str) -> bool where Self::Searcher: ReverseSearcher<'a>

impl PartialEq<String> for String

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

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

impl<'a> PartialEq<str> for String

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

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

impl<'a> PartialEq<&'a str> for String

fn eq(&self, other: &&'a str) -> bool

fn ne(&self, other: &&'a str) -> bool

impl<'a> PartialEq<Cow<'a, str>> for String

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

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

impl Default for String

fn default() -> String

impl Display for String

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

impl Debug for String

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

impl Hash for String

fn hash<H>(&self, hasher: &mut H) where H: Hasher

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

impl<'a> Add<&'a str> for String

type Output = String

fn add(self, other: &str) -> String

impl Index<Range<usize>> for String

type Output = str

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

impl Index<RangeTo<usize>> for String

type Output = str

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

impl Index<RangeFrom<usize>> for String

type Output = str

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

impl Index<RangeFull> for String

type Output = str

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

impl IndexMut<Range<usize>> for String

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

impl IndexMut<RangeTo<usize>> for String

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

impl IndexMut<RangeFrom<usize>> for String

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

impl IndexMut<RangeFull> for String

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

impl Deref for String

type Target = str

fn deref(&self) -> &str

impl DerefMut for String

fn deref_mut(&mut self) -> &mut str

impl FromStr for String

type Err = ParseError

fn from_str(s: &str) -> Result<String, ParseError>

impl AsRef<str> for String

fn as_ref(&self) -> &str

impl AsRef<[u8]> for String

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

impl<'a> From<&'a str> for String

fn from(s: &'a str) -> String

impl Into<Vec<u8>> for String

fn into(self) -> Vec<u8>

impl IntoCow<'static, str> for String

fn into_cow(self) -> Cow<'static, str>

impl Write for String

fn write_str(&mut self, s: &str) -> Result<(), Error>

fn write_char(&mut self, c: char) -> Result<(), Error>

fn write_fmt(&mut self, args: Arguments) -> Result<(), Error>

impl OwnedAsciiExt for String

fn into_ascii_uppercase(self) -> String

fn into_ascii_lowercase(self) -> String

impl AsRef<OsStr> for String

fn as_ref(&self) -> &OsStr

impl AsRef<Path> for String

fn as_ref(&self) -> &Path

Derived Implementations

impl Ord for String

fn cmp(&self, __arg_0: &String) -> Ordering

impl Eq for String

impl PartialOrd<String> for String

fn partial_cmp(&self, __arg_0: &String) -> Option<Ordering>

fn lt(&self, __arg_0: &String) -> bool

fn le(&self, __arg_0: &String) -> bool

fn gt(&self, __arg_0: &String) -> bool

fn ge(&self, __arg_0: &String) -> bool

impl Clone for String

fn clone(&self) -> String

fn clone_from(&mut self, source: &Self)