Learn Rust Coding · Aula

Strings e &str

Texto com propriedade e emprestado

Strings e &str é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Dois tipos de string

Rust tem dois tipos principais de texto:

String — uma string com propriedade e expansível.
&str — uma fatia de string emprestada, uma visão do texto.

fn main() {
    let owned: String = String::from("hello");
    let borrowed: &str = "world";
    println!("{} {}", owned, borrowed);
}

Literais de string são &str

Quando o texto é escrito entre aspas duplas, obtém-se um &str. Ele tem tamanho fixo e é armazenado no binário do programa.

fn main() {
    let greeting = "Hi there"; // type is &str
    println!("{}", greeting);
}

Criando uma String

Crie uma String com propriedade usando String::from ou o método .to_string().

fn main() {
    let a = String::from("abc");
    let b = "xyz".to_string();
    println!("{} {}", a, b);
}

Expandindo uma String

Como String tem propriedade e pode crescer, você pode acrescentar texto usando push_str e push.

fn main() {
    let mut s = String::from("Hello");
    s.push_str(", ");
    s.push_str("Rust");
    s.push('!');
    println!("{}", s);
}

Concatenação

Una strings usando o operador + ou a macro format!. format! não consome suas entradas.

fn main() {
    let first = String::from("Hello");
    let second = String::from("World");
    let joined = format!("{} {}", first, second);
    println!("{}", joined);
}

Fazendo empréstimo de uma String como &str

Uma String pode ser emprestada automaticamente como um &str. Isso permite que as funções aceitem qualquer um dos dois tipos.

fn print_text(text: &str) {
    println!("text: {}", text);
}

fn main() {
    let owned = String::from("owned");
    print_text(&owned);
    print_text("literal");
}

Por que preferir parâmetros &str

As funções geralmente recebem &str em vez de String. Isso é mais flexível: quem chama pode passar strings com propriedade, literais ou fatias.

fn shout(s: &str) -> String {
    s.to_uppercase()
}

fn main() {
    println!("{}", shout("quiet"));
}

Tamanho em bytes

O método len() retorna o tamanho em bytes, não em caracteres. Um texto ASCII tem um byte por caractere.

fn main() {
    let s = "hello";
    println!("{} bytes", s.len());
}

Verificando o conteúdo

Entre os métodos úteis de leitura estão contains, starts_with e is_empty.

fn main() {
    let s = "hello world";
    println!("{}", s.contains("world"));
    println!("{}", s.starts_with("hello"));
}

Diferença de propriedade

Uma String é proprietária dos próprios dados na memória heap e é responsável por liberá-los. Um &str apenas faz empréstimo de dados existentes e não é proprietário de nada.

fn main() {
    let owned = String::from("data");
    let view: &str = &owned[0..2];
    println!("owned {} view {}", owned, view);
}

Convertendo entre os dois tipos

Converta de um tipo para o outro:

&str para String: .to_string() ou String::from.
String para &str: &s ou s.as_str().

fn main() {
    let s = String::from("convert");
    let slice: &str = s.as_str();
    let back: String = slice.to_string();
    println!("{} {}", slice, back);
}

Verificação rápida

Recorde a diferença entre os dois tipos de texto.

Recapitulação

Strings em Rust:

String — com propriedade, expansível e alocada na memória heap.
&str — fatia ou visão emprestada, usada pelos literais.
Crie com String::from ou to_string(); expanda com push_str.
Prefira &str nos parâmetros de funções.

fn main() {
    let mut msg = String::from("Rust");
    msg.push_str(" rocks");
    let view: &str = &msg;
    println!("{} ({} bytes)", view, view.len());
}

Perguntas Frequentes

A aula “Strings e &str” é grátis?

Sim — o texto completo de “Strings e &str” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Strings e &str”?

Texto com propriedade e emprestado Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Strings e &str”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding