Como usar enums em ferrugem

Neste artigo, exploraremos como trabalhar com enums na linguagem de programação de ferrugem.

Definindo um enumeração

Vamos considerar um exemplo em que podemos usar um tipo de enumeração. Por exemplo, se precisarmos armazenar instruções, podemos usar uma enumeração. Normalmente, podemos expressar orientação em quatro principais valores possíveis: nordeste, sul e oeste.

Se considerarmos a direção, um veículo pode estar se movendo em uma de todas as direções possíveis, mas não mais uma vez ao mesmo tempo.

Isso torna uma enumeração fortemente apropriada para essa estrutura.

Para declarar uma enumeração em ferrugem, começamos com a enumeração de palavras -chave, seguida pelo identificador de enum. Um exemplo é fornecido abaixo:

direção da enumeração
Norte,
Leste,
Sul,
Oeste

O exemplo anterior nos permite definir um tipo personalizado de direção de tipo que podemos reutilizar no programa.

Você também pode definir uma enumeração com uma variante sem dados associados a ele, semelhante a uma estrutura semelhante a uma unidade. Uma enumeração também pode ter variantes com dados nomeados e dados sem nome.

Um exemplo é como mostrado:

Pessoa Enum
Vivo,
Macho (string, f64),
Fêmea nome: string, idade: i32

Enumes são úteis ao criar um tipo como mostrado no exemplo anterior. Se fôssemos usar a definição da estrutura, teríamos que criar várias estruturas. Enums nos permitem armazenar todas as variantes sob uma única entidade.

Valores da enumeração

Depois de declarar uma enumeração, podemos criar uma instância de uma enumeração usando as possíveis variantes disponíveis no tipo.

Por exemplo:

fn main ()
Seja n = direção :: norte;
Seja E = Direction :: leste;
Seja S = Direction :: South;
Seja w = direção :: oeste;

Para acessar a variante de uma enumeração, usamos o cólon duplo para separar o espaço de nome variante e seu identificador.

Match Over Enums

Um grande uso de enums é a correspondência de padrões. Se você tiver várias correspondências em potencial em seu programa, a opção para um bloco if-else pode não criar um código legível. Para esse cenário, podemos usar enums com o operador de partida.

O operador de correspondência nos permite comparar um valor com uma lista de padrões, como nomes de variáveis, valores literais e variantes de enum.

Considere o seguinte exemplo das direções que criamos anteriormente:

fn main ()
Deixe a direção: direção = direção :: norte;
Direção de correspondência
Direção :: norte =>
println!("Direção é norte");
,
Direção :: leste =>
println!("Direção é leste");
,
Direção :: sul =>
println!("Direção é sul");
,
Direção :: oeste =>
println!("Direção é oeste");

No exemplo anterior, começamos com a palavra -chave da partida seguida pela expressão que desejamos avaliar. Embora a sintaxe possa parecer semelhante a uma declaração IF, a expressão da correspondência não retorna um verdadeiro booleano ou falso. O tipo de retorno pode ser de qualquer tipo. No nosso caso, o tipo de retorno é uma enumeração de direção.

O próximo bloco é conhecido como um braço de partida. Um braço contém o padrão a ser correspondido e o bloco de código para executar se a correspondência for encontrada.

Em nosso exemplo, o primeiro braço contém o padrão de direção :: norte e o operador =>. Isso abre o bloco para o código executar quando a partida é encontrada. Para o exemplo anterior, imprimimos a mensagem para a direção correspondente.

O compilador avaliará a expressão de correspondência e comparará um padrão de correspondência nos braços fornecidos. Se uma correspondência for encontrada em um braço específico, o código dentro do bloco de braço será executado. Caso contrário, o compilador continua com a avaliação.

Podemos executar o código anterior da seguinte forma:

enum rustc.rs
./enums

O código anterior deve retornar da seguinte maneira:

$ ./enums
A direção é norte

O espaço reservado

Suponha que queremos apenas executar funções específicas para padrões específicos em uma enumeração. Então, faça uma ação comum para todos os outros.

Para esse caso, podemos usar o operador _, que corresponde a todos os outros casos não especificados em uma expressão de correspondência.

Vamos tomar as instruções que criamos anteriormente. Podemos definir uma ação se a direção estiver norte e, se não, executamos uma mensagem global para todos os outros casos. O código resultante é como mostrado abaixo:

fn main ()
Deixe a direção: direção = direção :: norte;
Direção de correspondência
Direção :: norte =>
println!("Direção é norte");
,
_ =>
println!("Outra direção")

Se alterarmos o valor de "direção", devemos obter a seguinte saída como:

Deixe a direção: direção = direção :: leste;
$ Cargo Run
Outra direção

O código dentro do bloco _ é executado, pois não definimos nenhum caso correspondente para a direção leste.

Zero enumes variantes

Também podemos criar uma enumeração sem variantes. Estes são conhecidos como enumes variantes zero, e não podemos instanciá-los.

Um exemplo de enums-variantes zero é fornecido abaixo:

enum zeroenum

Não podemos lançar enumes variantes zero para outros tipos.

Conclusão

Neste artigo, exploramos o básico de trabalhar com tipos de enum na linguagem de programação de ferrugem. Destacamos como trabalhar com enums em ferrugem, que inclui a definição de uma enumeração, o uso de valores de enumeração e como combinar com enums. Esperamos que você tenha achado este artigo útil. Verifique os outros artigos de dica do Linux para obter mais dicas e informações.