Diferente de muitas linguagens da estilo-C, a linguagem Rust não possui o comando de escolha switch. Rust possui os comandos match e let-match que serão estudados nesta parte do tutorial.

O comando de escolha-caso bem como o seu funcionamento já foram discutidos em Portugol: Comandos de Escolha sendo a leitura recomendada.

O comando match é um comando de escolha ou fluxo baseado em comparação de padrões e não apenas valores inteiros como em na linguagem C/C++, por exemplo. Esse comando pode ser usado com strings, caracteres, enums heterogêneos, tuplas e outros em seus cases sendo possível utilizar expressões, intervalo de dados, binding de variáveis e validações com guards.

Fig. 1: Fluxograma do Comando match

Sintaxe

match valor_condicao {
	valor_caso1 : => {
	{//seu código aqui para o caso 1}; 
    },
    valor_caso2 : =>{
	    //seu código aqui para o caso 2
    },
    valor_casoN : =>{
	    //seu código aqui para o caso N
    },
    _: => {
	    //default 
    }
}

Onde

=>: separador de padrão e bloco de código
_: case default

De forma semelhante ao switch, dado um valor_condicao, esse será testado e comparado com os expressões contidas em valor_caso1 ao valor_casoN executando o trecho de código definido caso a match retorne verdadeiro(true).

O último caso utilizando o operador "_" é executado caso nenhum valor_caso1 a valor_casoN satisfaça a verificação de valor_condicao. Esse último caso se assemelha ao caso default do comando switch.

Exemplo 1

fn main(){
   
   let codigo:i8 = 3;
   match codigo {
      0 => { println!("Caso 0")},
      1 => { println!("Caso 1")},
      2 => { println!("Caso 2")},
      3 => { println!("Caso 3")},
      _ => { println!("Default")}
   };
}

Saída

Caso 3

Semelhante ao switch em outras linguagens de programação, Rust permite que o comando match possa conter o tipo string ou tipo enum como condições em seus cases como pode ser visto nos exemplos abaixo:

Exemplo 2: string

fn main(){
   
    let str: &str = "codigo";
    match str {
        "codigo" => println!("ok"),
        "erro" => println!("Ocorreu erro"),
        _ => println!("comando desconhecido"),
   }
}

Saída

ok

Exemplo 3: char

fn main(){
   
    let codigo = 'a';

    match codigo {
        'x' => println!("codigo x"),
        'y' => println!("codigo y"),
        _ => println!("outro codigo"), 
    }
}

Saída

codigo x

Exemplo 4: enum

fn main(){
   
    #[allow(dead_code)] //warning
    enum MeuEnum { Opcao1, Opcao2, Opcao3 }

    let codigo = MeuEnum::Opcao2;
    
    match codigo {
        MeuEnum::Opcao1 => println!("Opcao1"),
        MeuEnum::Opcao2 => println!("Opcao2"),
        MeuEnum::Opcao3 => println!("Opcao3"),
    }
}

Saída

Opcao2

Em Rust podemos atribuir um valor de retorno de um case match utilizando o comando let-match. É possível executar um trecho de código e retornar um valor ou apenas retornar um valor. Abaixo as sintaxes e exemplos para mostram o que foi discutido:

Sintaxe 1: valor retorno

let retorno_match = match <condicao> {
	caso1 => {
	    valor_retorno1
    },
    caso2 =>{
	    valor_retorno2
    },
    casoN =>{
	    valor_retornoN
    },
    _ => {
	    valor_retorno_default
    }
}

Sintaxe 2: código + retorno

let retorno_match = match <condicao> {
	caso1 => {
	    valor_retorno1
    },
    caso2 =>{
	    valor_retorno2
    },
    casoN =>{
	    valor_retornoN
    },
    _ => {
	    valor_retorno_default
    }
}

Exemplo 5

fn main(){
   
   let codigo:i8 = 3;
   let retorno = match codigo{
      0 => { println!("Caso 0"); 99},
      1 => { println!("Caso 1"); 98},
      2 => { println!("Caso 2"); 97},
      3 => { println!("Caso 3"); 96},
      _ => { println!("Default"); 95}
   };
   
   println!("Retorno:{}",retorno);
}

Saída

Caso 3
Retorno:96

Exemplo 6

Ex:
fn main(){

    let flag = true;
    let ret = match flag {
        false => 0,
        true => 1,
    };
}

Saída

-

1. 22/05/2023 - versão inicial - Adição: match, 'match com string, char e enum' e let-match