Tipos de datos escalares en Rust

Todas las variables inicializadas usan el tipo de datos durante la declaración para restringir el tipo de datos que se almacenarán. Por lo tanto, podemos decir que los tipos de datos se utilizan para decirle a las variables el tipo de datos que pueden almacenar. 

En este artículo, hablaremos específicamente sobre los tipos de datos escalares en el lenguaje de programación Rust. Un tipo Scalar en Rust representa un valor único. Por ejemplo, un tipo de datos int solo almacena datos enteros únicos y no varios enteros ni una combinación de diferentes tipos de datos.

Rust tiene cuatro tipos escalares primarios: 

• enteros
• Números de punto flotante
• booleano
• Caracteres

Vamos a discutirlos en detalle.

tipos enteros

Los números enteros están en todas partes, Integer es un número entero con un signo y sin una parte fraccionaria. Por ejemplo, 1, 5, -9, 200001, -15489752 son números enteros

Los enteros son uno de los tipos de datos primitivos en Rust, el compilador de Rust puede detectar automáticamente los enteros y también el programador puede definir explícitamente el tipo de entero. 

Ejemplo:

fn main() {
   
      // implicitly defining int
    let x = 6;
   
      // explicitly defining unsigned int
    let y: u16 = 9;
   
      // explicitly defining signed int
    let z: i16 = -7;
    println!("{} {} {}", x,y,z);
}

Producción:

6 9 -7

En Rust, la declaración de enteros indica que el valor con el que está asociado debe ser un entero sin signo que comienza con u ( o) los tipos de enteros con signo comienzan con i y ocupan 32 bits de espacio con un mínimo de 8 bits.

Los tipos enteros complemento con signo tienen:

Tipos de punto flotante

Números enteros de coma flotante con partes decimales. Por ejemplo 3.22, -5.89, 200.0000. Rust también tiene un tipo de datos primitivo para números flotantes. Los tipos de coma flotante de Rust son f32 y f64, que tienen un tamaño de 32 bits y 64 bits, respectivamente. Al igual que los números enteros, puede definir números de punto flotante tanto explícita como implícitamente. Sintaxis de números de punto flotante

fn main() {
// implicit floating number type
let x = 200.000;
// explicitly floating point type
let y: f64 = 9.894;
let z: f64 = -7.4;
println!("{} {} {}", x,y,z);
}

Producción

200 9.894 -7.4

tipos booleanos

El tipo booleano es uno de los tipos de datos integrados proporcionados por Rust, que se definen mediante las palabras clave True o False. Generalmente, se utiliza para representar los valores de verdad de las expresiones. Los tipos booleanos en Rust se proporcionan con memoria de 1 bit. El tipo booleano en Rust se especifica mediante la palabra clave bool.

fn main() {
// true boolean
let x: bool = true;
// false boolean
let y: bool = false;
println!("{} {}", x,y);
}

Producción:

true false

Tipos de caracteres

El tipo de datos de caracteres se utiliza para almacenar caracteres. La palabra clave utilizada para el tipo de datos de carácter es char . Los caracteres normalmente requieren 1 byte de espacio de memoria y varían de -128 a 127 o de 0 a 255. 

Ejemplo:

fn main() {
    let s = 'z';
    let c = 'ℤ';
      println!("{} {}", s,c);
}

Producción

z ℤ

Programa Rust simple con todos los tipos de datos escalares:

fn main() {
   
        // Default is "i32"
        let g = 9;
        println!("{}", g);
   
        // Default is "f64"
        let f = 2.9;
        println!("{}", f);
   
        // Add explicit type
        let e: i64 = 14122020;
        println!("{}", e);
   
        // Boolean
        let is_active: bool = true;
        println!("{}", is_active);
   
        // char
        let c = 'a';
        println!("{}", c);
        let face = '\u{1F600}';
        println!("{}", face);
}

Producción:

9
2.9
14122020
true
a
????