Variables de Rust y cómo mostrarlas en pantalla

Clase 6 de 20 • Curso de Rust básico

Contenido del curso

Inicia tu camino con Rust

Domina las bases de Rust

Primer proyecto: calculadora digital

Estructuras y funciones en Rust

Segundo proyecto: videojuego de texto

Esto es solo el comienzo

20
Únete a la comunidad, Rustacean
00:45 min

Tomar examen

Resumen

Como todo lenguaje de programación, Rust posee diversos tipos de variables para almacenar números, cadenas de caracteres, etc.

Variables numéricas en Rust

En Rust, encontrarás diferentes tipos de variables numéricas para el guardado de números con mayor o menos longitud y con/sin signo.

Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128

Por ejemplo, i8 permite guardar números hasta 8 bits. 50% para números positivos y el otro 50% para números negativos. Mientras que u8, al no tener signo, permite guardar solo números positivos. Esto permite tener más capacidad de manipular números y realizar operaciones.

Data Type	Min	Max	Length
i8	-128	127	8-bit
i16	-32768	32767	16-bit
i32	-2147483648	2147483647	32-bit
i64	-92233720368547...	92233720368547...	64-bit
i128	-17014118346046923173168...	17014118346046923173168...	128-bit

Si tienes la necesidad de guardar números extremadamente grandes, puedes utilizar u128 para guardar el doble de números positivos en comparación con lo que permite i128.

Data Type	Min	Max
u8	0	255
u16	0	65535
u32	0	4294967295
u64	0	18446744073909551615
u128	0	340282366920938463463374607431768211455

Declaración de variables numéricas en Rust

Rust es un lenguaje fuertemente tipado, lo que significa que tienes que hacer explícito el tipo de las variables y este no pueden cambiar en tiempo de ejecución. Para declarar una variable y su tipo, hazlo haciendo uso de la palabra reservada let y el tipo de la misma:

fn main() {
    let a: i16 = 100;
    let b: u16 = 200;
    println!("El número es {} y {}", a, b);     // El número es 100 y 200
}

Para utilizar y mostrar por pantalla dichas variables, utiliza el comando println!() e ingresa el texto que deseas mostrar. Las variables que le pases después de la primera coma, reemplazarán los {}, denominados "placeholders", y formateará el texto en el orden que hayas establecido el ingreso de cada valor.

Por último, si deseas permitir que el valor de una variable sea modificable, tienes que agregar explícitamente la palabra reservada mut en la declaración de la misma, ya que, por defecto, no puedes modificar el valor de una variable.

fn main() {
    let mut a: i16 = 100;
    let b: u16 = 200;
    a = a + 1;
    println!("El número es {} y {}", a, b);     // El número es 101 y 200
}

Variables del tipo string en Rust

Para el guardado de variables del tipo cadenas de texto, el tipado se realiza con la palabra reservada &str.

fn main() {
    let name: &str = "Kevin";
    println!("Mi nombre es {}", name);      // Mi nombre es Kevin
}

Recuerda que puedes correr tu proyecto de Rust con el comando cargo run y visualizar los mensajes y los valores de las variables desde la terminal de línea de comandos.

De esta manera, ya sabes los conceptos básicos sobre declaración de variables y tipado de las mismas en Rust, además de mostrar sus valores por pantalla.

Contribución creada por Kevin Fiorentino con aportes de Sergio Estrella.

Comentarios

Sergio Estrella

teacher•

