Enumeraciones y coincidencia de patrones en Rust

Rust proporciona varios tipos de datos para realizar operaciones, desde tipos de datos básicos como cadenas, enteros y flotantes. apunte números a tipos de datos compuestos como vectores y matrices a tipos de datos compuestos como estructuras y enumeraciones.

Las enumeraciones (enumeraciones) son un tipo de dato que permite la representación de un conjunto fijo de valores, como los días de la semana y el color del arcoíris. Las enumeraciones son útiles cuando los valores posibles de una variable son limitados y conocidos.

Definición de enumeraciones en Rust

Declarar enumeraciones en Rust es similar a declarar enumeraciones en C#. Usarás el enumeración palabra clave que sigue al nombre y un conjunto de llaves para definir enumeraciones. Puede definir las posibles variantes (entidades) dentro de las llaves con una coma como separador.

Aquí hay una enumeración para los días de la semana:

enumeraciónDía laborable {
 Lunes,
 Martes,
 Miércoles,
 Jueves,
 Viernes,
 Sábado,
 Domingo,
}

El Día laborable enum representa los días de la semana. El variantes son los nombres del día y no tienen valores asociados. Además, las variantes de su enumeración pueden ser cualquiera Tipo de datos de óxido.

Puede acceder a las variantes especificando el nombre de la variante mediante el operador separador de ruta (::) en la enumeración.

dejar día = Día de la semana:: Lunes;
// versión estáticamente tipada de la variable `day`
dejar día: Día de la semana = Día de la semana:: Lunes;

El código especifica que desea acceder a la Lunes variante de la enumeración Weekday.

Variantes y discriminantes de enumeraciones

Las variantes de una enumeración están asociadas con valores enteros llamados discriminante. De forma predeterminada, los valores discriminantes comienzan en cero y se incrementan en 1 para las variantes posteriores; sin embargo, es posible especificar valores discriminantes personalizados para cada variante.

Este es un ejemplo de la enumeración Weekday con variantes de valor asignado.

enumeraciónDía laborable {
 lunes = 1,
 martes = 2,
 miércoles = 3,
 jueves = 4,
 viernes = 5,
 sábado = 6,
 domingo = 7,
}

La enumeración Weekday tiene siete variantes que representan cada día de la semana, y cada día tiene un valor (llamado discriminante) asignado. Las variantes están en el orden del primero al último día de la semana.

Puede acceder al valor discriminante utilizando el nombre de la variante.

fnprincipal() {
imprimir!("Lunes: {}", Día de la semana:: Lunes comoi32);
imprimir!("Martes: {}", Día de la semana:: Martes comoi32);
imprimir!("Miércoles: {}", Día de la semana:: Miércoles comoi32);
imprimir!("Jueves: {}", Día de la semana:: Jueves comoi32);
imprimir!("Viernes: {}", Día de la semana:: Viernes comoi32);
imprimir!("Sábado: {}", Día de la semana:: Sábado comoi32);
imprimir!("Domingo: {}", Día de la semana:: Domingo comoi32);
}

El imprimir! macro se utiliza para imprimir los discriminantes. Cada impresión! la invocación de macro toma dos argumentos: una cadena de formato y un valor. La cadena de formato especifica cómo formatear la salida; el valor es el valor real que se imprime.

En este caso, la cadena de formato es una cadena literal que contiene el nombre del día de la semana y el valor es la variante de enumeración con una conversión explícita al i32 tipo entero.

La conversión explícita a i32 es necesaria porque las enumeraciones de Rust se representan como enteros, pero el tipo de entero específico depende del tamaño de la enumeración. De forma predeterminada, Rust asigna el tipo de entero más pequeño que puede representar todos los discriminantes en la enumeración. Pero en este caso, desea imprimir los valores como enteros i32, por lo que debe convertirlos explícitamente.

Aquí está el resultado de ejecutar el principal función:

Coincidencia de patrones en Rust

La coincidencia de patrones es una construcción de estructura de control de Rust útil para identificar patrones de datos. La coincidencia de patrones permite escribir código conciso y eficiente mientras se opera con estructuras de datos avanzadas o realizar operaciones complejas.

