Rust 數據類型

Os tipos de dados básicos no Rust são os seguintes.

Tipos de inteiros (Integer)

Os tipos de inteiros (Integer) no Rust são nomeados conforme o comprimento de bits e se são assinados ou não, dividindo-se em:

usize e isize são tipos de inteiros usados para medir o tamanho dos dados, cujo comprimento de bits depende da plataforma alvo, se for 32 Os processadores de arquitetura de 32 bits usarão 32 inteiros de comprimento fixo de 32 bits.

As formas de expressar números inteiros são as seguintes:

Claramente, alguns inteiros têm um sublinhado no meio, este design permite que as pessoas julguem mais facilmente o valor aproximado de um número grande quando digitam um número grande.

tipos de ponto flutuante (Floating-Point)

O Rust, como outras linguagens de programação, suporta 32 ponto flutuante de 32 bits (f32) e 64 ponto flutuante de 32 bits (f64) Pelo padrão,64.0 representará 64 Ponto flutuante de 32 bits, pois os processadores de computadores modernos calculam a velocidade de ambos os tipos de ponto flutuante praticamente igualmente, mas 64 A precisão de ponto flutuante de 32 bits é maior.

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

Operações matemáticas

Uso de um programa para representar operações matemáticas:

fn main() {　
　　　　let sum =　5　+　10;　//　adição　
　　　　let difference =　95.5　-　4.3;　//　subtração　
　　　　let product =　4　*　30;　//　multiplicação　
　　　　let quotient =　56.7　/　32.2;　//　divisão　
　　　　let remainder =　43　%　5;　//　resto da divisão
}

Muitos operadores, seguidos de um sinal de igual (=), significam operações auto, por exemplo:

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

注意：O Rust não suporta ++ e --porque esses operadores, ao aparecerem antes ou depois de uma variável, podem afetar a legibilidade do código e diminuir a capacidade do desenvolvedor de perceber as mudanças nas variáveis.

Tipos booleanos

Os tipos booleanos são representados por bool, cujos valores podem ser true ou false.

Tipos de caractere

Os tipos de caractere são representados por char.

O tipo char do Rust tem o tamanho de 4 Um byte representa um valor de escalão Unicode, o que significa que ele pode suportar caracteres não-ocidentais como chinês, japonês e coreano, bem como emojis e espaços de largura zero, que são valores válidos de char no 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;　//　正確