Types de données de rouille
Les types de données sont une caractéristique universelle parmi de nombreux langages de programmation et fournissent un bloc de construction solide pour les programmes que nous construisons avec. Gardez à l'esprit que chaque langue a ses propres types qui peuvent différer des autres langues.
En tant que programmeurs, connaître les différents types primitifs fournis par une langue est plus que crucial. Par conséquent, pour ce tutoriel, nous parcourons les différents types du langage de programmation de rouille.
Types primitifs de la rouille
Il existe deux catégories principales pour les types primitifs de rouille:
- Types scalaires
- Types de composés
Cependant, peu importe si un type est scalaire ou composé, tout ce que vous devez savoir est de savoir comment l'utiliser dans vos programmes.
Commençons par les types les plus courants et les plus basiques de la rouille:
Entiers
La première catégorie de types primitifs dans la rouille est. Un entier est un type de nombre qui n'a pas de valeur fractionnaire. Il existe différents types de types entiers dans la rouille et comprennent:
- i8
- U8
- i16
- U16
- i32
- U32
- i64
- U64
- i128
- U128
- isize
- user
Chaque type entier prend le format de:
lettreLa lettre dans ce cas indique si le nombre peut avoir un signe. Si le type est signé (i), il peut avoir une valeur négative. Si non signé (u), le nombre ne sera positif que.
La valeur du nombre représente la taille des bits que le type occupera en mémoire. Par exemple, une valeur i32 représente un entier signé 32 bits.
Le type isize ou usize dépendra de l'architecture sur laquelle le code s'exécute. Si vous êtes sur une architecture 32 bits, le type prendra 32 bits et 64 bits pour les architectures 64 bits.
NOTE: Assurez-vous de conserver vos valeurs dans la plage de vos types spécifiés. Sinon, vous avez un débordement qui pourrait conduire à des opérations dangereuses.
L'exemple de programme ci-dessous montre comment déclarer et utiliser des types entiers en rouille.
fn main ()// types entiers
Soit i_8 = -128;
Soit u_8 = 127;
Soit i_16 = -32768;
Soit U_16 = 32767;
Soit i_32 = -2147483648;
Soit U_32 = 2147483647;
Soit i_64 = -9223372036854775808_i64;
Soit U_64 = 9223372036854775807_U64;
Soit i_128 = -170141183460469231731687303715884105728_i128;
Soit U_128 = 170141183460469231731687303715884105727_u128;
Soit i_size = -9223372036854775808_isize;
Soit u_size = 9223372036854775807_usize;
println!("i_8 -> \ nu_8 -> \ ni_16 -> \ nu_16 -> \ ni_32 -> \ nu_32 -> \ ni_64 -> \ ni_64 -> \ \ \ ni_64 - Ni_128 -> \ nu_128 -> \ ni_size -> \ nu_size -> ", i_8, u_8, i_16, u_16, i_32, u_32, i_64, u_64, i_128, u_128, i_size, u_Size);
Le programme ci-dessus montre comment déclarer les types int dans la rouille. Cela devrait imprimer:
NOTE: Si vous ne spécifiez pas le type lors de l'attribution d'une valeur numérique, Rust sera par défaut en un type i32.
De type flottant
La rouille a des numéros de type flottant. Ce sont des nombres qui incluent des valeurs de points flottants ou des points décimaux. Il n'y a que deux types de types flottants dans la rouille: F32 et F64 qui sont des valeurs 32 bits et 64 bits.
Exemple de type flottant est comme indiqué:
Soit f_32 = 3.141_f32; // Type flottant 32 bitsSoit f_64 = 3.141; // type flottant 64 bits
Si vous ne spécifiez pas le type pour une valeur à virgule flottante, Rust sera par défaut à F64.
Booléens
L'autre type fourni par Rust est un booléen. Comme toutes les valeurs logiques booléennes, il a deux valeurs possibles: vrai ou faux. Un booléen est un octet de taille.
L'exemple est comme indiqué:
Soit var1 = true;Soit var2 = false;
Type de caractère
Le type de caractère fait référence à un seul caractère Unicode. Il est de 4 octets. Par exemple, ce qui suit montre différents types de types de char Unicode.
Soit a = 'a';Soit Emoji = '😊';
Soit pi = 'π';
Laissez grand = '大';
Les exemples de code ci-dessus représentent divers caractères Unicode.
Tableaux
La deuxième catégorie de types primitifs dans la rouille est les types de composés. Un tableau fait partie du type composé.
Un tableau fait référence à une collection ordonnée de valeurs de types similaires. Le code ci-dessous montre un tableau de rouille:
Laissez la lettre: [&str; 5] = ["A", "B", "C", "D", "E"];Dans Rust, nous déclarons un tableau utilisant le mot-clé LET suivi du nom de la variable, d'un colon complet et du type et de la taille dans un carré.
Tranches
Les tranches sont étroitement similaires aux tableaux, sauf qu'ils sont dynamiques. Contrairement à un tableau, une tranche peut grandir ou rétrécir.
Un exemple est comme indiqué:
Soit slc = [1,2,3,4,5];Tuples
L'autre type de types de données de composés dans la rouille est un tuple. Un tuple est défini une séquence hétérogène de valeurs. Un tuple peut contenir des valeurs de plusieurs types contrairement à un tableau. Les tuples ont également une commande et peuvent être accessibles via leurs index. Vérifiez notre tutoriel sur les tuples de rouille pour en savoir plus.
Un exemple de tuple rouille est comme indiqué ci-dessous:
Soit tup = (1,2,3,4,5); // pas d'annotation de typeLaissez tup_letter: (i32, & str, f64, char) = (100, "bonjour", 3.141, «a»); // Annotation de type explicite
Dans le premier tuple, nous avons laissé le compilateur de rouille à déduire le type en fonction des valeurs fournies.
Pour le second, nous disons explicitement au compilateur quels types nous voulons. Gardez à l'esprit que l'ordre compte dans ce type de déclaration.
Conclusion
De ce tutoriel, vous remarquez que Rust nous fournit une suite de types primitifs impressionnants. Ils nous permettent de gérer divers types de données et de contrôler les données qui entrent ou hors de nos applications.
Merci d'avoir lu!