Rust, un lenguaje de programación de código abierto desarrollado por Mozilla, está diseñado teniendo en cuenta la seguridad, la velocidad y la programación concurrente. Su sintaxis es diferente a la de los lenguajes de programación tradicionales, pero es intuitiva y fácil de aprender una vez que se comprenden los conceptos básicos. En este artículo, exploraremos los tipos de datos básicos, las variables y la mutabilidad, el flujo de control, las funciones y los comentarios de Rust.

Tipos de datos básicos

Rust es un lenguaje de tipo estático, lo que significa que el tipo de cada variable debe conocerse en tiempo de compilación. Rust proporciona varios tipos de datos básicos, que incluyen:

Enteros

Rust tiene dos categorías principales de números enteros: con y sin signo. Cada categoría puede tener 8, 16, 32, 64 o 128 bits de longitud. Además, Rust tiene tipos isize y usize, que dependen de la arquitectura de la máquina. Por ejemplo:

let x: u8 = 255; // unsigned 8-bit integer
let y: i64 = -5000; // signed 64-bit integer

Booleanos

En Rust, los valores booleanos se declaran mediante la palabra clave bool. Pueden ser true o false. Por ejemplo:

let is_true: bool = true;
let is_false: bool = false;

Cadenas de texto

En Rust hay dos tipos de cadenas de texto: String y &str. String es una estructura de datos ubicada en el heap que es mutable y puede crecer, mientras que &str es una cadena de texto inmutable de longitud fija almacenada en algún lugar de la memoria. Por ejemplo:

let mut s: String = "Hola".to_string(); // cadena mutable
let t: &str = "Mundo"; // fragmento de cadena inmutable

Variables y Mutabilidad

Por defecto, las variables en Rust son inmutables. Esto es una parte fundamental del enfoque de Rust hacia la seguridad y la concurrencia sencilla. Para declarar una variable mutable, es necesario utilizar la palabra clave mut. Por ejemplo:

let x = 5; // x es inmutable
let mut y = 6; // y es mutable
y = 7; // esto es válido
// x = 8; // esto causaría un error

Flujo de Control

Rust ofrece varias estructuras para el control del flujo, incluyendo if, loop, while y for.

If

La palabra clave if permite la ejecución condicional del código. Por ejemplo:

let numero = 6;
if numero % 2 == 0 {
    println!("El número es par.");
} else {
    println!("El número es impar.");
}

Loop

La palabra clave loop permite bucles infinitos. Puedes usar break para salir del bucle. Por ejemplo:

let mut contador = 0;
loop {
    contador += 1;
    if contador == 10 {
        break;
    }
}

While

La palabra clave while permite bucles que se ejecutan mientras una condición sea verdadera. Por ejemplo:

let mut numero = 5;
while numero != 0 {
    println!("{}", numero);
    numero -= 1;
}

For

La palabra clave for permite iterar sobre elementos de una colección, como arreglos y vectores. Por ejemplo:

let numeros = [1, 2, 3, 4, 5];
for numero in numeros.iter() {
    println!("{}", numero);
}

Funciones

Las funciones son los bloques de construcción de un programa en Rust. Agrupan el código que realiza una tarea específica, lo que mejora la reusabilidad y la legibilidad.

Definición de Funciones

En Rust, se declaran funciones con la palabra clave fn. Aquí tienes la sintaxis:

fn nombre_de_la_funcion(parametros) -> tipo_de_retorno {
    // Cuerpo de la función.
}

function_name es el nombre de la función, parameters son las entradas de la función, y return_type es el tipo del valor de salida.

Por ejemplo, la siguiente función add toma dos enteros i32 como parámetros y devuelve su suma, que también es un entero i32:

fn add(x: i32, y: i32) -> i32 {
    return x + y;
}

Invocación de Funciones

Puedes invocar una función utilizando su nombre seguido de un conjunto de paréntesis que encierran cualquier argumento. Así es como podemos llamar a la función add:

let suma = add(5, 6);
println!("La suma es: {}", suma); // La suma es: 11

Declaraciones y Expresiones en Funciones

En Rust, una función se compone de declaraciones y expresiones. Las declaraciones realizan alguna acción y no devuelven un valor, mientras que las expresiones evalúan a un valor. En los cuerpos de las funciones, la última expresión se devuelve implícitamente:

fn add(x: i32, y: i32) -> i32 {
    x + y // no es necesario el keyword `return`
}

Comentarios

Los comentarios son notas explicativas que añades a tu código para que los humanos puedan leerlo; son ignoradas por el compilador de Rust. Los comentarios son fundamentales para hacer que tu código sea comprensible para otros y para recordarte a ti mismo lo que hace tu código.

Comentarios de una sola línea

Los comentarios de una sola línea comienzan con //. Rust ignora todo lo que sigue a // en la misma línea:

// Este es un comentario de una sola línea.

Comentarios de múltiples líneas

Para comentarios que abarcan varias líneas, se utiliza /* para iniciar el comentario y */ para finalizarlo:

/* Este es un comentario de múltiples líneas.
   Se extiende a lo largo de varias líneas. */

Comentarios de documentación

Rust también admite un tipo especial de comentario para la documentación. Estos comienzan con /// para comentarios de línea o /** ... */ para comentarios de bloque. Cuando ejecutas el comando cargo doc, Rust genera documentación basada en estos comentarios:

/// Esta función suma dos enteros.
///
/// # Ejemplos
///
/// let suma = add(5, 7);
/// assert_eq!(suma, 12);
///
fn add(x: i32, y: i32) -> i32 {
    x + y
}

En esta introducción, hemos cubierto los conceptos básicos de funciones y comentarios en Rust. A medida que continúes tu viaje con Rust, encontrarás casos de uso de funciones más complejos como funciones con parámetros genéricos, funciones asociadas y expresiones de cierre. De manera similar, para los comentarios, aprenderás cómo escribir comentarios de documentación más efectivos utilizando la sintaxis de Markdown.

¡Gracias por leer este artículo!

Fué escrito por Aurora Poppyseed, y traducido al Español por Juan José Gouvêa.