Cómo trabajar con arrays en Ruby

Introducción

Un array es una estructura de datos que representa una lista de valores, llamados elementos. Los arrays te permiten almacenar múltiples valores en una sola variable. En Ruby, los arrays pueden contener cualquier tipo de datos, incluyendo números, cadenas y otros objetos de Ruby. Esto puede condensar y organizar tu código, haciéndolo más legible y mantenible. Todos los arrays son objetos con sus propios métodos que puedes llamar, proporcionando una forma estandarizada de trabajar con conjuntos de datos.

En este tutorial, crearás arrays, accederás a los valores que contienen, agregarás, modificarás y eliminarás elementos en un array, e iterarás a través de los elementos en un array para resolver problemas más complejos.

Creación de un Array

Comenzarás viendo cómo crear arrays en más detalle. Como ejemplo, aquí tienes una lista de varias especies de tiburones. Sin un array, podrías almacenarlos en variables individuales:

shark1 = "Hammerhead"
shark2 = "Great White"
shark3 = "Tiger"

Este enfoque es verboso y puede volverse rápidamente difícil de mantener, ya que no es muy flexible. Agregar otro tiburón significa que tendrías que agregar y hacer un seguimiento de una variable adicional.

Si usas un array, puedes simplificar estos datos. Para crear un array en un programa de Ruby, utiliza corchetes cuadrados: ([]), y separa los valores que deseas almacenar con comas:

sharks = ["Hammerhead", "Great White", "Tiger"]

En lugar de crear tres variables separadas, ahora tienes una variable que contiene a los tres tiburones. En este ejemplo, se usaron corchetes cuadrados — [] — para crear una matriz, y se separó cada entrada con una coma. Si tuvieras que agregar otro tiburón, añadirías otro tiburón a la matriz en lugar de crear y gestionar una nueva variable.

Puedes imprimir toda una matriz con la instrucción print, que mostrará el contenido de la matriz:

print sharks

Output
["Hammerhead", "Great White", "Tiger"]

Si deseas crear una matriz donde cada entrada sea una sola palabra, puedes usar la sintaxis %w{}, que crea una matriz de palabras:

days = %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday}

Esto es equivalente a crear la matriz con corchetes cuadrados:

days =  ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

Sin embargo, nota que el método %w{} te permite omitir las comillas y las comas.

Las matrices a menudo se utilizan para agrupar listas de tipos de datos similares, pero en Ruby, las matrices pueden contener cualquier valor o una combinación de valores. Esto incluye otras matrices. Aquí tienes un ejemplo de una matriz que contiene una cadena, un valor nil, un entero y una matriz de cadenas:

record = [
    "Sammy",
    null,
    7,
    [
        "another",
        "array",
    ]
]

Ahora verás cómo acceder a los datos almacenados en las matrices.

Acceso a Elementos en Matrices

Para acceder a un elemento específico, o elemento de un array, haces referencia a su índice, o su posición en el array. En Ruby, los índices comienzan en cero. Para recuperar el primer elemento de tu array sharks, añades el índice del elemento a la variable usando corchetes cuadrados:

sharks = ["Hammerhead", "Great White", "Tiger"]

El array sharks tiene tres elementos. Aquí tienes un desglose de cómo se indexa cada elemento en el array sharks.

El primer elemento en el array es Hammerhead, que está indexado en 0. El último elemento es Tiger, que está indexado en 2. El conteo comienza con 0 en los índices, lo que va en contra de la intuición natural de comenzar a contar en 1, así que querrás tener esto en cuenta hasta que se vuelva natural.

Puedes averiguar cuántos elementos hay en un array con el método length:

sharks.length

Output
3

Aunque los índices de sharks comienzan en 0 y van hasta 2, la propiedad length devuelve el número de elementos en el array, que es 3. No le importan los índices en absoluto.

Si quisieras averiguar el número de índice de un elemento específico en un array, como Tiger, usa el método index():

print sharks.index("Tiger")

Output
2

