Tuples de rouille

Un tuple est défini comme un type de données composé qui vous permet de stocker une collection de valeurs d'un type différent. Dans Rust, un tuple est implémenté comme une structure, et il ne doit pas être utilisé en remplacement d'un tableau.

Plongeons profondément et découvrons comment nous pouvons travailler avec des tuples à la rouille.

Rust Créer des tuple

Dans Rust, nous créons un tuple en utilisant une paire de parenthèses. Il existe deux façons fondamentales de créer un tuple en rouille:

1. Sans inférence de type.
2. Sans inférence de type.

La syntaxe ci-dessous illustre comment créer un tuple sans inférence de type:

Soit Tuple_name = (valeurs);

La deuxième méthode pour créer un tuple est celle où nous déduisons le type.

Laissez Tuple_name: (data_type_1, data_type_2,…) = (value_1, value_2,…);

Bien que la méthode ci-dessus de la création de tuple soit prise en charge, elle a tendance à être déroutant à la première utilisation.

Un exemple de tuple sans inférence de type est comme indiqué ci-dessous:

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

Ce qui précède crée un tuple de différents types sans inférence de type. Le compilateur affectera automatiquement les types aux éléments du tuple.

Considérez l'exemple ci-dessous qui montre comment créer un tuple avec une inférence de type.

Soit Tuple2: (i32, & str) = (1, "a");

Dans l'exemple de syntaxe ci-dessus, nous disons explicitement au compilateur du type de valeurs que nous souhaitons stocker. N'oubliez pas que l'ordre est important et que chaque élément doit correspondre au type défini.

Nous pouvons imprimer un tuple en utilisant le trait de débogage du module STD :: FMT. Un exemple est comme indiqué:

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

Le programme ci-dessus renvoie les éléments du tuple:

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

Éléments de tuple d'accès à la rouille

Pour accéder à un élément d'un tuple, nous utilisons son index correspondant. À Rust, une indexation des tuple commence à 0.

La syntaxe pour accéder à un élément à un index spécifique est comme indiqué:

tuple_name.indice

Dans Rust, nous utilisons la notation de points pour accéder à un élément à un index spécifique. C'est parce qu'un tuple est techniquement une structure en rouille.

Considérez l'exemple ci-dessous qui accède à un élément de l'index 5 dans le tuple.

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

Le programme renvoie l'élément à l'index 5; Dans ce cas, il renvoie «A».

Astuce: les tuples ne permettent pas de boucle. Par conséquent, nous ne pouvons pas utiliser une fonctionnalité telle qu'une boucle pour itérater sur chaque élément du tuple.

Déballage de tuple rouille

Rust vous permet de déballer les éléments d'un tuple en valeurs individuelles. Nous pouvons le faire en utilisant la syntaxe ci-dessous:

LET (VALEURS…) = TuPle_name;

Un exemple de déballage de tuple est illustré ci-dessous:

fn main ()
Soit Tuple = (20, "Aaron", 131000);
Soit (âge, nom, salaire) = tuple;
println!("Nom: \ nage: \ nsalary: \ n", nom, âge, salaire)

L'exemple ci-dessus déballait les éléments en variables individuelles. Il s'agit d'une fonctionnalité très utile qui vous permet d'utiliser des éléments spécifiques d'un tuple individuellement.

Conclusion

Ce guide explore comment travailler avec des tuples et des types de tuple dans le langage de programmation Rust. La rouille traite les tuples différemment des autres langages de programmation, comme Python. Vérifiez la documentation pour explorer plus.

Merci d'avoir lu et codage heureux!!