Learn Rust Coding · Aula

Correspondência Poderosa de Padrões

Domine as expressões `match` e outras construções de correspondência de padrões para tratar variantes de dados de forma concisa e exaustiva.

Correspondência Poderosa de Padrões é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 3. 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 3 aulas no total.

Liberando o Poder da Correspondência de Padrões

Bem-vindo ao mundo da correspondência de padrões no Rust! Esse recurso poderoso permite controlar o fluxo do programa com base na estrutura dos dados.

Em vez de apenas verificar a igualdade, você pode decompor valores, extrair componentes e executar código específico para diferentes formatos de dados.

É como uma instrução if/else ou switch muito mais poderosa.
Garante a exaustividade: você precisa tratar todos os padrões possíveis.
Deixa o código mais legível e robusto.

Noções Básicas da Expressão `match`

O núcleo da correspondência de padrões é a expressão match. Ela recebe um valor e o compara com uma série de padrões. O primeiro padrão correspondente vence!

Cada "braço" de uma expressão match consiste em um padrão e no código a ser executado se esse padrão corresponder.

enum Direction {
  North,
  East,
  South,
  West,
}

fn main() {
  let my_direction = Direction::North;

  match my_direction {
    Direction::North => println!("Going up!"),
    Direction::East => println!("Going right!"),
    Direction::South => println!("Going down!"),
    Direction::West => println!("Going left!"),
  }
}

Correspondendo Literais e Intervalos

Você pode fazer correspondência com valores literais específicos (números, caracteres e valores booleanos) ou definir intervalos usando ..=. O operador | permite corresponder a vários padrões com um único braço.

Lembre-se: os padrões são verificados na ordem, e a primeira correspondência é usada.

fn main() {
  let x = 7;

  match x {
    1 => println!("It's one!"),
    2 | 3 => println!("It's two or three!"),
    4..=8 => println!("It's between four and eight!"),
    _ => println!("It's something else!"), // Catch-all
  }

  let character = 'b';
  match character {
    'a'..='e' => println!("Early letter"),
    _ => println!("Other letter"),
  }
}

Decompondo Estruturas

A correspondência de padrões realmente se destaca ao decompor tipos de dados complexos, como estruturas. Você pode extrair campos individuais diretamente para variáveis dentro do braço de match.

Isso torna o acesso aos dados da estrutura limpo e conciso, especialmente ao corresponder a valores específicos de campos.

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

fn main() {
  let p = Point { x: 0, y: 7 };

  match p {
    Point { x, y: 0 } => println!("On the X axis at {}", x),
    Point { x: 0, y } => println!("On the Y axis at {}", y),
    Point { x, y } => println!("Not on an axis: ({}, {})", x, y),
  }
}

Decompondo Enumerações com Dados

As enumerações no Rust podem conter dados associados. A correspondência de padrões é a principal forma de extrair esses dados de uma variante de enumeração.

Você pode decompor os dados diretamente em novas variáveis, facilitando o trabalho com o conteúdo de cada variante.

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
  match msg {
    Message::Quit => println!("Quit message."),
    Message::Move { x, y } => {
      println!("Move to x: {}, y: {}", x, y);
    }
    Message::Write(text) => println!("Text message: {}", text),
    Message::ChangeColor(r, g, b) => {
      println!("Color: R:{}, G:{}, B:{}", r, g, b);
    }
  }
}

fn main() {
  process_message(Message::Move { x: 10, y: 20 });
  process_message(Message::Write(String::from("Hello!")));
}

O Padrão Curinga `_`

O padrão especial _ (sublinhado) funciona como um coringa. Ele corresponde a qualquer valor e não associa esse valor a nenhuma variável.

Ele é útil quando você precisa abranger todas as possibilidades para garantir a exaustividade, mas não se importa com o valor específico que corresponde a determinado braço.

fn main() {
  let some_value = Some(5);
  let absent_value: Option<i32> = None;

  match some_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("Something else!"), // Matches None too
  }

  match absent_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("No value here!"),
  }
}

`if let` para Padrões Únicos

Às vezes, você só precisa verificar um padrão específico e quer ignorar todos os outros. Nesses casos, if let é uma alternativa mais concisa a uma expressão match completa.

Essencialmente, ele diz: "se este padrão corresponder, faça isto; caso contrário, não faça nada (ou execute um bloco else opcional).".

fn main() {
  let config_max = Some(3u8);
  let none_value: Option<u8> = None;

  if let Some(max) = config_max {
    println!("Max configured to be: {}", max);
  }

  if let Some(val) = none_value {
    println!("This won't print: {}", val);
  } else {
    println!("No value found!");
  }
}

`while let` para Laços Condicionais

Assim como if let, while let permite repetir um laço enquanto um padrão continuar correspondendo.

Isso é extremamente útil para processar itens de coleções como Vecs quando você quer continuar até não haver mais elementos correspondentes (por exemplo, até que pop() retorne None).

fn main() {
  let mut stack = vec![1, 2, 3];

  while let Some(top) = stack.pop() {
    println!("Popped: {}", top);
  }

  println!("Stack is empty now.");
}

Guardas de Correspondência: Adicionando Condições

Você pode adicionar uma condição if extra, chamada de guarda de correspondência, a um braço de match. O padrão precisa corresponder AND a condição da guarda precisa ser verdadeira para que esse braço seja executado.

Isso permite um controle mais preciso dentro de um padrão, sem a necessidade de criar mais variantes de enumeração.

fn main() {
  let num = Some(4);

  match num {
    Some(x) if x % 2 == 0 => println!("Even number: {}", x),
    Some(x) if x < 5 => println!("Small odd number: {}", x),
    Some(x) => println!("Any other number: {}", x),
    None => println!("No number"),
  }
}

Desafio de Correspondência de Padrões

Considere o seguinte trecho de código Rust. Quais das afirmações a seguir sobre a expressão match e sua saída são VERDADEIRAS?

enum Status {
  Loading,
  Success(u32),
  Error(String),
}

fn process_status(s: Status) {
  match s {
    Status::Success(code) if code > 200 => println!("Success with high code: {}", code),
    Status::Success(code) => println!("Success with code: {}", code),
    Status::Error(msg) => println!("Failed: {}", msg),
    _ => println!("Status unknown or loading..."),
  }
}

fn main() {
  process_status(Status::Success(201));
  process_status(Status::Error(String::from("Network issue")));
  process_status(Status::Loading);
  process_status(Status::Success(200));
}

Revisão: dominando padrões

Você explorou o incrível poder da correspondência de padrões em Rust! Esse é um conceito fundamental para escrever código claro, conciso e seguro.

As expressões match fornecem controle de fluxo exaustivo com base na estrutura dos dados.
Você pode fazer correspondência com literais, intervalos e curingas (_).
A desestruturação permite extrair valores diretamente de estruturas e enumerações.
if let e while let oferecem maneiras concisas de fazer correspondência com padrões únicos.
As guardas de correspondência adicionam lógica condicional aos braços de match.

Continue praticando esses padrões; eles são essenciais para escrever Rust idiomático!

Perguntas Frequentes

A aula “Correspondência Poderosa de Padrões” é grátis?

Sim — o texto completo de “Correspondência Poderosa de Padrões” é 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 3 aulas no total.

O que vou aprender em “Correspondência Poderosa de Padrões”?

Domine as expressões `match` e outras construções de correspondência de padrões para tratar variantes de dados de forma concisa e exaustiva. 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 3.

Quanto tempo leva a aula “Correspondência Poderosa de Padrões”?

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