En Rust al igual que casi todos los lenguajes de programación tenemos métodos de imprimir por pantalla valores utilizando la biblioteca estándar.

Usaremos la consola para este fin utilizando println! (« print – imprime por la pantalla de la consola y ln una lineal por comando» )

El println!() es una llamada a una macro, si fuese una función seria así println() al usar! la definimos como una macro.

Una macro en Rust es diferente que en C no te confundas en su uso, para llamar una macro usamos el signo! para poder diferenciarla de una función.

println! (» Hola mundo»);// Imprime por pantalla Hola mundo con ln la próxima seria en la siguiente línea

print!(«Hola de nuevo»);// Esto sería a continuación en la misma línea

Tipos de datos básicos.

Todos los lenguajes de programación utilizan las variables para almacenar datos y manipularlos.

Como declarar Variables en Rust:

las variables en Rust son inmutables (no se pueden cambiar los valores por defecto).

Puedes declarar variables mutables introduciendo la palabra mut antes del nombre de la variable.

// Variable normal

let variable_normal = 40;

___________________________________

// Variable mutable

let mut variable_mutable = 45;

Hay varios tipos de datos básicos que utilizamos para almacenar datos en las variables.

Tenemos para guardar varias longitudes de tamaño:

Los tipos son enteros, flotantes, caracteres, boléanos, tuplas, cadenas, arrays

Boléanos

Representan valores true ( verdaderos ) y false ( falso )

Ejemplos de código:

let a = true;

let b: bool = false;

Enteros

Los enteros son valores sin decimal

Ejemplo de código fuente:

let variable_entero: i64 = 50; // Entero de 64 bits

Tuplas

Se usan (). Pueden almacenar varios valores ( elementos ) en un solo valor, se indexan con números dede el 0 en adelante para acceder a ellos.

Ejemplos

let mi_tupla:(i32)=(11,21,12,’ a’);

Cadenas

Se pueden representar con str o String

let texto: &str = » Hola mundo «;// es una referencia inmutable

let mut texto: String = String::from(«Hello «);// es una referencia mutable

Arrays

Los Arrays son colecciones de elementos del mismo tipo con una longitud fija.

Algunos tipos básicos que ofrece Rust, como los anteriores , tienen sus propias características

y usos. En el momento que te familiarices mas con Rust, lograrás aprovechar mejor el máximo

de su sistema y características.

let arrays: [i32; 400] = [0; 400];// son como las tuplas pero con corchetes [ ]

Se utiliza la biblioteca estándar ( std::io ).

Proporciona las funciones necesarias para poder interactuar con el usuario.

std::io:stdin()

Permite la lectura de datos por el teclado, con el método read_line se captura una entrada y se almacena en una variable siempre que sea mutable.

Ejemplo de código fuente

use std::io;

fn main()

{

let mut nombre = String::new();// Esta line crea una variable string nueva vacía(( String::new )) en nombre

println!(» Escribe tu nombre «);

io::stdin().read_line(& mut nombre);// Lee los caracteres de la variable nombre

println!(» Tu nombre es {}», nombre);// Imprime el valor de la variable nombre en la pantalla

}

Cuando el usuario introduce datos lo hace en string (cadena) que para hacer operaciones numéricas seria imposible.

Para eso tenemos que convertir el string en numérico, utilizamos los métodos de conversión del Rust.

Estas estructuras son importantes para tomar decisiones para el control del flujo de ejecución del programa, el camino a seguir según la evaluación del condicional.

El condicional » if » se ejecuta si la condición booleana se ejecuta como » true » (verdadero), el bloque de código entre las llaves se ejecutará o si no se ignorara.

Ejemplo de código fuente:

fn main()

{
let variable = 20;

 if variable == 20 // Aquí está la condición 

 {
     println!("La variable tiene un valor de 20.");//  Si se cumple se ejecuta esta linea
 }

}

Una idea sería como el lenguaje C++ la similitud es muy parecida

Si la condición booleana es False ( falso ) pasaría al bloque del else.

Antes no se cumplió el if

Podemos anidar varios » if » – » else «,

para marcar el camino a seguir según sea necesario en el programa.

loop, ejecuta un bucle infinito hasta que se encuentre una instrucción break

loop {

println (» la cuenta es {} «,contador);// Imprime el valor de la variable

cuenta +=1;// Incrementa 1 la variable cuenta

if cuenta >= 10 { break; }// Este condicional hace terminar el bucle al llegar la cuenta a10

}

While, ejecuta un bloque de código repetidamente, hasta que la expresión booleana sea true (Verdadera).

En el momento que sea false, saldrá del código que se encuentre entre las llaves { código true }

Visita en C++.

Ejemplo de código fuente:

EL lenguaje de programación Rust, poderoso, seguro y moderno.

Visita Wikipedia para una definición mas explicita.

Se caracteriza en su sistema de tipos y va mas allá de lo que ofrecen otros lenguajes.

Esta diseñado para evitar uno de los errores de memoria como desbordamientos y las referencias nulas .

Android 13, aproximadamente el 21% de todo el código nativo nuevo, está en Rust. Hay aproximadamente 1,5 millones de líneas totales de código Rust en nuevas funciones y componentes.

Hasta el momento no se detecta vulnerabilidades de seguridad de memoria en el código Rust de Android.

Para instalar en el ordenador,🖥 tenemos que seguir este enlace

rustup.rs – The Rust toolchain installer

y seguir sus indicaciones.

El entorno de trabajo mejor seria el VS Code y Visual Studio de Microsoft desde este enlace: https://visualstudio.microsoft.com/es/

Un ejemplo del típico, hola mundo, en la consola de comandos:

https://danielcaraballo.es/Rust/HolaMundo.rs Para descargar.

En este ejemplo, tenemos la función main, que se define con fn, que es quien define el inicio del programa

fn main(){ aquí se encuentra el cuerpo del programa }

que es println! con el signo de exclamación al final imprime por pantalla lo que se encuentra entre los paréntesis, el texto dentro de las comillas.

No olvidar terminar la linea con el ;

println («texto a mostrar»); // Esto es para tus diálogos

Ejemplo de código fuente para unos diálogos:

El modo de escribir diálogos es como en C++.