Arrays

¿Qué es un array?

Imagina que tienes una lista de compras: huevos, leche, pan, mantequilla. Podrías crear una variable separada para cada cosa, pero eso se vuelve un desorden rápidamente. Un array es una sola variable que contiene una lista de valores en orden.

Piensa en un array como una fila de cajas numeradas. Cada caja tiene una posición (empezando desde 0) y contiene un valor.

Posición:  0       1      2     3
         [huevos] [leche] [pan] [mantequilla]

Crear arrays

En Nyx, creas un array con corchetes:

fn main() {
    let numeros: Array = [10, 20, 30, 40, 50]
    let nombres: Array = ["Alice", "Bob", "Charlie"]
    let vacio: Array = []

    print(numeros)
    print(nombres)
    print(vacio)
}

Los arrays pueden contener cualquier tipo de valor: enteros, strings, booleanos, o incluso otros arrays.

Acceder a elementos

Accedes a un elemento por su índice — su posición en el array. Los índices empiezan en 0, no en 1:

fn main() {
    let frutas: Array = ["manzana", "banana", "cereza", "dátil"]

    print(frutas[0])    // manzana (primer elemento)
    print(frutas[1])    // banana (segundo elemento)
    print(frutas[3])    // dátil (cuarto elemento)
}

¿Por qué empezar en 0? Es una convención en la mayoría de los lenguajes de programación. El primer elemento está en la posición 0, el segundo en la posición 1, y así sucesivamente.

Modificar elementos

Si declaras un array con var, puedes cambiar sus elementos:

fn main() {
    var notas: Array = [85, 90, 78]

    print(notas[1])    // 90
    notas[1] = 95
    print(notas[1])    // 95
}

Longitud del array

El método .length() te dice cuántos elementos tiene un array:

fn main() {
    let colores: Array = ["rojo", "verde", "azul"]
    print(colores.length())    // 3

    let vacio: Array = []
    print(vacio.length())     // 0
}

Agregar elementos

El método .push() agrega un elemento al final del array:

fn main() {
    var lista: Array = [1, 2, 3]
    print(lista.length())    // 3

    lista.push(4)
    lista.push(5)
    print(lista.length())    // 5
    print(lista[4])          // 5
}

Quitar el último elemento

El método .pop() quita y devuelve el último elemento:

fn main() {
    var pila: Array = [10, 20, 30]

    let ultimo: int = pila.pop()
    print(ultimo)               // 30
    print(pila.length())        // 2
}

Insertar y quitar en cualquier posición

El método .insert(índice, valor) agrega un elemento en una posición específica, desplazando los elementos hacia la derecha. El método .remove(índice) quita y devuelve el elemento en una posición específica, desplazando los elementos hacia la izquierda:

fn main() {
    var nums: Array = [10, 30, 40]

    nums.insert(1, 20)         // insertar 20 en índice 1
    print(nums)                // [10, 20, 30, 40]

    let quitado: int = nums.remove(2)   // quitar elemento en índice 2
    print(quitado)             // 30
    print(nums)                // [10, 20, 40]
}

Estos métodos son más flexibles que push/pop, que solo funcionan al final. Úsalos cuando necesites agregar o quitar elementos en el medio de un array.

Recorrer arrays

Lo más común que se hace con un array es recorrer cada elemento. Usa un bucle while con un índice:

fn main() {
    let nombres: Array = ["Alice", "Bob", "Charlie", "Diana"]

    var i: int = 0
    while i < nombres.length() {
        print(nombres[i])
        i += 1
    }
}

Salida:

Alice
Bob
Charlie
Diana

Ejemplo práctico: encontrar el máximo

Escribamos una función que encuentra el número más grande en un array:

fn encontrar_max(arr: Array) -> int {
    var max_val: int = arr[0]
    var i: int = 1
    while i < arr.length() {
        if arr[i] > max_val {
            max_val = arr[i]
        }
        i += 1
    }
    return max_val
}

fn main() {
    let notas: Array = [72, 95, 88, 61, 100, 84]
    print(encontrar_max(notas))    // 100
}

Ejemplo práctico: suma de todos los elementos

fn suma(arr: Array) -> int {
    var total: int = 0
    var i: int = 0
    while i < arr.length() {
        total += arr[i]
        i += 1
    }
    return total
}

fn main() {
    let numeros: Array = [10, 20, 30, 40]
    print(suma(numeros))    // 100
}

Ejemplo práctico: contar ocurrencias

fn contar_valor(arr: Array, objetivo: int) -> int {
    var cuenta: int = 0
    var i: int = 0
    while i < arr.length() {
        if arr[i] == objetivo {
            cuenta += 1
        }
        i += 1
    }
    return cuenta
}

fn main() {
    let datos: Array = [1, 3, 5, 3, 7, 3, 9]
    print(contar_valor(datos, 3))    // 3
    print(contar_valor(datos, 7))    // 1
    print(contar_valor(datos, 2))    // 0
}

Ejercicios

Escribe una función encontrar_min(arr: Array) -> int que devuelva el elemento más pequeño.

Escribe una función promedio(arr: Array) -> int que devuelva el promedio entero de todos los elementos.

Escribe una función invertir_array(arr: Array) -> Array que devuelva un nuevo array con los elementos en orden inverso. Pista: crea un array vacío, recorre desde el último elemento al primero, y haz push de cada uno.

Escribe un programa que cree un array con los primeros 20 números pares (2, 4, 6, ..., 40) usando un bucle con .push(), y después los imprima todos.

Escribe una función contiene(arr: Array, objetivo: int) -> bool que devuelva true si el array contiene el valor objetivo.

Resumen

Los arrays contienen listas ordenadas de valores: let a: Array = [1, 2, 3]
Accede a elementos por índice (empezando en 0): a[0]
.length() devuelve la cantidad de elementos.
.push(val) agrega al final. .pop() quita del final.
Recorre arrays con while i < arr.length().
Los arrays son una de las estructuras de datos más fundamentales en programación.

Siguiente capítulo: Strings →

← Anterior: Funciones Siguiente: Strings →