Esto devuelve el índice del primer elemento que contiene ese texto. Si no se encuentra un número de índice, como para un valor que no existe, la consola devolverá nil:

print sharks.index("Whale")

Output
nil

Para obtener el último elemento de una matriz en Ruby, usa el índice -1:

print sharks[-1]

Output
"Tiger"

Ruby también proporciona los métodos first y last para obtener los primeros y últimos elementos sin usar índices:

puts sharks.first
puts sharks.last

Output
"Hammerhead"
"Tiger"

Intentar acceder a un índice que no existe devolverá nil:

sharks[10]

Output
nil

Las matrices pueden contener otras matrices, que se llaman matrices anidadas. Esta es una forma de modelar conjuntos de datos bidimensionales en un programa. Aquí tienes un ejemplo de una matriz anidada:

nested_array = [
    [
        "salmon",
        "halibut",
    ],
    [
        "coral",
        "reef",
    ]
]

Para acceder a elementos en una matriz anidada, agregarías otro número de índice para corresponder a la matriz interna. Por ejemplo, para recuperar el valor coral de esta matriz anidada, usarías la siguiente declaración:

print nested_array[1][0];

Output
coral

En este ejemplo, accediste a la matriz en la posición 1 de la variable nested_array, que devolvió la matriz ["coral", "reef"]. Luego accediste a los elementos en la posición 0 de esa matriz, que era "coral".

Ahora verás cómo agregar elementos a una matriz.

Agregando Elementos a las Matrices

Tienes tres elementos en tu matriz sharks, que están indexados desde 0 hasta 2:

sharks = ["Hammerhead", "Great White", "Tiger"]

Hay algunas formas de agregar un nuevo elemento. Podrías asignar un valor al siguiente índice, que en este caso sería 3:

sharks[3] = "Whale";

print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale"]

Este método es propenso a errores, sin embargo. Si agregas un elemento y accidentalmente omites un índice, creará un elemento nil en el array.

sharks[5] = "Sand";

print sharks;

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Sand"]

Intentar acceder al elemento adicional del array devolverá su valor, que será nil:

sharks[4]

Output
nil

Encontrar el próximo índice disponible en un array es propenso a errores y lleva tiempo extra. Evita errores usando el método push, que agrega un elemento al final de un array:

sharks.push("Thresher")
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher"]

También puedes usar la sintaxis << en lugar del método push para agregar un elemento al final de un array:

sharks << "Bullhead"

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Para agregar un elemento al principio de un array, utiliza el método unshift():

sharks.unshift("Angel")
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Ahora que sabes cómo agregar elementos, veremos cómo quitarlos.

Eliminar Elementos de los Arrays

Para eliminar un elemento específico de un array, utiliza los métodos delete o delete_at. En el array sharks, creaste un elemento de array nil anteriormente. Ahora, te desharás de él.

Primero, encuentra su posición en el array. Puedes usar el método index para eso:

print sharks.index(nil)

Output
4

Luego usa delete_at para eliminar el elemento en el índice 4 e imprimir el array:

sharks.delete_at(4)
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", "Thresher", "Bullhead"]

El método delete elimina elementos de una matriz que coinciden con el valor que pasas. Úsalo para eliminar Ballena de la matriz:

sharks.delete("Whale")
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher", "Bullhead"]

El método delete eliminará todos las ocurrencias del valor que pasas, así que si tu matriz tiene elementos duplicados, todos serán eliminados.

El método pop eliminará el último elemento en una matriz:

sharks.pop
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher"]

Cabezón ha sido eliminado como el último elemento de la matriz. Para eliminar el primer elemento de la matriz, usa el método shift:

sharks.shift
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Thresher"]

Esta vez, Ángel fue eliminado del principio de la matriz.

Al usar pop y shift, puedes eliminar elementos desde el principio y el final de las matrices. Usar pop es preferible siempre que sea posible, ya que el resto de los elementos en la matriz conservan sus números de índice originales.

Los métodos delete_at, pop y shift cambian la matriz original y devuelven el elemento que eliminaste::

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
deleted_at_element = sharks.delete_at(1)
popped_element = sharks.pop

