Learn Rust Coding · Aula

use e caminhos

Importe itens

use e caminhos é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 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.

Trazendo itens para o escopo

Digitar caminhos completos como std::collections::HashMap em todos os lugares é trabalhoso. A palavra-chave use traz um item para o escopo, permitindo referenciá-lo por um nome curto.

Um use básico

Depois de um use, você referencia o item pelo nome final. Aqui, importamos HashMap e o usamos diretamente.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("ana", 10);
    println!("{:?}", scores.get("ana"));
}

Caminhos absolutos e relativos

Um caminho absoluto começa em crate (a raiz do crate). Um caminho relativo começa no módulo atual, usando opcionalmente self ou super.

mod a {
    pub mod b {
        pub fn hi() { println!("hi from b"); }
    }
    pub fn call_b() {
        crate::a::b::hi();
        self::b::hi();
    }
}

fn main() {
    a::call_b();
}

use dentro de módulos

Um use afeta apenas o escopo em que aparece. Coloque-o no início de um módulo para encurtar os nomes usados em todo esse módulo.

mod work {
    use std::collections::HashSet;
    pub fn run() {
        let mut s = HashSet::new();
        s.insert(1);
        s.insert(1);
        println!("size {}", s.len());
    }
}

fn main() {
    work::run();
}

Renomeando com as

Quando dois itens têm o mesmo nome ou quando um nome é longo demais, renomeie-o durante a importação com as.

use std::collections::HashMap as Map;

fn main() {
    let mut m: Map<&str, i32> = Map::new();
    m.insert("x", 1);
    println!("{:?}", m.get("x"));
}

Agrupando importações

Importe vários itens do mesmo caminho em uma única linha usando chaves. Isso mantém o bloco de importações organizado.

use std::collections::{HashMap, HashSet};

fn main() {
    let map: HashMap<i32, i32> = HashMap::new();
    let set: HashSet<i32> = HashSet::new();
    println!("{} {}", map.len(), set.len());
}

Grupos aninhados e self

Dentro de um grupo, self importa o próprio módulo junto com seus itens. Isso permite usar tanto o nome do módulo quanto membros específicos.

use std::io::{self, Write};

fn main() {
    let _ = io::stdout().write_all(b"hello\n");
}

Importações globais

O caractere global * traz tudo que é público de um caminho. Use-o com moderação — ele pode ocultar a origem dos nomes —, mas é comum em preâmbulos e testes.

mod colors {
    pub fn red() -> &'static str { "red" }
    pub fn blue() -> &'static str { "blue" }
}

use colors::*;

fn main() {
    println!("{} {}", red(), blue());
}

Estilo idiomático de importação

Convenção: importe funções pelo módulo pai (use std::cmp; cmp::max(...)), mas importe tipos pelo nome (use std::collections::HashMap;). Assim, as chamadas ficam claras.

use std::cmp;

fn main() {
    println!("{}", cmp::max(3, 9));
}

Caminhos para crates externos

Para dependências, o caminho começa com o nome do crate, por exemplo, rand::thread_rng. Liste o crate em Cargo.toml e importe os itens da mesma forma que faria com std.

Mantendo as importações organizadas

Agrupe as importações relacionadas, renomeie-as para evitar conflitos e prefira importações explícitas a globais no código da aplicação. Importações organizadas tornam um arquivo fácil de examinar.

Verificação rápida

Teste seus conhecimentos sobre caminhos.

Recapitulação

Você aprendeu a importar itens:

use traz um item para o escopo usando um nome curto
Caminhos absolutos começam em crate; caminhos relativos usam self/super
as renomeia, chaves agrupam e * faz importações globais
Importe tipos pelo nome e funções pelo módulo pai para obter clareza

Perguntas Frequentes

A aula “use e caminhos” é grátis?

Sim — o texto completo de “use e caminhos” é 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 “use e caminhos”?

Importe itens 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 3 de 4.

Quanto tempo leva a aula “use e caminhos”?

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