Rust est un langage de programmation moderne à typage statique conçu pour la performance, la fiabilité et la sécurité. Comme dans d'autres langages à typage statique, vous déclarez les types de données Rust au moment de la compilation. Cela facilite la détection des erreurs de type avant d'exécuter votre code.
Rust propose des types scalaires, composés, de référence, des structures, des énumérations et des chaînes. Son inférence de type fournit des fonctionnalités pour écrire du code concis tout en maintenant la sécurité d'un langage typé statiquement.
Entiers en Rust
Rust fournit des types d'entiers signés et non signés classés en fonction du nombre de bits. Les types d'entiers signés sont i8, i16, i32, et i64 représentant respectivement des entiers signés 8 bits, 16 bits, 32 bits et 64 bits. Il prend également en charge les types d'entiers non signés sont
u8, u16, u32, et u64, représentant des entiers non signés 8 bits, 16 bits, 32 bits et 64 bits.// entiers signés
laisser un: i8 = -10;
laisser b: i16 = -2048;
laisser c: i32 = -2147483648;
laisser ré: i64 = -9223372036854775808;
// entiers non signés
laisser e: u8 = 255;
laisser f: u16 = 65535;
laisser g: u32 = 4294967295;
laisser h: u64 = 18446744073709551615;
Rust utilise le i32 type pour les littéraux entiers par défaut.
Types à virgule flottante de rouille
La rouille fournit f32 et f64 en tant que types à virgule flottante qui représentent des nombres à virgule flottante simple précision et double précision. Le f32 type utilise 32 bits pour stocker les valeurs, et le f64 type utilise 64 bits.
Les nombres à virgule flottante dans Rust suivent la norme IEEE 754 pour l'arithmétique à virgule flottante.
laisser un = 3.14159265358979323_f32 ;
laisser b = 2.718281828459045235_f64 ;
Utiliser les booléens de Rust
La rouille fournit un bourdonner taper pour représenter vrai ou FAUX valeurs. Les booléens sont souvent utilisés dans les instructions de flux conditionnel et de contrôle pour la prise de décision du programme.
laisser variable_1: bool = vrai;
laisser variable_2: bool = FAUX;
Vous pouvez comparer des valeurs booléennes avec l'opérateur d'égalité, ==, et l'opérateur d'inégalité, !=. Rust ne définit pas les opérateurs de comparaison, , <=, et >=, pour bourdonner valeurs.
laisser variable_1: bool = vrai;
laisser variable_2: bool = FAUX;
si variable_1 == variable_2 {
imprimez! ("la variable_1 est égale à la variable_2");
} autresi variable_1 != variable_2 {
imprimez! ("la variable_1 n'est pas égale à la variable_2");
}
Le type de caractère
La rouille carboniser type représente une seule valeur scalaire Unicode qui peut représenter n'importe quel caractère dans la norme Unicode. Vous pouvez spécifier un carboniser valeur en utilisant des guillemets simples.
// Déclaration d'une valeur char
laisser c = 'un';
Le carboniser type est utile pour travailler avec les emojis dans Rust.
Tuples dans Rust
La structure de données tuple vous permet de regrouper plusieurs valeurs en une seule valeur composée. Ces valeurs peuvent avoir le même type ou des types différents. Vous pouvez déclarer des tuples en les écrivant sous la forme d'une liste de valeurs séparées par des virgules entourées de parenthèses.
Voici comment vous pouvez déclarer un tuple avec des entiers 32 bits, des chaînes et des valeurs float64.
laisser tup: (i32, &str, f64) = (500, "Bonjour", 3.14);
Les tuples ont une longueur fixe et vous pouvez les utiliser pour renvoyer plusieurs valeurs à partir d'une fonction ou transmettre plusieurs valeurs à des fonctions en tant qu'argument unique.
Vous pouvez accéder aux éléments individuels d'un tuple en le déstructurant à l'aide de la correspondance de modèle ou en accédant directement aux éléments individuels à l'aide de la syntaxe point (.) et d'un index.
Voici comment vous pouvez accéder aux éléments individuels d'une structure à l'aide de la correspondance de modèle :
laisser mon_tuple = (10, "Bonjour le monde!", FAUX);laisser (x, y, z) = mon_tuple ;
imprimez! ("Le premier élément est: {}", X);
imprimez! ("Le deuxième élément est: {}", y);
imprimez! ("Le troisième élément est: {}", z);
Voici comment vous pouvez accéder à des éléments individuels en utilisant la notation par points :
laisser mon_tuple = (10, "Bonjour le monde!", FAUX);
println!("Led'abordélémentest: {}", mon_tuple.0);
println!("Ledeuxièmeélémentest: {}", mon_tuple.1);
println!("Letroisièmeélémentest: {}", mon_tuple.2);
Les tuples sont très utiles pour regrouper des données liées en une seule valeur. Ils peuvent également améliorer la lisibilité de votre code si vous les utilisez avec parcimonie.
Tableaux en Rust
Un tableau est une collection d'éléments de même type avec une longueur fixe. Vous écrivez les tableaux Rust sous la forme d'une liste de valeurs entre crochets, séparées par des virgules.
Voici comment vous pouvez déclarer des tableaux dans Rust :
laisser arr = [1, 2, 3, 4, 5];
Vous ne pouvez pas modifier le nombre d'éléments dans un tableau une fois que vous l'avez déclaré, mais vous pouvez accéder, modifier et manipuler des éléments individuels d'un tableau à l'aide de l'indexation.
laisser mut mon_tableau = [1, 2, 3, 4, 5];// Accéder aux éléments
println!("Led'abordélémentest: {}", my_array[0]);// Modification des éléments
mon_tableau[0] = 100 ;
println!("Led'abordélémentaprèsmodificationest: {}", my_array[0]);// Boucle sur un tableau et manipulation d'éléments
pourjedans 0..my_array.len() {
mon_tableau[i] *= 2;
}
// impression du tableau
imprimez! ("Le tableau après manipulation: {:?}", mon_tableau);
Les tableaux de rouille sont stocké sur la pile et ont une allocation de mémoire contiguë, de sorte que l'accès aux éléments d'un tableau est rapide et efficace. Cela rend les tableaux adaptés aux situations où vous devez stocker et traiter de nombreux éléments.
Travailler avec des tranches de rouille
Une tranche est une structure de données qui permet de référencer une séquence contiguë d'éléments dans une collection. Les tranches sont représentées par le &[T] type, où T est le type des éléments stockés dans la tranche.
fn principal(){
// déclarer un tableau
laisser mon_tableau = [1, 2, 3, 4, 5];// crée une tranche à partir du tableau
laisser ma_tranche = &mon_tableau[1..3];
// imprime la tranche
imprimez! ("Tranche: {:?}", ma_tranche);
}
Remarquez comment la syntaxe de la plage, .., extrait une tranche d'un tableau en utilisant l'index de départ et un index supérieur d'un à la fin :
Les tranches sont dynamiques, donc Rust peut déterminer leur longueur au moment de l'exécution. Vous pouvez également passer des tranches en tant qu'arguments aux fonctions sans avoir besoin d'allocation de tas.
Vous utiliserez généralement des tranches pour les opérations sur les chaînes et pour transmettre des sous-ensembles de données aux fonctions. Ils constituent un outil puissant et efficace pour gérer les collections dans Rust, offrant une alternative plus flexible aux tableaux.
Vous pouvez créer des applications Web frontales alimentées par WebAssembly dans Rust
La connaissance des types de données est essentielle à votre parcours Rust, car vous les utiliserez pour la plupart des opérations lors de la création d'applications.
WebAssembly est un format binaire de bas niveau qui s'exécute sur les navigateurs Web modernes, avec des performances quasi natives. Il vous permet d'écrire du code dans de nombreux langages différents et de le transpiler vers WebAssembly.
WebAssembly est de plus en plus adopté par Rust. Il existe de nombreux frameworks tels que Yew, Sycamore et Seed que vous pouvez utiliser pour créer des interfaces WebAssembly avec Rust.