Types de données Rust

Les types de données de base du langage Rust sont les suivants.

Integer

Les types d'entiers sont appelés entiers. Selon la longueur en bits et qu'ils soient signés ou non, ils sont divisés en les catégories suivantes :

Longueur en bits	Signé	Non signé
8 bits	i8	u8
16 bits	i16	u16
32 bits	i32	u32
64 bits	i64	u64
128 bits	i128	u128
arch	isize	usize

Les types entiers isize et usize servent à mesurer la taille des données. Leur longueur en bits dépend de la plateforme cible sur laquelle ils s'exécutent. S'il s'agit d'un processeur d'architecture 32 bits, une longueur d'entier de 32 bits sera utilisée.

Il existe plusieurs façons de représenter les entiers :

Base	Exemple
Decimal	98_222
Hexadécimal	0xff
Octal	0o77
Binary	0b1111_0000
Octet (ne peut représenter que le type u8)	b'A'

De toute évidence, certains entiers comportent un trait de soulignement au milieu. Cette conception permet aux gens d'estimer plus facilement la valeur d'un nombre lorsqu'ils saisissent un très grand nombre.

Virgule flottante

Comme d'autres langages, Rust prend en charge les nombres à virgule flottante 32 bits (f32) et 64 bits (f64). Par défaut, 64.0 représentera un nombre à virgule flottante de 64 bits, car les processeurs informatiques modernes traitent les deux types de calculs en virgule flottante à une vitesse presque identique, mais les nombres à virgule flottante 64 bits ont une précision supérieure.

Exemple

fn main() {
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}

Opérations mathématiques

Utilisez un programme pour illustrer les opérations mathématiques :

Exemple

fn main() {
let sum = 5 + 10; // Addition
let difference = 95.5 - 4.3; // Soustraction
let product = 4 * 30; // Multiplication
let quotient = 56.7 / 32.2; // Division
let remainder = 43 % 5; // Reste
}

Ajouter un signe = après de nombreux opérateurs signifie une opération sur lui-même, par exemple :

sum += 1Équivalent àsum = sum + 1。

Remarque :Rust ne prend pas en charge++et--, car lorsque ces deux opérateurs apparaissent avant ou après une variable, ils affectent la lisibilité du code et réduisent la conscience qu'a le développeur des modifications de la variable.

Boolean

Le booléen est représenté par bool, et sa valeur ne peut être que true ou false.

Caractère

Le type caractère est représenté par char.

Le type char de Rust a une taille de 4 octets et représente une valeur scalaire Unicode. Cela signifie qu'il peut prendre en charge des caractères non anglais tels que les caractères chinois, japonais et coréens. Même les emojis et les espaces de largeur nulle sont des valeurs char valides en Rust.

Les valeurs Unicode vont de U+0000 à U+D7FF et de U+E000 à U+10FFFF (inclus). Cependant, le concept de « caractère » n'existe pas dans Unicode, donc votre intuition de ce qu'est un « caractère » peut ne pas correspondre au concept de caractère en Rust. Par conséquent, il est généralement recommandé d'utiliser des chaînes de caractères pour stocker du texte UTF-8 (les caractères non anglais doivent apparaître dans les chaînes autant que possible).

Remarque :Comme il existe deux encodages de texte chinois (GBK et UTF-8), l'utilisation de chaînes chinoises en programmation peut provoquer des caractères mal affichés. En effet, le programme source et la ligne de commande ont des encodages de texte incohérents. Par conséquent, en Rust, les chaînes et les caractères doivent utiliser l'encodage UTF-8, sinon le compilateur signalera une erreur.

Types composés

Un tuple utilise une paire de( )parenthèses pour englober un ensemble de données, qui peut contenir différents types de données :

Exemple

let tup: (i32, f64, u8) = (500, 6.4, 1);
// tup.0 est égal à 500
// tup.1 est égal à 6.4
// tup.2 est égal à 1
let (x, y, z) = tup;
// y est égal à 6.4

Un tableau utilise une paire de[ ]crochets pour contenir des données du même type.

Exemple

let a = [1, 2, 3, 4, 5];
// a est un tableau d'entiers de longueur 5

let b = ["janvier", "février", "mars"];
// b est un tableau de chaînes de caractères de longueur 3

let c: [i32; 5] = [1, 2, 3, 4, 5];
// c est un tableau i32 d'une longueur de 5

let d = [3; 5];
// Équivalent à let d = [3, 3, 3, 3, 3];

let first = a[0];
let second = a[1];
// Accès au tableau

a[0] = 123; // Erreur : le tableau a n'est pas mutable
let mut a = [1, 2, 3];
a[0] = 4; // Correct

Autres extensions