Óxido tuples

Una tupla se define como un tipo de datos compuestos que le permite almacenar una colección de valores de un tipo diferente. En Rust, una tupla se implementa como una estructura, y no debe usarse como reemplazo para una matriz.

Vamos a sumergirnos profundamente y aprender cómo podemos trabajar con tuplas en óxido.

Óxido crea tuple

En Rust, creamos una tupla usando un par de paréntesis. Hay dos formas fundamentales de crear una tupla en Rust:

1. Sin inferencia de tipo.
2. Sin inferencia de tipo.

La sintaxis a continuación ilustra cómo crear una tupla sin inferencia de tipo:

dejar tuple_name = (valores);

El segundo método para crear una tupla es aquel en el que inferimos el tipo.

Sea tuple_name: (data_type_1, data_type_2, ...) = (value_1, value_2, ...);

Aunque se admite el método anterior de creación de tupla, tiende a ser confuso en primer uso.

Un ejemplo de tupla sin inferencia de tipo es como se muestra a continuación:

fnmain ()
Sea Tuple = (1,2,3,4,5, "A,", "B", "C");

Lo anterior crea una tupla de diferentes tipos sin inferencia de tipo. El compilador asignará automáticamente los tipos a los elementos de la tupla.

Considere el ejemplo a continuación que muestra cómo crear una tupla con inferencia de tipo.

Sea Tuple2: (i32, & str) = (1, "A");

En la sintaxis de ejemplo anterior, le decimos explícitamente al compilador sobre el tipo de valores que deseamos almacenar. Recuerde que el orden es importante, y cada elemento debe corresponder con el tipo definido.

Podemos imprimir una tupla usando el rasgo de depuración del módulo std :: fmt. Un ejemplo es como se muestra:

fnmain ()
Sea Tuple = (1,2,3,4,5, "A,", "B", "C");
println!(":? ", tuple);

El programa anterior devuelve los elementos de la tupla:

(1, 2, 3, 4, 5, "A,", "B", "C")

Elementos de tupla de acceso a la óxido

Para acceder a un elemento de una tupla, utilizamos su índice correspondiente. En Rust, una indexación de tupla comienza en 0.

La sintaxis para acceder a un elemento en un índice específico es como se muestra:

Tuple_Name.índice

En Rust, usamos la notación de puntos para acceder a un elemento en un índice específico. Esto se debe a que una tupla es técnicamente una estructura en óxido.

Considere el ejemplo a continuación que accede a un elemento en el índice 5 en la tupla.

fn main ()
Sea Tuple = (1,2,3,4,5, "A,", "B", "C");
// deja Tuple2: (i32, & str) = (1, "A");
println!(":? ", tuple.5);

El programa devuelve el elemento en el índice 5; En este caso, devuelve "A".

Sugerencia: las tuplas no permiten bucle. Por lo tanto, no podemos usar una característica como un bucle for para iterar sobre cada elemento en la tupla.

Tuple de óxido desempaquetando

El óxido le permite desempacar los elementos de una tupla en valores individuales. Podemos hacer esto usando la sintaxis que se muestra a continuación:

LET (valores ...) = Tuple_Name;

A continuación se muestra un ejemplo de desempaquetado de tupla:

fn main ()
Sea Tuple = (20, "Aaron", 131000);
Let (edad, nombre, salario) = tuple;
println!("Nombre: \ nage: \ nsalary: \ n", nombre, edad, salario)

El ejemplo anterior desempaquera los elementos en variables individuales. Esta es una característica muy útil que le permite usar elementos específicos de una tupla individualmente.

Conclusión

Esta guía explora cómo trabajar con tuplas y tipos de tuple en el lenguaje de programación de óxido. El óxido trata las tuplas de manera diferente a otros lenguajes de programación, como Python. Consulte la documentación para explorar más.

Gracias por leer y feliz codificación!!