Tipos de datos de Rust

Los tipos de datos básicos en el lenguaje Rust son los siguientes.

El tipo de datos entero (Integer)

El tipo de datos entero se abrevia como entero, se divide según la longitud de los bits y si es sin signo o con signo en las siguientes categorías:

isize y usize son dos tipos de enteros que se utilizan para medir el tamaño de los datos, su longitud en bits depende de la plataforma de destino en ejecución, si es 32 Los procesadores de arquitectura de bits de bits usarán 32 enteros de longitud de bits bit a bit.

Las formas de expresar números enteros son las siguientes:

Es obvio que algunos enteros tienen un subrayado en el medio, este diseño permite a las personas juzgar más fácilmente cuánto es aproximadamente el valor de un número grande cuando se ingresa.

El tipo de datos de coma flotante (Floating-Point)

Rust, como otros lenguajes, admite 32 los números de coma flotante de bits (f32) y 64 los números de coma flotante de bits (f64)。Por defecto,64.0 representará 64 Los números de coma flotante de bits, ya que los procesadores de computadoras modernos calculan ambos tipos de coma flotante a aproximadamente la misma velocidad, pero 64 La precisión de los números de coma flotante de bits es mayor.

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

Operaciones matemáticas

Un programa que reacciona a operaciones matemáticas:

fn main() {　
　　　　let sum　=　5　+　10;　//　suma　
　　　　let difference　=　95.5　-　4.3;　//　resta　
　　　　let product　=　4　*　30;　//　multiplicación　
　　　　let quotient　=　56.7　/　32.2;　//　división　
　　　　let remainder　=　43　%　5;　//　resta
}

Muchos operadores se pueden añadir = para denotar operaciones automáticas, por ejemplo:

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

Nota:Rust no admite ++ y --, ya que estos operadores afectan la legibilidad del código cuando se encuentran antes o después de una variable, reduciendo la capacidad del desarrollador de ser consciente de los cambios en la variable.

El tipo booleano

El tipo booleano se representa con bool, los valores solo pueden ser true o false.

El tipo de dato de carácter

El tipo de dato de carácter se representa con char.

El tipo char de Rust tiene un tamaño de 4 Un byte, representa el valor escalar Unicode, lo que significa que puede soportar caracteres no latinos como chino, japonés y coreano, incluso emoticonos y espacios de anchura cero, que son valores válidos de char en Rust.

El rango de valores de Unicode va de U+0000 a U+D7FF y U+E000 a U+10FFFF (incluidos los extremos). Sin embargo, el concepto de "carácter" no existe en Unicode, por lo que su intuición sobre lo que es un "carácter" puede no coincidir con el concepto de carácter en Rust. Por lo tanto, se recomienda generalmente usar cadenas para almacenar UTF-8 Caracteres (no caracteres ingleses) deben aparecer en la cadena lo más posible).

Nota:Debido a que la codificación de caracteres chinos tiene dos tipos (GBK y UTF-8），por lo que el uso de cadenas de caracteres chinos en la programación puede causar la aparición de caracteres ilegibles, porque la codificación de caracteres del programa fuente y la línea de comandos no coinciden, por lo que en Rust, las cadenas y caracteres deben usar UTF-8 Codificación, de lo contrario, el compilador generará un error.

Tipos compuestos

Los tuplos se incluyen entre paréntesis ( ) y contienen un grupo de datos, que pueden incluir diferentes tipos de datos:

let　tup:　(i32,　f64,　u8)　=　(500,　6.4,　1);
//　tup.0 es igual a　500
//　tup.1　Es igual a　6.4
//　tup.2　Es igual a　1
let　(x,　y,　z)　=　tup;
//　y es igual a　6.4

Los arrays se incluyen entre corchetes [ ] y contienen datos del mismo tipo.

let　a　=　[1,　2,　3,　4,　5];
//　a es un array de longitud　5　Array de enteros
let　b　=　["January",　"February",　"March"];
//　b es un array de longitud　3　Array de cadenas
let　c:　[i32;　5]　=　[1,　2,　3,　4,　5];
//　c es un array de longitud　5　del i32　Array
let　d　=　[3;　5];
//　Es equivalente a let　d　=　[3,　3,　3,　3,　3];
let　first　=　a[0];
let　second　=　a[1];
//　Acceso al array
a[0]　=　123;　//　Error: El array a no es inmutable
let　mut　a　=　[1,　2,　3];
a[0]　=　4;　//　Correcto