Rust String Length

One of the most common string operations in programming is determining the length of a string. As with most modern programming languages, it is a common task to determine the length of a string in a given program.

Rust is known for its emphasis on safety and performance; finding the length of a string is a straightforward task. Rust provides several methods to obtain the length of a string, each with its advantages and use cases.

Since strings are a fundamental part of many programs, understanding how to work efficiently with their lengths can significantly improve the code performance and quality.

This tutorial explores the different ways to obtain the length of a string in Rust and provides insights into the best practices and pitfalls to watch out for.

Method 1: Using the Len() Method

The first and most common method of fetching a string’s length in Rust is using the len() method.

The function syntax is as follows:

string.len()

In this case, the string refers to the actual string variable whose length you wish to determine.

The function then returns the number of bytes of the input string which denotes its length. An example usage is demonstrated in the following code snippet:

fn main() {
let my_string = String::from("hello, world!");
let length = my_string.len();
println!("The length of the string is: {}", length);
}

Once we run the previous code, it should print the length of the string as follows:

The length of the string is: 13

Method 2: Using the Chars() Method

The second method that we can use to fetch the length of a Rust string is the chars() method. The chars() method returns an iterator over the characters in a given string. We can then count the number of characters that is produced by the iterator to determine the length of the string.

Consider the following example demonstration:

fn main() {
let my_string = String::from("hello, world!");
let length = my_string.chars().count();
println!("The length of the string is: {}", length);
}

Method 3: Using the Bytes() Method

We also have access to the bytes() method in Rust. This method works similarly to the chars() method but instead returns an iterator over the bytes of the string. Hence, we can use the produced bytes to calculate the length of the string.

Take the following example code:

fn main() {
let my_string = String::from("hello, world!");
let length = my_string.bytes().count();
println!("The length of the string is: {}", length);
}

Resulting Output:

The length of the string is: 13

Method 4: Using the Graphemes() Method

The final and probably less common method to determine the length of a string in Rust is using the graphemes() method.

This method returns an iterator over the grapheme clusters in a string. If you are not familiar, a grapheme cluster refers to a sequence of one or more Unicode characters used that combine to represent a single visual character.

You can learn more about that here:

http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries

This method is useful if you work with languages that use the diacritic marks such as ligatures. The following example code demonstrates how we can use this function:

use unicode_segmentation::UnicodeSegmentation;
fn main() {
let my_string = String::from("café");
let length = my_string.graphemes(true).count();
println!("The length of the string is: {}", length);
}

As you can guess, the function returns the length of the string as follows:

The length of the string is: 4

You can learn more about Unicode segmentation as shown in the following:

https://crates.io/crates/unicode-segmentation

Conclusion

You now understood that obtaining the length of a string in Rust is an essential skill for any Rust programmer. Rust provides several methods to efficiently determine the length of a string, each with its advantages and use cases as demonstrated in this post.

Choosing the suitable method is determined by your specific use case and the type of characters or glyphs used in the string.