O tipo de dado string é uma cadeia de caracteres justapostos. Abaixo uma abstração da representação de uma string em um local de memória. Por padrão, strings em Rust utilizam a codificação UTF-8.

Tab. 1: String em memória

0	1	2	3	4	5
's'	't'	'r'	'i'	'n'	'g'

Para declarar um string somente-leitura em Rust utilizamos a sintaxe a seguir:

Sintaxe:

let nome_variavel:&str = "conteúdo da string literal";

Exemplo 1

fn main() {
   let variavel = "uma string em rust";
   println!("{}",variavel);
}

Saída

uma string em rust

Para declarar uma string como objeto, utilizamos a sintaxe abaixo:

Sintaxe:

let variavel:String = String::new("conteudo_string");

Exemplo 2

fn main() {
   
   let variavel = String::from("um string em rust");
   println!("{}",variavel);
}

Saída

um string em rust

Quando queremos criar um objeto string sem valor inicial, utilizamos o método new. Esse não recebe nenhum argumento.

Sintaxe:

let variavel:String = String::new();

Exemplo 3

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

Saída

-

Em Rust não podemos acessar um elemento em específico de uma string &str ou String como em outras linguagens no estilo-C que utilizam o indexador [] devido à codificação padrão. Esse acesso é feito utilizando o método nth do tipo Chars retornado pelo método chars.

Sintaxe:

variavel_string.chars().nth(indice_elemento);

Exemplo 4

fn main() {
 
   let string_obj: String = String::from("Uma string qualquer");
   let mchar: Option<char> = string_obj.chars().nth(0);
   println!("{}", mchar.unwrap());
}

Saída

U

O assunto Option será visto com mais informações em Rust > Tipos Derivados > Option.

Tanto para string literal ou objeto String, para percorrermos o conteúdo de uma string podemos utilizar, por exemplo, o comando for, já visto, em conjunto com o método chars.

Sintaxe:

pub fn chars(&self) -> Chars<'_>

Exemplo 5

fn main() {
 
   //usando from
   let variavel1:&str = "Rust";
   
   let variavel2:String = String::from("Rust");
   
   for c in variavel1.chars(){
        println!("{}",c);       
   }
   
   for c in variavel2.chars(){
        println!("{}",c);       
   }
}

Saída

R
u
s
t
R
u
s
t

Para saber do número de elementos ou caracteres em um string, precisamos recuperar os caracteres da string e contar o número de elementos. Isso é feito com o método count do tipo Chars.

Sintaxe:

fn count(self) -> usize

Exemplo 6

fn main() {

    let text = "string"; //UTF-8
    let elementos = text.chars();
    println!("{}", elementos.count());
}

Saída

6

Para ter conhecimento do tamanho da string em bytes, devemos utilizar o método len do tipo string:

Sintaxe:

fn len(self) -> usize

Exemplo 7

fn main() {

    let text = "stringç"; //UTF-8
    println!("{}", text.len());
}

Saída

8

A alteração do conteúdo de uma string é feita via métodos do tipo String como to_uppercase, to_lowercase ou replace, por exemplo.

Sintaxe:

fn to_lowercase(&self) -> String
fn to_uppercase(&self) -> String
fn replace<P>(&self, from: P, to: &str) -> String

Onde:

from: substring a ser substituída
to: substring para substituição

Exemplo 8

fn main(){

    let var_str:String = String::from("sTRiNg");
    
    println!("{}", var_str.to_lowercase());
    println!("{}", var_str.to_uppercase());
    
    let ret = var_str.replace("sTRi", "stru");
    println!("{}", ret);
}

Saída

string
STRING
struNg

Comparar strings em Rust pode ser feita com auxílio dos operadores "==" ou "!=" como pode ser visto na sintaxe abaixo:

Sintaxe:

string1 == string2
string1 != string2

Exemplo 9

fn main(){

    let string1 = "string";  //mesmo case
    let string2 = "string"; 
    
    println!("{}", string1 == string2);
    println!("{}", string1 != string2);
}

Saída

true
false

A comparação lexicográfica é feita utilizando os operadores <, <=, > ou >= como pode ser visto na sintaxe a seguir:

Sintaxe:

string1 >= string2
string1 <= string2
string1 < string2
string1 > string2

Exemplo 10

fn main(){

    let string1 = "ana";
    let string2 = "ano"; 
    
    println!("{}", string1 < string2);
    println!("{}", string1 > string2);
}

Saída

true
false

Para a verificação se uma string está vazia, utilizamos o método is_empty. Caso essa string contenha apenas espaços em branco, utilizamos o método trim e is_empty como pode ser conferido abaixo:

Sintaxe:

fn is_empty(&self) -> bool
fn trim(&self) -> &str

Exemplo 11

fn main() {

    let mstr1: &str = "uma string";
    let mstr2: &str = " ";
    
    println!("{}", mstr1.is_empty()); //não vazia
    println!("{}", mstr2.is_empty()); //não vazia com espaço em branco
    println!("{}", mstr2.trim().is_empty()); //vazia sem espacos em branco
}

Saída

false
false
true

1. 17/08/2026 - versão inicial: declaração, acesso, iteração, 'número de elementos', alteração, comparação e verificação.