Al manejar un número definido de bits, cada variable puede albergar hasta un cierto número de valor (Por ejemplo, si tratáramos de guardar un 256 en una variable de tipo u8, me saltaría error de Out of range (Fuera de rango)

La diferencia entre los signed y unsigned, es que estos últimos solo utilizan su capacidad para almacenar números positivos, mientras que los signed lo usan para una cantidad igual de números positivos y negativos.

Andrés Felipe Lopez gomez

student•

excelente aporte

Jose Alfonso Velaides Machado

student•

Gracias por el aporte!

Kevin Jeremy Salazar Jimenez

student•

Probe la concatenacion de la siguiente manera y tambien me funciono

fn main() {
    let edad:u8 = 58;
    let nombre:&str = "Kevin";
    println!("Hola soy {nombre} y tengo {edad} años");
}

Adolfo Martínez Garza

student•

Gran aporte compañero

Carlos Rodríguez

student•

Que buen aporte.

Yony Calsin

student•

fibonacci en rust

fn fibonacci(n: u32) -> u32 {
    if n == 0 {
        return 0;
    } else if n == 1 {
        return 1;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

fn main() {
    println!("{}", fibonacci(10));
}

Luis Alberto Juarez Corona

student•

Buena recursividad master!! añado mi recursividad con factorial.

fn factorial(num: u32)->u32{
    if num == 0{
        return 1;
    }
    else{
        return num * (factorial(num - 1));
    }
}

fn main() {
    println!("Resultado: {:?}",factorial(1));
}

Sebastián Ospino

student•

Mi pana, la recursividad no es recomendable. Esta es la implementación lineal de fibonacci, el input máximo es 186, después de eso habrá overflow

fn fib(n: u8) -> u128 {
    return if n > 1 {
        let mut i: u8 = 1;
        let mut n0: u128 = 0;
        let mut n1: u128 = 1;
        let mut aux: u128;
        while i < n {
            aux = n1;
            n1 = n1 + n0;
            n0 = aux;
            i += 1;
        }
        n1
    } else {
        n as u128
    }
}

Andersson Johan Ramirez Mosquera

student•

Las variables en rust son inmutables (no pueden modificarse) tanto en su valor como es su tipo, para hacer una variable mutable se debe agregar la palabra reservada mut y el tipo de dato se debe natener

Los tipos de datos relacionados con numeros pueden ser definidos sin signo y con signo, es decir que se puede limitar el uso inecesario de bits en memoria como por ejemplo con una variable para la edad que no puede ser negativa y para los humanos normalente no puede superar el valor de 100 o sea que el tipo de dato mas apropiado es u8
Rust maneja mas de dos tipos de datos con respecto a los strings que se puede ver en su propia documentacion

Max Castillo

student•

Se puede ver lo seguro que es el lenguaje rust

Rodrigo Andrés Moreno Pertúz

student•

like python

print("Hola: {} edad: {}".format(variable1,variable2))

Erick Alay

student•

Hahaha Python be like! 🤣

Carlos Rodríguez

student•

:wink:

Juan Matus

student•

fn main() {
    let max_temp: i32 = 80;
    let min_temp: i32 = -40;

    println!("The max temperature is {}", max_temp);
    println!("The min temperature is {}", min_temp);
}

Edward Rodriguez

student•

Diferentes y sencillas formas de definir un string en otros lenguajes, y en este toca poner un ampersan?

Carlos José González Juan

student•

Moises Samuel Urias Moreno

student•

El tipo de datos para números negativos es: i32. Ese es el tipo por defecto de Rust para los integer

Enrique Andres Gonzalez Pelaez

student•

fn main() {
    let minima: i8 = -15;
    let maxima: u8 = 40;

    println!("En mi ciudad la minima fue de {} y la maxima fue de {}", minima, maxima);
}

Cristian Marchese

student•

Me suena raro el hecho de "variable" "constante". después a pesar de algunas cosas de la escritura creo que tiene un parecido a C, verdad?.

Samuel Rueda

student•

fn main() {

//Puse numeros al azar xd

//programa
let ciudad: &str = "Bogota";
let t_min: i8 = -2;
let t_max: u128 = 30;

println!("La temperatura minima de {} fue de {} y la maxima de {}", ciudad, t_min, t_max)

}

Alejandro Medina

student•

Rust tiene varios tipos de datos nativos, que se pueden clasificar en categorías principales:

Escalares: Representan un solo valor. Incluyen:
- Enteros: i8, i16, i32, i64, i128, isize (con signo) y u8, u16, u32, u64, u128, usize (sin signo).
- Flotantes: f32 y f64.
- Booleano: bool (valores true o false).
- Caracteres: char, que representa un solo carácter Unicode.
Compuestos: Agrupan múltiples valores.
- Tuplas: Colecciones de diferentes tipos.
- Arreglos: Colecciones de elementos del mismo tipo.

Estos tipos de datos son fundamentales para trabajar con Rust y su sistema de tipos.

Erick Garcia

student•

Mi funcion quedo asi:

// i8, i16 - enteros con signo
// u8, u16 - enteros sin signo (positivos)
// &str - string
fn main() {

    let temperatura_minima: i8 = -3;
    let temperatura_maxima: u8 = 32;
    let temperatura_promedio: f32 = (temperatura_minima + temperatura_maxima as i8) as f32/ 2.0;

    print!("La termeratura minima en mi ciudad es {temperatura_minima} y la maxima es {temperatura_maxima} y el promedio es {temperatura_promedio}");
}

Sebastián Ospino

student•

Este es mi aporte

fn main() {
    // Signed numbers
    let _x1: i8 = -128; // Occupies 8 bits and its range is -128..=127
    let _x2: i16 = 32767; // Occupies 16 bits and its range is -32768..=32767
    let _x3: i32 = -2147483648; // Occupies 32 bits and its range is -2147483648..=2147483647
    let _x4: i64 = 9223372036854775807; // Occupies 64 bits and its range is -9223372036854775808..=9223372036854775807
    let _x5: i128 = -170141183460469231731687303715884105728; // Occupies 128 bits and its range is -170141183460469231731687303715884105728..=170141183460469231731687303715884105727

    // Unsigned numbers
    let _x6: u8 = 255; // Occupies 8 bits and its range is 0..=255
    let _x7: u16 = 65535; // Occupies 16 bits and its range is 0..=65535
    let _x8: u32 = 4294967295; // Occupies 32 bits and its range is 0..=4294967295
    let _x9: u64 = 18446744073709551615; // Occupies 64 bits and its range is 0..=18446744073709551615
    let _x10: u128 = 340282366920938463463374607431768211455; // Occupies 128 bits and its range is 0..=340282366920938463463374607431768211455

    // Macro to print to stdout
    println!("Print something");

    // Strings
    let mut _str: &str = "My string"; // Variables are immutable by default, setting mut makes them mutable
    println!("The size of '{}' is {}", _str, _str.chars().count()); // The number of characters in the string
    let mut n: u8 = 0;
    for i in _str.chars(){
        println!("Char number {}: {}", n, i);
        n += 1;
    }
    _str = "Changed string";

    // Fib case
    let n: u8 = 186;
    if n < 187 {
        println!("Fib of {} is {}", n, fib(n));
    } else {
        println!("You cannot enter numbers greater than 186, because there will be an overflow");
    }
}

// Fib linear implementation, only works with n in the range 0..=186
fn fib(n: u8) -> u128 {
    return if n > 1 {
        let mut i: u8 = 1;
        let mut n0: u128 = 0;
        let mut n1: u128 = 1;
        let mut aux: u128;
        while i < n {
            aux = n1;
            n1 = n1 + n0;
            n0 = aux;
            i += 1;
        }
        n1
    } else {
        n as u128
    }
}

Víctor Andrés Córdova Poma

student•

El ejercicio resuelto:

fn main() {
    let temperatures: [i8; 5] = [-5, 6, -110, 5, 110];    
    let min_temperature: i8 = get_min_value(temperatures);
    let max_temperature: i8 = get_max_value(temperatures);

    println!("the minimun temperature is: {min_temperature}");
    println!("the maximum temperature is: {max_temperature}");
}

fn get_min_value(values:[i8; 5]) -> i8{
    let mut prev:i8 = values[0];

    for value in values {
        if prev > value {
            prev = value;
        }
    }
    return prev;
}

fn get_max_value(values:[i8; 5]) -> i8{
    let mut prev:i8 = values[0];

    for value in values {
        if prev < value {
            prev = value;
        }
    }
    return prev;
}

Emmanuel Zuluaga

student•

en cuanto a la definición de que es una variable, creo que hace falta especificar un poco más para el entendimiento de manejo de memoria en rust. Una variable no es solo una "cajita", es una referencia a un valor en memoria. Entender esto, ayuda mejor a la comprensión de conceptos como borrowing en rust

ALEJANDRO RIAÑO VELASCO

student•

Hola, adjunto el pantallazo del resultado al problema de las temperaturas:

Enmanuel Antoni Bracho Villanueva

student•

Esta fue mi solución.

struct Temperatura {
    max: f32,
    min: f32,
}

fn main() {
    let temperatura = Temperatura {
        max: 32.0,
        min: 26.0,
    };

    println!(" <----- Temperatura promedio de Venezuela Estado Falcón ----->");
    println!(" * Temperatura máxima promedio: {} °C", temperatura.max);
    println!(" * Temperatura mínima promedio: {} °C", temperatura.min);
}

Rodrigo Ramos Xochiteotzin

student•

¿No sería más correcto decirles constantes en lugar de variables? Ya que son inmutables a menos que le indique lo contrario

Hecot Pulido

student•

No, las constantes son otra cosa diferente, el nombre es "variable inmutable"

fn fibonacci(n: u32) -> u32 {
    if n == 0 {
        return 0;
    } else if n == 1 {
        return 1;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

fn main() {
    println!("{}", fibonacci(10));
}

fn fib(n: u8) -> u128 {
    return if n > 1 {
        let mut i: u8 = 1;
        let mut n0: u128 = 0;
        let mut n1: u128 = 1;
        let mut aux: u128;
        while i < n {
            aux = n1;
            n1 = n1 + n0;
            n0 = aux;
            i += 1;
        }
        n1
    } else {
        n as u128
    }
}

// i8, i16 - enteros con signo
// u8, u16 - enteros sin signo (positivos)
// &str - string
fn main() {

    let temperatura_minima: i8 = -3;
    let temperatura_maxima: u8 = 32;
    let temperatura_promedio: f32 = (temperatura_minima + temperatura_maxima as i8) as f32/ 2.0;

    print!("La termeratura minima en mi ciudad es {temperatura_minima} y la maxima es {temperatura_maxima} y el promedio es {temperatura_promedio}");
}

fn main() {
    // Signed numbers
    let _x1: i8 = -128; // Occupies 8 bits and its range is -128..=127
    let _x2: i16 = 32767; // Occupies 16 bits and its range is -32768..=32767
    let _x3: i32 = -2147483648; // Occupies 32 bits and its range is -2147483648..=2147483647
    let _x4: i64 = 9223372036854775807; // Occupies 64 bits and its range is -9223372036854775808..=9223372036854775807
    let _x5: i128 = -170141183460469231731687303715884105728; // Occupies 128 bits and its range is -170141183460469231731687303715884105728..=170141183460469231731687303715884105727

    // Unsigned numbers
    let _x6: u8 = 255; // Occupies 8 bits and its range is 0..=255
    let _x7: u16 = 65535; // Occupies 16 bits and its range is 0..=65535
    let _x8: u32 = 4294967295; // Occupies 32 bits and its range is 0..=4294967295
    let _x9: u64 = 18446744073709551615; // Occupies 64 bits and its range is 0..=18446744073709551615
    let _x10: u128 = 340282366920938463463374607431768211455; // Occupies 128 bits and its range is 0..=340282366920938463463374607431768211455

    // Macro to print to stdout
    println!("Print something");

    // Strings
    let mut _str: &str = "My string"; // Variables are immutable by default, setting mut makes them mutable
    println!("The size of '{}' is {}", _str, _str.chars().count()); // The number of characters in the string
    let mut n: u8 = 0;
    for i in _str.chars(){
        println!("Char number {}: {}", n, i);
        n += 1;
    }
    _str = "Changed string";

    // Fib case
    let n: u8 = 186;
    if n < 187 {
        println!("Fib of {} is {}", n, fib(n));
    } else {
        println!("You cannot enter numbers greater than 186, because there will be an overflow");
    }
}

// Fib linear implementation, only works with n in the range 0..=186
fn fib(n: u8) -> u128 {
    return if n > 1 {
        let mut i: u8 = 1;
        let mut n0: u128 = 0;
        let mut n1: u128 = 1;
        let mut aux: u128;
        while i < n {
            aux = n1;
            n1 = n1 + n0;
            n0 = aux;
            i += 1;
        }
        n1
    } else {
        n as u128
    }
}

fn main() {
    let temperatures: [i8; 5] = [-5, 6, -110, 5, 110];    
    let min_temperature: i8 = get_min_value(temperatures);
    let max_temperature: i8 = get_max_value(temperatures);

    println!("the minimun temperature is: {min_temperature}");
    println!("the maximum temperature is: {max_temperature}");
}

fn get_min_value(values:[i8; 5]) -> i8{
    let mut prev:i8 = values[0];

    for value in values {
        if prev > value {
            prev = value;
        }
    }
    return prev;
}

fn get_max_value(values:[i8; 5]) -> i8{
    let mut prev:i8 = values[0];

    for value in values {
        if prev < value {
            prev = value;
        }
    }
    return prev;
}

struct Temperatura {
    max: f32,
    min: f32,
}

fn main() {
    let temperatura = Temperatura {
        max: 32.0,
        min: 26.0,
    };

    println!(" <----- Temperatura promedio de Venezuela Estado Falcón ----->");
    println!(" * Temperatura máxima promedio: {} °C", temperatura.max);
    println!(" * Temperatura mínima promedio: {} °C", temperatura.min);
}

Variables de Rust y cómo mostrarlas en pantalla

Inicia tu camino con Rust

Bienvenida al Curso Básico de Rust

Rust: un lenguaje amado por los desarrolladores

Instalando Rust en MacOS o Linux

Instalación de Rust en Windows y WSL

Domina las bases de Rust

Creando un nuevo proyecto en Rust