String - rust-course

The String type is a wrapper around Vec<u8> that handles UTF-8 strings allocated inside the heap memory.

See Table 1 for a partial list of its methods and String for the full list.

Table 1:Some methods of String

Method	Description
`as_bytes()`	Returns a byte slice.
`as_mut_str()`	Returns a mutable string slice.
`as_str()`	Returns a string slice.
`capacity()`	Returns the instance’s capacity in bytes.
`clear()`	Removes all characters.
`drain(r)`	Removes a range of characters and returns an iterator on them.
`from(s)`	Creates a string from a literal string.
`insert(i, c)`	Inserts a character at the specified index.
`insert_str(i, s)`	Inserts a string slice at the specified index.
`into_bytes()`	Converts (and consumes) the `String` into a `Vec<u8>`.
`is_empty()`	Returns `true` if the instance contains no character.
`len()`	Returns the number of bytes of the string.
`new()`	Creates an empty string.
`pop()`	Removes and returns the last character.
`push(c)`	Appends one character to the string.
`push_str(s)`	Appends a string slice to the string.
`remove(i)`	Removes and returns the character at the specified index.
`replace_range(r, s)`	Replaces a range of characters by a string slice.
`reserve(n)`	Reserves additional memory space (i.e.: increases the capacity).
`shrink_to(n)`	Shrinks the capacity to specified size.
`shrink_to_fit()`	Shrinks the capacity in order to match length.
`truncate(n)`	Shortens the string to the specified length.
`with_capacity(n)`	Creates a new empty `String` with the specified capacity.

18.2.1New empty string¶

The new() method builds a new empty string:

let s = String::new();
s

Couldn't automatically determine type of variable `s`.
Please give it an explicit type.

18.2.2New instance from literal string¶

Using the from() method, we can build a String instance from a literal string:

let s = String::from("abc");
s

18.2.3Appending to a String object¶

The push() method appends a character to a string:

let mut s = String::new();
s.push('a'); // Append a single character
s

The push_str() method appends a string slice to a string:

let mut s = String::new();
s.push_str("def");
s

18.2.4format!() macro¶

The format!() macro allows to build a String instance using formatting codes from fmt module.

Plain literal strings are transformed into String objects:

let s = format!("My string");
s

However the real advantage of the format!() macro is the formatting instructions inserted with curly brackets ({}). In the following example we use the curly brackets notation to insert the value of the variable n:

let n = 10;
let s = format!("Number: {n}");
s

In the following example, we use format!() to concatenate two strings:

let s1 = String::from("abc");
let s2 = String::from("def");
let s3 = format!("{s1}{s2}");
s3

String alignment:

let s = "abc";
format!("#{s:<7}#{s:.<7}#{s:^7}#{s:>7}#")

Formatting a zero padded integer:

let n = 16;
format!("{n:05}")

Formatting a floating-point number:

let x = 1893.7834;
format!("{x} {x:.5} {x:.2} {x:.3e} {x:.2E}")

Formatting an integer into binary, octal or hexadecimal:

let n = 170;
format!("{n:b} {n:o} {n:x} {n:X} {n:04x}")

Formatting a complex object using the Debug formatter:

let t = (1.5, "abc", true);
format!("{t:?}")

see solution

18.2 String

18.2.1New empty string¶

18.2.2New instance from literal string¶

18.2.3Appending to a String object¶

18.2.4format!() macro¶