Literales y operadores

Literal: son datos constantes que se escriben directamente en el código y cuyo valor se ve a simple vista, es la forma básica de representar datos en un programa.

Su valor es fijo e inmutable, está escrito directamente en el código y no puede cambiar durante la ejecución. No requiere cálculos ni análisis de variables; literalmente significa «valor escrito tal cual».

Ejemplo: los números 13 y 3.14 que aparecen abajo son literales, en otros lenguajes también se les llama valores literales.

fn main() {
    println!("{}", 13);
    println!("{}", 3.14);
}Lenguaje del código: JavaScript (javascript)

Para facilitar el aprendizaje, el equipo oficial ofrece un editor de Rust online. No hace falta instalar un entorno local para practicar la sintaxis básica de Rust, haz clic en el enlace de abajo

Rust Playground

Los literales

Rust admite literales de estos tipos: entero, número de punto flotante, carácter, cadena de texto, booleano, tipo unidad (unit).

• Entero: 11
• Carácter: 'a' (comillas simples)
• Cadena: "abc" (comillas dobles)
• Booleano: true / false
• Tipo unidad: ()

Distintas bases para los enteros

Se distinguen las bases mediante un prefijo, solo válido para números enteros:

• Hexadecimal: empieza por 0x, ej: 0x1F
• Octal: empieza por 0o, ej: 0o77
• Binario: empieza por 0b, ej: 0b1010

Separador numérico

Dentro de los literales numéricos se puede insertar una barra baja _ para mejorar la legibilidad, no modifica el valor real del número:

• Entero: 1_000 = 1000
• Flotante: 0.000_001 = 0.000001

Notación científica

Los números de punto flotante admiten la notación científica con E, su tipo por defecto es f64:

• 1e6 = 1000000
• 7.6e-4 = 0.00076

Sufijos de tipo en literales (fundamental)

En Rust hay que especificar explícitamente el tipo de cada literal, estos son los sufijos más usados:

• u32: entero sin signo de 32 bits (solo valores positivos o cero)
• i32: entero con signo de 32 bits (admite positivos y negativos)

Aviso: no se pueden mezclar enteros con signo y sin signo en operaciones matemáticas, esto generará un error directamente.

Ejemplo:

fn main() {
    // 1. Literal entero simple
    println!("Entero: {}", 13);
    // Enteros binario, octal, hexadecimal
    println!("Binario: {}", 0b1010);
    println!("Octal: {}", 0o77);
    println!("Hexadecimal: {}", 0x2A);
    // Entero con separador (mejora la legibilidad)
    println!("Entero con guion bajo: {}", 1_000_000);
    // Entero con sufijo de tipo
    println!("Entero u32 sin signo: {}", 100u32);
    println!("Entero i32 con signo: {}", -50i32);

    // 2. Literal de punto flotante
    println!("Flotante: {}", 3.14);
    // Flotante con guion bajo
    println!("Flotante con guion bajo: {}", 0.000_001);
    // Flotante en notación científica
    println!("Notación científica: {}", 1e6);
    println!("Notación científica negativa: {}", 7.6e-4);

    // 3. Literal de cadena (comillas dobles)
    println!("Cadena: {}", "hello world");

    // 4. Literal de carácter (comillas simples, solo un solo carácter)
    println!("Carácter: {}", 'a');
    println!("Carácter chino: {}", '中');

    // 5. Literal booleano
    println!("Booleano true: {}", true);
    println!("Booleano false: {}", false);

    // 6. Literal unidad () (tipo unidad de Rust)
    println!("Tipo unidad: {:?}", ());
}Lenguaje del código: JavaScript (javascript)

Los operadores

Las reglas y prioridades de los operadores de Rust son casi iguales a los de los lenguajes tipo C.

1. Operadores aritméticos

Operaciones básicas como suma y resta, se usan junto con los sufijos de tipo de los enteros:

• Suma: +
• Resta: -

2. Operadores lógicos booleanos (cortocircuito)