Learn Rust Coding · Aula

Desestruturação

Structs, enumerações e tuplas

Desestruturação é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 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.

O que é destruturação?

Desestruturação divide um valor composto em suas partes usando um padrão. Ela funciona com tuplas, estruturas, enumerações, matrizes e muito mais.

Desestruturando tuplas

Atribua cada elemento de uma tupla à sua própria variável em um único let.

fn main() {
    let point = (3, 7);
    let (x, y) = point;
    println!("x = {x}, y = {y}");
}

Ignorando partes de tuplas

Use _ para ignorar um valor e .. para ignorar vários.

fn main() {
    let data = (1, 2, 3, 4);
    let (first, .., last) = data;
    println!("{first} ... {last}");
}

Desestruturando estruturas

Extraia campos de uma estrutura pelo nome. Os nomes das variáveis atribuídas podem corresponder aos campos ou ser renomeados.

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    let Point { x, y } = p;
    println!("{x}, {y}");
}

Renomeando campos

Use field: new_name para atribuir um campo de estrutura a uma variável com outro nome.

struct Config {
    width: u32,
    height: u32,
}

fn main() {
    let c = Config { width: 800, height: 600 };
    let Config { width: w, height: h } = c;
    println!("{w} x {h}");
}

Ignorando campos de estruturas

.. ignora os campos restantes de que você não precisa.

struct User {
    name: String,
    age: u32,
    active: bool,
}

fn main() {
    let u = User { name: "Ada".into(), age: 36, active: true };
    let User { name, .. } = u;
    println!("{name}");
}

Desestruturando enumerações

Em um match, desestruture as variantes de uma enumeração para extrair seus dados.

enum Event {
    Click { x: i32, y: i32 },
    Key(char),
}

fn main() {
    let e = Event::Click { x: 5, y: 8 };
    match e {
        Event::Click { x, y } => println!("click at {x},{y}"),
        Event::Key(c) => println!("key {c}"),
    }
}

Desestruturação em parâmetros

Os parâmetros de funções podem ser desestruturados diretamente, o que é útil para tuplas e estruturas pequenas.

fn distance((x1, y1): (f64, f64), (x2, y2): (f64, f64)) -> f64 {
    ((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt()
}

fn main() {
    println!("{}", distance((0.0, 0.0), (3.0, 4.0)));
}

Desestruturação aninhada

Os padrões podem ser aninhados livremente, permitindo acessar estruturas profundas em uma única etapa.

struct Line {
    start: (i32, i32),
    end: (i32, i32),
}

fn main() {
    let line = Line { start: (0, 0), end: (4, 5) };
    let Line { start: (sx, sy), end: (ex, ey) } = line;
    println!("from {sx},{sy} to {ex},{ey}");
}

Desestruturando matrizes e fatias

Matrizes e fatias podem ser desestruturadas, inclusive capturando a parte central com ...

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let [first, .., last] = arr;
    println!("first {first}, last {last}");
}

Desestruturação em laços for

A desestruturação também funciona em laços for, o que é perfeito para iterar sobre pares de valores.

fn main() {
    let pairs = [("a", 1), ("b", 2), ("c", 3)];
    for (label, value) in pairs {
        println!("{label} = {value}");
    }
}

Verificação rápida

Como ignorar os campos restantes de uma estrutura durante a desestruturação?

Recapitulação

Você aprendeu sobre desestruturação:

Dividir tuplas, estruturas, enumerações, matrizes e fatias
Renomear campos com field: name
Ignorar partes com _ e ..
Desestruturar em let, match e parâmetros de funções
Aninhar padrões para extrair dados profundamente

Perguntas Frequentes

A aula “Desestruturação” é grátis?

Sim — o texto completo de “Desestruturação” é 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 “Desestruturação”?

Structs, enumerações e tuplas 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 4 de 4.

Quanto tempo leva a aula “Desestruturação”?

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