Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Questões - String and &str

01 - Escreva um código que crie uma string vazia e a imprima.

Playground!

Resposta 
fn main() {
    let cria_string: String = String::new();
    println!("{}", cria_string);
}

02 - Crie uma string a partir do literal de string "Pequeno, texto!".

Playground!

Resposta 
fn main() {
    let literal_string: String = String::from("Pequeno, texto!");
    println!("{}", literal_string);
}

03 - Declare uma variável que contenha &str com o valor "Aprendendo Rust".

Playground!

Resposta 
fn main() {
    let texto: &str = "Aprendendo Rust";
    println!("{}", texto);
}

04 - Dada uma string, escreva o código para obter um &str que represente toda a string.

Playground!

Resposta 
fn main() {
    let entrada_string: String = String::from("Aprendendo Rust!");
    let entrada_str: &str = &entrada_string;
    println!("{}", entrada_str);
}
fn main() {
    let entrada_string: String = String::from("Aprendendo Rust!");
    let entrada_str: &str = entrada_string.as_str();
    println!("{}", entrada_str);
}

05 - Escreva um código que receba um texto em string e o converta para &str e, em seguida, o imprima na tela.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_string: String = String::new();
    io::stdin()
        .read_line(&mut entrada_string)
        .expect("Erro de entrada de dados!");
    let texto_string: &str = entrada_string.as_str();
    println!("\nTexto convertido para &str: {}", texto_string.trim());
}

06 - Converta um string = 123 em um inteiro.

Playground!

Resposta 
fn main() {    
    let text: &str = "123";
    let num: u8 = text.parse().expect("Erro ao converter dados!");
    println!("{}", num);    
}
fn main() {
    let text: &str = "123";
     
    let num = match text.parse::<u8>() {
        Ok(num) => num,
        Err(_) => {
            println!("Erro ao converter dados!");
            return;
        }
    };
    println!("{}", num);
}

07 - Use o método .to_string() ou String::from() para criar uma nova string concatenando um &str e uma string existente.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_texto: String = String::new();
    io::stdin()
        .read_line(&mut entrada_texto)
        .expect("Erro de entrada de dados!");

    let texto_a: &str = &entrada_texto.as_str().trim();
    let texto_b: String = String::from(" + string!");

    println!("{}", texto_a.to_string() + &texto_b);
}

08 - Crie uma string mutável e anexe um &str a ela usando o método push_str().

Playground!

Resposta 
fn main() {
    let mut string_mutavel: String = String::from("Pequeno, ");
    string_mutavel.push_str("texto!");
    println!("{}", string_mutavel);
}

09 - Adicione um único caractere (char) ao final de uma string mutável.

Playground!

Resposta 
fn main() {    
    let mut unico_char: String = String::from("Pequeno, texto");
    let caractere: char = '!';

    unico_char.push(caractere);
    println!("{}", unico_char);
}

10 - Combine um &str, uma string e um número em uma nova string usando a macro format!.

Playground!

Resposta 
fn main() {
    let var_str: &str = "1";
    let var_string: String = String::from("2");
    let var_u8: u8 = 3;

    // a macro format! cria uma nova string
    let result = format!("{}{}{}", var_str, var_string, var_u8);
    println!("{}", result);
}

11 - Crie uma nova string removendo todos os espaços em branco de uma string.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    let remove_espaco = entrada_texto.replace(" ", "");
    println!("\nSem espaços = {}", remove_espaco.trim());
}

12 - Substitua todas as ocorrências da substring erro por sucesso em um &str, criando uma nova string.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    let novo_texto = entrada_texto.replace("erro", "sucesso");
    println!("{}", novo_texto);
}

13 - Substitua apenas a primeira ocorrência de antes por depois em um &str, criando uma nova string.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    let frase = entrada_frase.replacen("antes", "depois", 1);
    println!("{}", frase);
}

14 - Verifique se um &str contém a substring Rust.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    if entrada_texto.contains("Rust") {
        println!("\n{} - contém 'Rust'", entrada_texto.trim());
    } else {
        println!("\n{} - não contém 'Rust'", entrada_texto.trim());
    }
}

15 - Verifique se um nome de arquivo em uma string termina com o sufixo .rs

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com o nome do arquivo:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    if entrada_texto.trim().ends_with(".rs") {
        println!("\n{} - termina com '.rs'", entrada_texto.trim());
    } else {
        println!("\n{} - não termina com '.rs'", entrada_texto.trim());
    }
}

16 - Verifique se um &str começa com o prefixo https://.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com link:");
    let mut entrada_link: String = String::new();
    io::stdin().read_line(&mut entrada_link).err();

    if entrada_link.starts_with("https://") {
        println!("\n{} - começa com 'https://'", entrada_link.trim());
    } else {
        println!("\n{} - não começa com 'https://'", entrada_link.trim());
    }
}

17 - Crie um código que receba uma string e retorne uma fatia contendo apenas a primeira palavra. Assuma que as palavras são separadas por espaços.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    let frase = entrada_frase.split_whitespace().next();
    println!("{}", frase.unwrap());
}

18 - Encontre o índice de byte inicial da primeira ocorrência da substring rust.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com a frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    if let Some(indice) = entrada_frase.find("rust") {
        println!("\nÍndice de bytes: {}", indice);
    } else {
        println!("\nNão tem: rust");
    }
}

19 - Escreva uma função que aceite uma string e retorne seu primeiro caractere como um char.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com a palavra:");
    let mut entrada_palavra: String = String::new();
    io::stdin().read_line(&mut entrada_palavra).err();

    let primeira_letra: char = entrada_palavra.trim_start().chars().next().unwrap_or(' ');
    println!("Primeira letra = {}", primeira_letra);
}

20 - Escreva um código que conte o número de caracteres (char) em um &str, não o número de bytes.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com uma palavra:");
    let mut entrada_palavra: String = String::new();
    io::stdin().read_line(&mut entrada_palavra).err();

    let palavra = entrada_palavra.trim().replace(" ", "");
    println!("{}", palavra);
    println!("{:?}", palavra.chars().count());
}

21 - Escreva um código que receba um &mut string e substitua todos os caracteres a minúsculos por A maiúsculos, modificando a string original.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    let frase = entrada_frase.trim().replace("a", "A");
    println!("{}", frase);    
}

22 - Escreva um código que remova o último caractere de uma string.

Playground!

Resposta 
use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_palavra: String = String::new();
    io::stdin()
        .read_line(&mut entrada_palavra)
        .expect("Erro de entrada de dados!");

    let mut palavra: String = entrada_palavra.trim_end().to_string();
    palavra.pop();
    println!("{}", palavra);
}

23 - Use o método .clear() para limpar uma string sem desalocar sua capacidade de memória.

Playground!

Resposta 
fn main() {
    let mut var_string: String = String::with_capacity(50);
    var_string.push_str("Pequeno, grande texto!");

    println!("String = {}", var_string);
    println!("Capacidade = {}", var_string.capacity());
    println!("Tamanho = {}", var_string.len());
    println!("");

    var_string.clear();
    println!("String = {}", var_string);
    println!("Capacidade = {}", var_string.capacity());
    println!("Tamanho = {}", var_string.len());
}