How to get the last character of a &str?

One option is to use slices. Here's an example:

let len = my_str.len();
let final_str = &my_str[len-1..];

This returns a string slice from position len-1 through the end of the string. That is to say, the last byte of your string. If your string consists of only ASCII values, then you'll get the final character of your string.

The reason why this only works with ASCII values is because they only ever require one byte of storage. Anything else, and Rust is likely to panic at runtime. This is what happens when you try to slice out one byte from a 2-byte character.

For a more detailed explanation, please see the strings section of the Rust book.

That is how you get the last char (which may not be what you think of as a "character"):

mystring.chars().last().unwrap();

Use unwrap only if you are sure that there is at least one char in your string.

---

Warning: About the general case (do the same thing as mystring[-n] in Python): UTF-8 strings are not to be used through indexing, because indexing is not a O(1) operation (a string in Rust is not an array). Please read this for more information.

However, if you want to index from the end like in Python, you must do this in Rust:

mystring.chars().rev().nth(n - 1) // Python: mystring[-n]

and check if there is such a character.

If you miss the simplicity of Python syntax, you can write your own extension:

trait StrExt {
    fn from_end(&self, n: usize) -> char;
}

impl<'a> StrExt for &'a str {
    fn from_end(&self, n: usize) -> char {
        self.chars().rev().nth(n).expect("Index out of range in 'from_end'")
    }
}

fn main() {
    println!("{}", "foobar".from_end(2)) // prints 'b'
}

As @Boiethios mentioned

let last_ch = mystring.chars().last().unwrap();

Or

let last_ch = codes.chars().rev().nth(0).unwrap();

I would rather have (how hard is that!?)

let last_ch = codes.chars(-1); // Not implemented as rustc 1.56.1