Usarás el fósforo palabra clave seguida de la => separador para el patrón y la operación para el patrón, respectivamente. El patrón puede ser cualquier expresión de Rust, incluidos literales, variables y llamadas a funciones.

Aquí hay una declaración de coincidencia de ejemplo:

fnprincipal(){
dejar x = 5;
fósforo X {
1 => imprimir!("uno"),
2 => imprimir!("dos"),
3 => imprimir!("tres"),
// se ejecuta si ninguno de los patrones coincide
 _ => imprimir!("algo más"),
 }
}

El principal coincidencias de funciones X contra varios patrones y luego imprime el valor basado en el valor de x. El patrón de guión bajo (_) es un patrón comodín que se usa como un cajón de sastre para los casos que no se manejan explícitamente.

Enumeraciones y coincidencia de patrones

Las enumeraciones y la coincidencia de patrones son útiles para expresar y trabajar con estructuras de datos avanzadas de una manera segura y eficiente. Puede usar enumeraciones para definir un conjunto fijo de valores y la coincidencia de patrones para trabajar con esos valores.

Aquí hay una enumeración para los colores en un arco iris:

enumeraciónArcoíris {
 Rojo,
 Naranja,
 Amarillo,
 Verde,
 Azul,
 Índigo,
 Violeta,
}

Cada variante de la Arcoíris enum representa un color del arco iris. Puede usar la coincidencia de patrones con la declaración de coincidencia para hacer coincidir los patrones con la variante para controlar el flujo del programa según el color del arcoíris.

Aquí hay una función que toma la variante de color de la enumeración Rainbow e imprime un mensaje basado en el color.

fnimprimir_color(color: arcoiris) {
fósforo color {
 Arcoiris:: Rojo => imprimir!("¡El color es rojo!"),
 Arcoiris:: Naranja => imprimir!("¡El color es naranja!"),
 Arcoiris:: Amarillo => imprimir!("¡El color es amarillo!"),
 Arcoiris:: Verde => imprimir!("¡El color es verde!"),
 Arcoiris:: Azul => imprimir!("¡El color es azul!"),
 Arcoíris:: Índigo => imprimir!("¡El color es índigo!"),
 Arcoiris:: Violeta => imprimir!("¡El color es violeta!"),
 }
}
fnprincipal() {
dejar color = arcoiris:: azul;
 imprimir_color (color);
}

puede obtener las variantes nunca se construyen o advertencias similares cuando intente ejecutar el código anterior porque las otras variantes, aparte de la variante azul, nunca se construyeron en este código. Por lo tanto, en este caso, puede ignorar con seguridad estas advertencias ya que es intencional.

El imprimir_color La función toma un parámetro de color del tipo de enumeración Rainbow. La declaración de coincidencia coincide con el color de un conjunto de colores a los que se accede a través de los nombres de las variantes. Y finalmente, el mensaje se imprime en función del color coincidente.

Puede usar la coincidencia de patrones para operaciones complejas como múltiples valores de retorno basados ​​en una condición.

fncalcular_longitud de onda(color: arcoíris) -> u32 {
fósforo color {
 Arcoiris:: Rojo => 700,
 Arcoiris:: Naranja => 590,
 Arcoiris:: Amarillo => 570,
 Arcoiris:: Verde => 510,
 Arcoiris:: Azul => 475,
 Arcoíris:: Índigo => 445,
 Arcoiris:: Violeta => 400,
 }
}

El calcular_longitud de onda La función toma una variante de color del tipo de enumeración Rainbow como parámetro y devuelve un entero de 32 bits sin signo que es la longitud de onda del color que coincide con el patrón.

Rust también proporciona estructuras para crear tipos personalizados

Las enumeraciones son útiles para definir tipos personalizados para varias operaciones, especialmente en los casos en que los campos son conocidos y definidos.

Rust también proporciona estructuras que puede usar para crear tipos personalizados con campos con nombre. A diferencia de las enumeraciones, las estructuras le permiten definir campos de diferentes tipos a los que puede acceder y modificar individualmente.