Tuplas de ferrugem

Uma tupla é definida como um tipo de dados composto que permite armazenar uma coleção de valores de um tipo diferente. Na ferrugem, uma tupla é implementada como uma estrutura e não deve ser usada como substituto para uma matriz.

Vamos mergulhar profundamente e aprender como podemos trabalhar com tuplas em ferrugem.

Ferrugem Crie tupla

Em Rust, criamos uma tupla usando um par de parênteses. Existem duas maneiras fundamentais de criar uma tupla na ferrugem:

1. Sem tipo de inferência.
2. Sem tipo de inferência.

A sintaxe abaixo ilustra como criar uma tupla sem inferência de tipo:

Seja tuple_name = (valores);

O segundo método para criar uma tupla é aquele em que inferimos o tipo.

Seja tuple_name: (data_type_1, data_type_2,…) = (value_1, value_2,…);

Embora o método acima da criação de tupla seja suportado, ela tende a ser confusa no primeiro uso.

Um exemplo de tupla sem que a inferência é mostrado abaixo:

fnmain ()
Seja tupla = (1,2,3,4,5, "a", "b", "c");

O acima cria uma tupla de diferentes tipos sem inferência de tipo. O compilador atribuirá automaticamente os tipos aos elementos da tupla.

Considere o exemplo abaixo que mostra como criar uma tupla com inferência de tipo.

Seja tuple2: (i32, & str) = (1, "a");

No exemplo sintaxe acima, contamos explicitamente ao compilador sobre o tipo de valores que desejamos armazenar. Lembre -se de que a ordem é importante e cada elemento deve corresponder ao tipo definido.

Podemos imprimir uma tupla usando o traço de depuração do módulo STD :: FMT. Um exemplo é como mostrado:

fnmain ()
Seja tupla = (1,2,3,4,5, "a", "b", "c");
println!(":? ", tupla);

O programa acima retorna os elementos da tupla:

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

Elementos de tupla de acesso à ferrugem

Para acessar um elemento de uma tupla, usamos seu índice correspondente. Em ferrugem, uma indexação de tupla começa em 0.

A sintaxe para acessar um elemento em um índice específico é como mostrado:

tuple_name.índice

Na ferrugem, usamos a notação de pontos para acessar um elemento em um índice específico. Isso ocorre porque uma tupla é tecnicamente uma estrutura em ferrugem.

Considere o exemplo abaixo que acessa um elemento no índice 5 na tupla.

fn main ()
Seja tupla = (1,2,3,4,5, "a", "b", "c");
// deixe tuple2: (i32, & str) = (1, "a");
println!(":? ", tupla.5);

O programa retorna o elemento no índice 5; Nesse caso, ele retorna "a".

Dica: as tuplas não permitem looping. Portanto, não podemos usar um recurso como um loop para iterar sobre cada item na tupla.

Descarga de tupla de ferrugem

Rust permite que você descompacte os elementos de uma tupla em valores individuais. Podemos fazer isso usando a sintaxe mostrada abaixo:

vamos (valores…) = tuple_name;

Um exemplo de descompacagem de tupla é mostrado abaixo:

fn main ()
Seja tupla = (20, "Aaron", 131000);
vamos (idade, nome, salário) = tupla;
println!("Nome: \ nage: \ nsalary: \ n", nome, idade, salário)

O exemplo acima descompacta os elementos em variáveis ​​individuais. Este é um recurso muito útil que permite que você use elementos específicos de uma tupla individualmente.

Conclusão

Este guia explora como trabalhar com tuplas e tipos de tupla na linguagem de programação de ferrugem. Rust trata as tuplas de maneira diferente de outras linguagens de programação, como o Python. Verifique a documentação para explorar mais.

Obrigado pela leitura e codificação feliz!!