Rust 数据类型

Les types de données de base en Rust incluent les suivants.

Integer

Le type integer est abrégé en integer, et il est divisé en plusieurs catégories en fonction de la longueur en bits et de l'existence ou non d'un signe :

usize et isize sont deux types d'entiers utilisés pour mesurer la taille des données, leur longueur en bits dépendant de la plateforme cible, s'il s'agit de 32 les processeurs à architecture de bits de 32 longueur de bits entiers.

Il existe plusieurs méthodes d'expression des entiers :

Il est évident que certains entiers contiennent une barre oblique, ce qui permet aux utilisateurs de mieux juger de la valeur approximative d'un grand nombre lors de l'entrée.

Floating-Point)

Rust prend en charge, comme d'autres langages, 32 bits de précision en virgule flottante (f32) et 64 bits de précision en virgule flottante (f64)。Par défaut,64.0 représentera 64 bits de précision en virgule flottante, car les processeurs informatiques modernes traitent les deux types de nombres en virgule flottante à une vitesse presque égale, mais 64 bits de précision en virgule flottante sont plus élevés.

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

Opérations mathématiques

Utiliser un programme pour réagir aux opérations mathématiques :

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;　//　modulo
}

Les opérateurs mathématiques suivants peuvent être suivis d'un signe égal pour indiquer une opération auto, par exemple :

sum += 1 est équivalent à sum = sum + 1.

注意：Rust ne prend pas en charge ++ et --parce que ces deux opérateurs, lorsqu'ils apparaissent avant ou après une variable, peuvent affecter la lisibilité du code et réduire la capacité du développeur à être conscient des changements des variables.

Le type booléen

Le type booléen est représenté par bool, et ses valeurs peuvent être true ou false.

Le type de caractères

Les caractères sont représentés par char.

La taille du type char en Rust est 4 Un octet représente une valeur scalaire Unicode, ce qui signifie qu'il peut soutenir des caractères non latins tels que le chinois, le japonais, le coréen, ainsi que des emojis et des espaces de largeur nulle, ce qui est un type de valeur char valide en Rust.

Unicode 值的范围从 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF （包括两端）。 但是，"字符"这个概念并不存在于 Unicode 中，因此您对"字符"是什么的直觉可能与Rust中的字符概念不匹配。所以一般推荐使用字符串储存 UTF-8 文字（非英文字符尽可能地出现在字符串中）。

注意：由于中文文字编码有两种（GBK 和 UTF-8），所以编程中使用中文字符串有可能导致乱码的出现，这是因为源程序与命令行的文字编码不一致，所以在 Rust 中字符串和字符都必须使用 UTF-8 编码，否则编译器会报错。

复合类型

元组用一对 ( ) 包括的一组数据，可以包含不同种类的数据：

let　tup:　(i32,　f64,　u8)　=　(500,　6.4,　1);
//　tup.0　等于　500
//　tup.1　等于　6.4
//　tup.2　等于　1
let　(x,　y,　z)　=　tup;
//　y　等于　6.4

数组用一对 [ ] 包括的同类型数据。

let　a　=[1,　2,　3,　4,　5];
//　a　是一个长度为　5　的整型数组
let　b　=["January",　"February",　"March"];
//　b　是一个长度为　3　的字符串数组
let　c:　[i32;　5]　=[1,　2,　3,　4,　5];
//　c　是一个长度为　5　的　i32　数组
let　d　=[3;　5];
//　等同于　let　d　=[3,　3,　3,　3,　3];
let　first　=a[0];
let　second　=a[1];
//　数组访问
a[0]　=　123;　//　错误：数组　a　不可变
let　mut　a　=[1,　2,　3];
a[0]　=　4;　//　正确