puts "Deleted_at element: #{deleted_at_element}"
puts "Popped element: #{popped_element}"

puts "Remaining array: #{sharks}"

Output
Deleted_at element: Great White
Popped element: Whale
Remaining array: ["Hammerhead", "Tiger"]

Ahora conoces varias formas de eliminar elementos de una matriz. Ahora verás cómo modificar el elemento que ya tienes.

Modificación de Elementos Existentes en Matrices

Para actualizar un elemento en la matriz, asigna un nuevo valor al índice del elemento usando el operador de asignación, como lo harías con una variable regular.

Dado un nuevo conjunto de tiburones, con "Hammerhead" en el índice 0, reemplazarás "Hammerhead" con "Ángel":

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks[0] = "Angel"
print sharks;

Output
["Angel", "Great White", "Tiger", "Whale"]

Para asegurarte de actualizar el elemento correcto, podrías usar el método index para localizar primero el elemento, tal como hiciste para encontrar el elemento que querías eliminar.

Ahora verás cómo trabajar con todos los elementos en el conjunto.

Iterando sobre Conjuntos

Ruby proporciona muchas formas de iterar sobre un conjunto, y el método que uses depende del tipo de trabajo que quieras realizar. A continuación, explorarás cómo iterar sobre un conjunto y mostrar cada uno de sus elementos.

Ruby proporciona la sintaxis for..in:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
for shark in sharks do
  puts shark
end

Para cada elemento en el conjunto sharks, Ruby asigna ese elemento a la variable local shark. Luego puedes imprimir el valor del elemento usando puts.

No verás for..in muy a menudo. Los conjuntos de Ruby son objetos, y proporcionan el método each para trabajar con elementos. El método each funciona de manera similar a for..in, pero tiene una sintaxis diferente:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each do |shark|
  puts shark
end

El método each utiliza una sintaxis que verás a menudo en la programación Ruby. Toma un bloque de Ruby como argumento. Un bloque es algún código que se ejecutará más tarde en el contexto del método. En este caso, el código es puts shark. La palabra clave shark, encerrada entre los caracteres de tubería (|), es la variable local que representa el elemento en el array al que accederá el bloque. Ruby asigna el elemento a esta variable y ejecuta el código en el bloque. El método each repite este proceso para cada elemento en el array:

Output
Hammerhead
Great White
Tiger
Whale

Cuando el bloque es solo una línea, a menudo verás a los desarrolladores de Ruby reemplazar las palabras clave do y end con llaves y condensar toda la declaración en una sola línea:

...
sharks.each {|shark| puts shark }

Esto produce los mismos resultados pero usa menos líneas de código.

El método each_with_index funciona de manera similar, pero también te da acceso al índice del elemento del array. Este programa utiliza each_with_index para imprimir el índice y el valor de cada elemento:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each_with_index do |shark, index|
  puts "The index is #{index}"
  puts "The value is #{shark}"
end

Para cada elemento en el array, Ruby asigna el elemento a la variable shark y asigna el índice actual a la variable index. Luego puedes hacer referencia a ambas variables en el bloque.

Output
The index is 0
The value is Hammerhead
The index is 1
The value is Great White
The index is 2
The value is Tiger
The index is 3
The value is Whale

Iterarás sobre los elementos en un array a menudo en tus propios programas, como cuando necesitas mostrar los elementos de una base de datos en un sitio web o cuando estás leyendo líneas de un archivo y procesando su contenido.

Conclusión

Los arrays son una parte extremadamente versátil y fundamental de la programación en Ruby. En este tutorial, creaste arrays y accediste a elementos individuales. También agregaste, eliminaste y modificaste elementos en un array. Finalmente, exploraste dos formas de iterar sobre un array y mostrar su contenido, lo cual se utiliza como un método común para mostrar datos.

Aprende sobre otros tipos de datos en Ruby leyendo el tutorial Comprendiendo los Tipos de Datos en Ruby.