El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Sintaxis y Estructura Básica

Siguiente ►
►

En esta sección, aprenderemos sobre la sintaxis y la estructura básica de un programa en Rust. Este conocimiento es fundamental para escribir y entender código en Rust. Cubriremos los siguientes temas:

  1. Estructura de un programa en Rust
  2. Comentarios
  3. Variables y constantes
  4. Tipos de datos básicos
  5. Operadores
  6. Control de flujo básico

  1. Estructura de un Programa en Rust

Un programa en Rust generalmente se compone de funciones, con la función main siendo el punto de entrada. Aquí hay un ejemplo básico:

fn main() {
    println!("Hola, Mundo!");
}

Explicación:

  • fn main() { ... }: Define la función principal del programa.
  • println!("Hola, Mundo!");: Imprime "Hola, Mundo!" en la consola. println! es una macro que se usa para imprimir texto.

  1. Comentarios

Los comentarios son esenciales para documentar el código. Rust soporta dos tipos de comentarios:

  • Comentarios de una sola línea:

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

  • Comentarios de múltiples líneas:

    /*
 Este es un comentario
 de múltiples líneas
*/

  1. Variables y Constantes

Variables

En Rust, las variables son inmutables por defecto. Para declarar una variable mutable, se usa la palabra clave mut.

fn main() {
    let x = 5; // Variable inmutable
    let mut y = 10; // Variable mutable
    y = 15; // Modificando la variable mutable
}

Constantes

Las constantes se declaran usando la palabra clave const y deben tener un tipo explícito.

const MAX_POINTS: u32 = 100_000;

Explicación:

  • let x = 5;: Declara una variable inmutable x con el valor 5.
  • let mut y = 10;: Declara una variable mutable y con el valor 10.
  • const MAX_POINTS: u32 = 100_000;: Declara una constante MAX_POINTS de tipo u32 con el valor 100000.

  1. Tipos de Datos Básicos

Rust es un lenguaje de tipado estático, lo que significa que el tipo de cada variable debe ser conocido en tiempo de compilación. Aquí hay algunos tipos de datos básicos:

  • Enteros: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128
  • Flotantes: f32, f64
  • Booleanos: bool
  • Caracteres: char

Ejemplo:

fn main() {
    let a: i32 = 10; // Entero de 32 bits
    let b: f64 = 3.14; // Flotante de 64 bits
    let c: bool = true; // Booleano
    let d: char = 'R'; // Carácter
}

  1. Operadores

Rust soporta los operadores aritméticos, de comparación y lógicos comunes.

Operadores Aritméticos

  • Suma: +
  • Resta: -
  • Multiplicación: *
  • División: /
  • Módulo: %

Ejemplo:

fn main() {
    let sum = 5 + 10; // 15
    let difference = 95.5 - 4.3; // 91.2
    let product = 4 * 30; // 120
    let quotient = 56.7 / 32.2; // 1.76
    let remainder = 43 % 5; // 3
}

Operadores de Comparación

  • Igual a: ==
  • No igual a: !=
  • Mayor que: >
  • Menor que: <
  • Mayor o igual que: >=
  • Menor o igual que: <=

Ejemplo:

fn main() {
    let is_equal = 5 == 5; // true
    let is_not_equal = 5 != 4; // true
    let is_greater = 5 > 4; // true
    let is_less = 4 < 5; // true
    let is_greater_or_equal = 5 >= 5; // true
    let is_less_or_equal = 4 <= 5; // true
}

Operadores Lógicos

  • Y lógico: &&
  • O lógico: ||
  • No lógico: !

Ejemplo:

fn main() {
    let and = true && false; // false
    let or = true || false; // true
    let not = !true; // false
}

  1. Control de Flujo Básico

Condicionales

Rust usa if para condicionales.

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("El número es divisible por 4");
    } else if number % 3 == 0 {
        println!("El número es divisible por 3");
    } else if number % 2 == 0 {
        println!("El número es divisible por 2");
    } else {
        println!("El número no es divisible por 4, 3 o 2");
    }
}

Bucles

Rust soporta varios tipos de bucles: loop, while, y for.

loop

fn main() {
    let mut counter = 0;

    loop {
        counter += 1;

        if counter == 10 {
            break;
        }
    }
    println!("Contador: {}", counter);
}

while

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    println!("¡Despegue!");
}

for

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("El valor es: {}", element);
    }
}

Ejercicio Práctico

Ejercicio 1

Escribe un programa en Rust que haga lo siguiente:

  1. Declare una variable mutable x con el valor 10.
  2. Use un bucle while para reducir el valor de x en 1 hasta que x sea 0.
  3. Imprima el valor de x en cada iteración del bucle.

Solución

fn main() {
    let mut x = 10;

    while x != 0 {
        println!("x: {}", x);
        x -= 1;
    }
    println!("¡x ha llegado a 0!");
}

Conclusión

En esta sección, hemos cubierto la sintaxis y la estructura básica de un programa en Rust. Ahora deberías tener una comprensión fundamental de cómo se estructuran los programas en Rust, cómo declarar variables y constantes, y cómo usar operadores y control de flujo básico. En el próximo módulo, profundizaremos en conceptos más avanzados como la propiedad y el préstamo.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados