Índice

Variables y tipos

¿Qué es una variable?

Imagina una caja con una etiqueta. Puedes poner algo dentro de la caja, y después puedes leer la etiqueta para encontrar lo que hay dentro. Eso es una variable.

Una variable tiene tres partes:

Crear variables

En Nyx, hay dos formas de crear una variable:

let — Un valor que no cambia

fn main() {
    let nombre: String = "Alicia"
    let edad: int = 25
    let pi: float = 3.14159
    let activo: bool = true

    print(nombre)
    print(edad)
}

let crea una variable inmutable — una vez que asignas un valor, no puedes cambiarlo. Esta es la opción por defecto y la más segura. La mayoría de tus variables deberían usar let.

var — Un valor que puede cambiar

fn main() {
    var puntuacion: int = 0
    print(puntuacion)    // 0

    puntuacion = 10
    print(puntuacion)    // 10

    puntuacion = puntuacion + 5
    print(puntuacion)    // 15
}

var crea una variable mutable — puedes cambiar su valor tantas veces como quieras.

¿Por qué tener ambos?

Si usas let e intentas cambiar el valor accidentalmente, el compilador te avisará. Esto detecta errores temprano. Usa var solo cuando genuinamente necesites que el valor cambie.

fn main() {
    let nombre: String = "Alicia"
    nombre = "Roberto"    // ERROR: no se puede asignar a variable inmutable
}

Los cuatro tipos básicos

Nyx tiene cuatro tipos fundamentales de datos:

int — Números enteros

fn main() {
    let contador: int = 42
    let negativo: int = -7
    let cero: int = 0
    let grande: int = 1000000

    print(contador)     // 42
    print(negativo)     // -7
}

Los enteros son números sin punto decimal. Pueden ser positivos, negativos o cero. Úsalos para contar, indexar, y cualquier cosa que no necesite fracciones.

float — Números decimales

fn main() {
    let temperatura: float = 36.6
    let precio: float = 9.99
    let proporcion: float = 0.5

    print(temperatura)    // 36.6
}

Los floats son números con punto decimal. Úsalos para medidas, precios, porcentajes y cálculos científicos.

String — Texto

fn main() {
    let saludo: String = "Hola"
    let vacio: String = ""
    let frase: String = "Nyx es un lenguaje compilado."

    print(saludo)     // Hola
    print(frase)      // Nyx es un lenguaje compilado.
}

Los strings son secuencias de caracteres — texto. Siempre van entre comillas dobles "...". Nota que String empieza con mayúscula — esta es una convención en Nyx para tipos complejos.

bool — Verdadero o falso

fn main() {
    let esta_activo: bool = true
    let esta_borrado: bool = false

    print(esta_activo)     // true
    print(esta_borrado)    // false
}

Los booleanos solo tienen dos valores posibles: true o false. Se usan para condiciones y decisiones (aprenderás más sobre esto en el Capítulo 4).

Inferencia de tipos

En muchos casos, Nyx puede determinar el tipo automáticamente:

fn main() {
    let nombre = "Alicia"    // Nyx sabe que es String
    let edad = 25            // Nyx sabe que es int
    let pi = 3.14            // Nyx sabe que es float
    let activo = true        // Nyx sabe que es bool

    print(nombre)
    print(edad)
}

Cuando escribes let nombre = "Alicia", Nyx ve las comillas dobles y sabe que el valor es un String. No necesitas escribir : String explícitamente — pero puedes hacerlo si quieres ser claro sobre tus intenciones.

En este libro, escribiremos los tipos explícitamente en la mayoría de los ejemplos para que puedas ver exactamente qué tipo tiene cada variable. En la práctica, los programadores experimentados frecuentemente dejan que el compilador infiera los tipos.

Reglas para nombres

Los nombres de variables en Nyx deben seguir estas reglas:

fn main() {
    let nombre_usuario: String = "Alicia"    // correcto
    let edad2: int = 25                      // correcto
    let _temp: int = 100                     // correcto

    // let 2rapido: int = 0       // ERROR: empieza con número
    // let let: int = 0           // ERROR: palabra reservada
    // let mi-nombre: String = "" // ERROR: guiones no permitidos
}

Convención: Nyx usa snake_case para variables y funciones (palabras separadas por guiones bajos, todo en minúsculas). Structs y tipos usan PascalCase (cada palabra en mayúscula, sin separadores).

let nombre_usuario: String = "Alicia"    // snake_case para variables
let max_reintentos: int = 3              // snake_case para variables

struct PerfilUsuario {                    // PascalCase para tipos
    nombre: String,
    edad: int
}

Convertir entre tipos

A veces necesitas convertir un valor de un tipo a otro:

fn main() {
    // int a String
    let edad: int = 25
    let edad_texto: String = int_to_string(edad)
    print("Edad: " + edad_texto)    // Edad: 25

    // String a int
    let entrada: String = "42"
    let numero: int = string_to_int(entrada)
    print(numero + 8)               // 50
}

No puedes mezclar tipos directamente:

fn main() {
    let edad: int = 25
    print("Tengo " + edad)    // ERROR: no se puede sumar String con int
}

En su lugar, convierte el int a String primero:

fn main() {
    let edad: int = 25
    print("Tengo " + int_to_string(edad))    // Tengo 25
}

Ejercicios

  1. Crea variables para tu nombre, tu edad y tu número favorito. Imprime los tres.
  1. Crea una variable mutable contador que empiece en 0. Increméntala tres veces (suma 1 cada vez) e imprime el resultado después de cada incremento.
  1. Intenta crear una variable let y cambiarla. Lee el mensaje de error que te da el compilador.
  1. ¿Qué tipo usarías para cada uno de estos?

Resumen

Siguiente capítulo: Operaciones y expresiones →

← Anterior: ¿Qué es programar? Siguiente: Operaciones y expresiones →