Rust 數據類型

I tipi di dati di base nel linguaggio Rust sono i seguenti.

Integer

I tipi di interi (Integer) sono abbreviati in Integer e sono classificati in base alla lunghezza in bit e alla presenza di segno come segue:

isize e usize sono due tipi di interi utilizzati per misurare la dimensione dei dati, la loro lunghezza in bit dipende dalla piattaforma di destinazione, se il processore è di architettura a 32 bit utilizzerà un intero a 32 bit di lunghezza.

Esistono diversi modi per esprimere numeri interi:

Evidentemente, ci sono underscore tra alcuni numeri interi, questo design rende più facile per le persone valutare approssimativamente il valore di un numero molto grande.

Tipo di numero a virgola mobile (Floating-Point)

Rust supporta come altri linguaggi numeri a virgola mobile di 32 bit (f32) e 64 bit (f64). Per default, 64.0 rappresenta un numero a virgola mobile di 64 bit, poiché i processori moderni elaborano entrambi i tipi di numeri a virgola mobile a velocità quasi identica, ma i numeri a virgola mobile di 64 bit hanno una maggiore precisione.

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

Operazioni matematiche

Usare un programma per rispondere a operazioni matematiche:

fn main() {　
　　　　let sum = 5 + 10; // Somma　
　　　　let difference = 95.5 - 4.3; // Sottrazione　
　　　　let product = 4 * 30; // Moltiplicazione　
　　　　let quotient = 56.7 / 32.2; // Divisione　
　　　　let remainder = 43 % 5; // Calcolo del resto
}

Molti operatori seguiti da un equal (=) sono operazioni di auto-aumento, ad esempio:

sum += 1 è equivalente a sum = sum + 1.

注意：Rust non supporta ++ e --perché questi due operatori appaiono davanti e dietro le variabili, influenzando la leggibilità del codice e riducendo la consapevolezza del developer riguardo alle modifiche delle variabili.

Il tipo booleano

Il tipo booleano è rappresentato da bool, i cui valori possono essere solo true o false.

Il tipo di carattere

Il tipo di carattere è rappresentato da char.

Il tipo char in Rust ha una dimensione di 4 byte e rappresenta un valore scalare Unicode, il che significa che può supportare caratteri non inglesi come cinese, giapponese e coreano, nonché emoji e spazi di larghezza zero in Rust sono valori char validi.

L'intervallo dei valori Unicode va da U+0000 a U+D7FF e da U+E000 a U+10FFFF (inclusi entrambi gli estremi). Tuttavia, il concetto di "carattere" non esiste in Unicode, quindi l'intuizione che si ha su "carattere" potrebbe non corrispondere al concetto di carattere in Rust. Pertanto, si consiglia generalmente di utilizzare stringhe per memorizzare testi UTF-8 (evitando di inserire caratteri non inglesi nelle stringhe il più possibile).

注意：由於中文文字編碼有兩種（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; // 正确