Tableaux de rouille

Un tableau fait référence à une collection d'objets du même type. Les tableaux sont incroyablement utiles dans une pléthore de cas. Par conséquent, en tant que programmeurs, il est essentiel de se familiariser avec les tableaux et comment les utiliser dans nos programmes.

Cet article explorera comment nous pouvons créer et utiliser des tableaux dans le langage de programmation de rouille.

Tableaux de rouille

Dans Rust, comme la plupart des langages de programmation, nous représentons un tableau par une paire de crochets. La rouille nécessite la taille d'un tableau à connaître avant la compilation. Si la taille d'un tableau n'est pas définie au moment de la compilation, c'est connu sous le nom de tranche.

Créer un tableau de rouille

Il existe deux façons principales de créer des tableaux de rouille:

En ajoutant les éléments du tableau à une paire de crochets. C'est la méthode la plus simple et la plus courante de création de tableau. Nous pouvons exprimer la syntaxe pour cette méthode de création de tableau comme indiqué:

Laissez Array_name: [F64, 3] = [3.141, 100.2443, 223.554]

Ce qui précède crée un tableau sous le nom de la variable "Array_name". Dans notre cas, la table. La taille du tableau est 3. Cela signifie qu'il peut contenir jusqu'à 3 éléments.

Nous nous référons à la deuxième méthode de création d'un tableau comme une expression répétée. La syntaxe est comme [n, x] où le tableau contient la valeur de x est copiée n fois.

Tableau de déclaration de rouille

Il existe différents types de tableaux de rouille. Chaque type est déterminé par la méthode de déclaration utilisée. Voici les tableaux et comment les déclarer.

Tableaux sans taille et type

Le premier type de tableau est un sans la taille et le type. Ceci est une méthode très utile pour les opérations de tableau rapide.

Pour déclarer un tableau sans type ni taille, utilisez la syntaxe comme indiqué ci-dessous:

Soit Array_Name = [Elements];

Ici, nous utilisons le mot-clé LET, suivi du nom de la variable. Ensuite, nous utilisons l'opérateur d'affectation, suivi des éléments du tableau à l'intérieur d'une paire de crochets.

Un exemple est comme indiqué:

Soit arr = [1,2,3];

Le compilateur détermine le type de tableau en fonction des éléments stockés dedans. Le nombre total d'éléments dans le tableau devient sa taille.

Tableaux avec type et taille

Le deuxième type de tableau est un avec un type et une taille pendant la déclaration. Pour ce type de tableau, nous définissons le type de données des éléments que nous souhaitons stocker dans le tableau et le nombre d'éléments que le tableau tiendra.

La syntaxe de cette création de tableau est comme indiqué ci-dessous:

Laissez Array_name: [data_type; array_size] = [array_elements];

Un exemple est comme indiqué ci-dessous:

fn main ()
Laissez Arr: [i32; 3] = [1,2,3];

Ce qui précède crée un tableau appelé «arr» qui contient des entiers signés 3, 32 bits.

Arrays avec des valeurs par défaut

Le troisième type de tableau en rouille est celui qui contient une valeur par défaut. Dans ce type de tableau, tous les éléments du tableau contiennent une seule valeur identique que vous pouvez mettre à jour comme vous le voyez.

La syntaxe est comme indiqué:

Laissez Array_name: [data_type; array_size] = [default_value; array_size];

Un exemple d'un tel tableau est comme indiqué:

fn main ()
Laissez Arr: [&str; 3] = ["nil"; 3];

L'exemple ci-dessus crée un tableau de & Str et Taille 3. Nous incluons également une valeur par défaut, «nul». Par conséquent, les trois éléments du tableau maintiendront la valeur par défaut à moins que.

Tableau d'impression de rouille

Nous pouvons imprimer un tableau à l'aide du println! macro et le trait de débogage dans le std :: fmt. Un exemple est comme indiqué:

fn main ()
Laissez Arr: [&str; 3] = ["nil"; 3];
println!(":? ", arr);

Le code ci-dessus doit imprimer le tableau comme indiqué:

Indexation de la réseaux de rouille

Bien que nous puissions imprimer l'intégralité du tableau à l'aide du trait de débogage du module FMT, nous pouvons accéder aux éléments individuels à partir du tableau en utilisant son index.

Dans Rust, l'indexation du tableau commence à 0. Cela signifie que le premier élément du tableau est à l'index 0, et le second est à l'index 1 et ainsi.

Pour accéder à un élément par son index, nous utilisons le nom du tableau suivi de l'index de l'élément auquel nous souhaitons accéder à l'intérieur d'une paire de supports carrés.

Un exemple est comme indiqué:

fn main ()
Laissez Arr: [&str; 3] = ["nil"; 3];
println!("", arr [0]);

L'exemple ci-dessus doit être l'élément à l'index 0 ou le premier élément du tableau.

Pour obtenir le dernier élément du tableau, nous utilisons la longueur du tableau - 1 puisque l'indexation commence à 0.

Un exemple est comme indiqué:

fn main ()
Laissez les bases de données: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];
println!("", bases de données [bases de données.len () - 1]);

Dans l'exemple ci-dessus, nous utilisons la fonction Len () pour obtenir la longueur du tableau. Cette fonction intégrée renvoie la longueur (nombre d'éléments) dans le tableau.

Le programme ci-dessus doit renvoyer l'élément à l'index 2 comme:

Rust itérer sur le tableau

Une autre opération courante lorsque vous travaillez avec les tableaux est d'itérer sur chaque élément du tableau. À Rust, nous pouvons y parvenir en utilisant une boucle pour une boucle.

Un exemple est comme indiqué ci-dessous:

fn main ()
Laissez les bases de données: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];
pour i dans 0… bases de données.Len ()
println!("Index: , élément: ", i, bases de données [i]);

L'exemple de programme ci-dessus utilise une boucle simple pour itérer les éléments du tableau. Pour obtenir le nombre d'éléments dans le tableau, nous pouvons utiliser la fonction Len (). À l'intérieur de la boucle FOR, nous accédons à chaque élément en fonction de l'index.

Les valeurs résultantes sont telles que montrées:

Mutabilité du tableau de rouille

Comme toutes les variables de la rouille, les tableaux sont immuables par défaut. Par conséquent, essayer de changer le tableau entraînera une erreur.

Un exemple est comme indiqué:

fn main ()
Laissez les bases de données: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];
bases de données [0] = "PostgreSQL";

Le programme ci-dessus tente de modifier la valeur de l'élément à l'index 0. L'exécution du code ci-dessus renverra une erreur comme indiqué:

Nous pouvons définir le tableau sur Mutable en utilisant le mot clé Mut pour éviter cette erreur. Le code est comme indiqué ci-dessous:

Laissez les bases de données Mut: [&str; 3] = ["MySQL", "MongoDB", "SQL Server"];

Cela rend le tableau mutable, vous permettant de modifier ses valeurs comme bon.

Conclusion

Cet article a exploré comment créer et utiliser des tableaux de rouille. Gardez à l'esprit que les tableaux peuvent être élargis pour faire beaucoup plus. Considérez les documents de rouille pour plus d'informations.