Enums e correspondência de padrões em Rust

Rust fornece vários tipos de dados para executar operações, desde tipos de dados básicos como strings, inteiros e flutuantes números de pontos para tipos de dados compostos, como vetores e matrizes, para tipos de dados compostos, como structs e enumerações.

Enums (enumerações) é um tipo de dados que permite a representação de um conjunto fixo de valores, como os dias da semana e a cor do arco-íris. Enums são úteis quando os valores possíveis para uma variável são limitados e conhecidos.

Definindo Enums em Rust

Declarar enums em Rust é semelhante a declarando enums em C#. Você vai usar o enumerar palavra-chave após o nome e um conjunto de chaves para definir enumerações. Você pode definir as possíveis variantes (entidades) entre chaves com uma vírgula como separador.

Aqui está uma enumeração para os dias da semana:

enumerarDia da semana {
 Segunda-feira,
 Terça-feira,
 Quarta-feira,
 Quinta-feira,
 Sexta-feira,
 Sábado,
 Domingo,
}

O Dia da semana enum representa os dias da semana. O variantes são os nomes do dia e não possuem valores associados. Além disso, as variantes do seu enum podem ser qualquer Tipo de dados de ferrugem.

Você pode acessar variantes especificando o nome da variante usando o operador separador de caminho (::) na enumeração.

deixar dia = Dia da semana:: Segunda-feira;
// versão estaticamente tipada da variável `day`
deixar dia: Dia da semana = Dia da semana:: Segunda-feira;

O código especifica que você deseja acessar o Segunda-feira variante da enumeração Weekday.

Variantes e discriminantes de enums

As variantes de uma enumeração são associadas a valores inteiros chamados discriminante. Por padrão, os valores discriminantes começam em zero e são incrementados em 1 para variantes subsequentes; no entanto, é possível especificar valores discriminantes personalizados para cada variante.

Aqui está um exemplo da enumeração Weekday com variantes de valor atribuído.

enumerarDia da semana {
 segunda-feira = 1,
 terça = 2,
 quarta-feira = 3,
 quinta = 4,
 Sexta = 5,
 sábado = 6,
 Domingo = 7,
}

A enumeração Weekday tem sete variantes que representam cada dia da semana e cada dia tem um valor (chamado de discriminante) atribuído a eles. As variantes estão na ordem do primeiro ao último dia da semana.

Você pode acessar o valor discriminante usando o nome da variante.

fnprincipal() {
println!("Segunda-feira: {}", Dia da semana:: Segunda-feira comoi32);
println!("Terça-feira: {}", Dia da semana:: Terça-feira comoi32);
println!("Quarta-feira: {}", Dia da semana:: Quarta-feira comoi32);
println!("Quinta-feira: {}", Dia da semana:: Quinta-feira comoi32);
println!("Sexta-feira: {}", Dia da semana:: Sexta-feira comoi32);
println!("Sábado: {}", Dia da semana:: Sábado comoi32);
println!("Domingo: {}", Dia da semana:: Domingo comoi32);
}

O println! macro é usada para imprimir os discriminantes. Cada impressão! a invocação da macro requer dois argumentos: uma string de formato e um valor. A string de formato especifica como formatar a saída; o valor é o valor real que é impresso.

Nesse caso, a string de formato é uma string literal que contém o nome do dia da semana e o valor é a variante enum com uma conversão explícita para o i32 tipo inteiro.

A conversão explícita para i32 é necessária porque as enumerações Rust são representadas como números inteiros, mas o tipo inteiro específico depende do tamanho da enumeração. Por padrão, Rust atribui o menor tipo inteiro que pode representar todos os discriminantes na enumeração. Mas, neste caso, você deseja imprimir os valores como inteiros i32, portanto, precisa convertê-los explicitamente.

Aqui está o resultado da execução do principal função:

Correspondência de Padrões em Rust

A correspondência de padrões é uma construção de estrutura de controle Rust útil para identificar padrões de dados. A correspondência de padrões permite escrever código conciso e eficiente durante a operação com estruturas de dados avançadas ou realizando operações complexas.

Você vai usar o corresponder palavra-chave seguida pelo => separador para o padrão e a operação para o padrão, respectivamente. O padrão pode ser qualquer expressão Rust, incluindo literais, variáveis ​​e chamadas de função.

Aqui está um exemplo de declaração de correspondência:

fnprincipal(){
deixar x = 5;
corresponder x {
1 => println!("um"),
2 => println!("dois"),
3 => println!("três"),
// executa se nenhum dos padrões corresponder
 _ => println!("algo mais"),
 }
}

O principal correspondências de função x contra vários padrões e, em seguida, imprime o valor com base no valor de x. O padrão de sublinhado (_) é um padrão curinga usado como um catch-all para casos que não são tratados explicitamente.

Enums e Correspondência de Padrões

Enums e correspondência de padrões são úteis para expressar e trabalhar com estruturas de dados avançadas de maneira segura e eficiente. Você pode usar enums para definir um conjunto fixo de valores e correspondência de padrões para trabalhar com esses valores.

Aqui está uma enumeração para as cores em um arco-íris:

enumerarArco-íris {
 Vermelho,
 Laranja,
 Amarelo,
 Verde,
 Azul,
 Índigo,
 Tolet,
}

Cada variante do Arco-íris enum representa uma cor do arco-íris. Você pode usar a correspondência de padrões com a instrução de correspondência para corresponder os padrões à variante para controlar o fluxo do programa com base na cor do arco-íris.

Aqui está uma função que recebe a variante de cor da enumeração Rainbow e imprime uma mensagem com base na cor.

fnprint_color(cor: arco-íris) {
corresponder cor {
 Arco-íris:: Vermelho => println!("A cor é vermelha!"),
 Arco-íris:: Laranja => println!("A cor é laranja!"),
 Arco-íris:: Amarelo => println!("A cor é amarela!"),
 Arco-íris:: Verde => println!("A cor é verde!"),
 Arco-íris:: Azul => println!("A cor é azul!"),
 Arco-íris:: Índigo => println!("A cor é índigo!"),
 Arco-íris:: Violeta => println!("A cor é violeta!"),
 }
}
fnprincipal() {
deixar cor = Arco-íris:: Azul;
 print_color (cor);
}

você pode conseguir variantes nunca são construídas ou avisos semelhantes quando você tentar executar o código acima porque as outras variantes além da variante Blue nunca foram construídas neste código. Portanto, nesse caso, você pode ignorar com segurança esses avisos, pois é intencional.

O print_color A função recebe um parâmetro de cor do tipo Rainbow enum. A declaração de correspondência corresponde à cor de um conjunto de cores que são acessadas por meio dos nomes das variantes. E, finalmente, a mensagem é impressa com base na cor correspondente.

Você pode usar a correspondência de padrões para operações complexas, como vários valores de retorno com base em uma condição.

fncalcular_comprimento de onda(cor: arco-íris) -> u32 {
corresponder cor {
 Arco-íris:: Vermelho => 700,
 Arco-íris:: Laranja => 590,
 Arco-íris:: Amarelo => 570,
 Arco-íris:: Verde => 510,
 Arco-íris:: Azul => 475,
 Arco-íris:: Índigo => 445,
 Arco-íris:: Violeta => 400,
 }
}

O calcular_comprimento de onda A função recebe uma variante de cor do tipo Rainbow enum como um parâmetro e retorna um inteiro não assinado de 32 bits que é o comprimento de onda da cor que corresponde ao padrão.

Rust também fornece estruturas para criar tipos personalizados

Enums são úteis para definir tipos personalizados para diversas operações, especialmente nos casos em que os campos são conhecidos e definidos.

Rust também fornece structs que você pode usar para criar tipos personalizados com campos nomeados. Ao contrário de enums, structs permitem que você defina campos de diferentes tipos que podem ser acessados ​​e modificados individualmente.