Nivel inicial8 min de lectura · Publicado el

Arrays en Ruby: crear, leer, añadir y borrar

Arrays en Ruby: una huevera con papas, manises y mojo en los huecos 0, 1 y 2, que contando desde el final son -3, -2 y -1. Un array empieza en el 0rubentejera.com "papas"0-3"manises"1-2"mojo"2-1<< "mojo"array[-1] → "mojo"
La huevera es el array: cada hueco tiene su número, empezando por el 0, y desde el final se cuenta con -1, -2… El mojo entra el último con <<, así que array[-1] es "mojo".

Un array en Ruby es una lista ordenada de elementos. Piensa en una bandeja de huevos numerada: cada hueco tiene su número, empezando por el 0, y puedes meter, sacar o mirar lo que hay en cualquier hueco.

Crear arrays

vacio       = []                        # []
otro_vacio  = Array.new                 # []

array  = ["papas", "manises"]           # ["papas", "manises"]
array2 = %w[papas manises]              # ["papas", "manises"]: atajo para palabras sueltas
cervezas = Array.new(3, "cerveza")      # ["cerveza", "cerveza", "cerveza"]
decenas  = Array.new(3) { |i| i * 10 }  # [0, 10, 20]

%w[...] crea un array de cadenas separando por espacios; da igual usar corchetes o paréntesis (%w(...)).

Leer elementos

Cada posición tiene dos números: el positivo, que cuenta desde el principio (0, 1, 2…), y el negativo, que cuenta desde el final (-1 es el último).

Código Resultado con ["papas", "manises"] Qué hace
array[0] "papas" Elemento en la posición 0
array[-1] "manises" Último elemento
array.at(0) "papas" Igual que array[0]
array.first / array.last "papas" / "manises" Primero y último
array[345] nil Si la posición no existe, devuelve nil
array.fetch(345, "por defecto") "por defecto" Valor por defecto si no existe
array.fetch(345) IndexError Sin valor por defecto, avisa con un error

Trozos de un array

Con un solo número, array[0], recibes el elemento. Con dos números o con un rango, pides un trozo, y las dos formas devuelven un array, aunque sea de un solo elemento:

array[0, 1]     # ["papas"]               desde la posición 0, coge 1 elemento
array[0..1]     # ["papas", "manises"]    de la posición 0 a la 1, ambas incluidas
array[1..-1]    # ["manises"]             de la 1 hasta el final
array[1..]      # ["manises"]             lo mismo, más corto

Con un array más largo se ve mejor:

a = %w[ant bat cat dog elk fly gnu]
a[2]        # "cat"
a[-3]       # "elk"
a[1..3]     # ["bat", "cat", "dog"]
a[-3..-1]   # ["elk", "fly", "gnu"]
a[4..-2]    # ["elk", "fly"]

Añadir elementos

array = ["papas", "manises"]
array << "mojo"                       # ["papas", "manises", "mojo"]
array.push("gofio")                   # ["papas", "manises", "mojo", "gofio"]
array.unshift("queso")                # ["queso", "papas", "manises", "mojo", "gofio"]
array += ["membrillo", "bizcocho"]    # añade los dos al final

<<, push y unshift modifican el array. += crea un array nuevo y lo vuelve a guardar en la variable.

Eliminar elementos

Hay métodos que cambian el array original (destructivos) y otros que te devuelven uno nuevo sin tocarlo.

Partimos de ["queso", "papas", "manises", "mojo", "gofio", "membrillo", "bizcocho"], el array del bloque anterior:

# Destructivos: cambian el array
primera = array.shift      # "queso"     (quita el primero)
ultima  = array.pop        # "bizcocho"  (quita el último)
# array = ["papas", "manises", "mojo", "gofio", "membrillo"]

# No destructivos: el array no cambia
array.drop(1)              # ["manises", "mojo", "gofio", "membrillo"]  (todos menos el primero)
array.slice(1, 3)          # ["manises", "mojo", "gofio"]

# Destructivos, por posición o por valor
array.delete_at(0)         # "papas"
array.delete("mojo")       # "mojo"
array.delete("nada")       # nil: no estaba
# array = ["manises", "gofio", "membrillo"]

Cambian el array

  • shift, pop
  • delete, delete_at
  • <<, push, unshift

Devuelven uno nuevo

  • drop, slice, []
  • +
  • map, select, reject

Muchos métodos tienen las dos versiones, y la destructiva acaba en !: select devuelve un array nuevo y select! cambia el original; lo mismo con reject!, map!, sort! o uniq!.

Ojo con un detalle: uniq!, select! y reject! devuelven nil si no han cambiado nada. [1, 2].uniq! da nil, porque no había repetidos, así que encadenar array.uniq!.join falla con undefined method 'join' for nil (NoMethodError). Si quieres encadenar, usa la versión sin !.

Arrays constantes con freeze

Si un array no debe cambiar nunca, congélalo:

NOMBRES = %w[Pepe Juan Antonio Luis].freeze
NOMBRES << "Ana"
frozen.rb:2:in '<main>': can't modify frozen Array: ["Pepe", "Juan", "Antonio", "Luis"] (FrozenError)

freeze congela la bandeja, no los huevos: no puedes añadir ni quitar elementos, pero los textos de dentro siguen pudiendo cambiar si no están congelados ellos también. Y NOMBRES + ["Ana"] sí funciona, porque crea un array nuevo, sin congelar.

Recorrer y buscar

numeros = [0, 1, 2, 3]

numeros.each { |n| puts n }              # 0 1 2 3, uno por línea
numeros.find { |n| n * n > 4 }           # 3: el primero que cumple
numeros.select(&:even?)                  # [0, 2]: todos los que cumplen
numeros.map { |n| n * 2 }                # [0, 2, 4, 6]
numeros.sum                              # 6

Lo que va entre llaves es un bloque; si quieres entender bien cómo funcionan, mira Bloques en Ruby. Tienes más formas de recorrer arrays en Bucles e iteradores en Ruby.

El 0 es el primero; el -1, el último.

Otros métodos que usarás a diario

tapas = ["papas", "mojo", "papas", "gofio"]
p tapas.uniq             # ["papas", "mojo", "gofio"]: sin repetidos
p tapas.sort             # ["gofio", "mojo", "papas", "papas"]: ordenado
p tapas.count("papas")   # 2: cuántas veces aparece
p tapas.index("mojo")    # 1: en qué posición está
puts tapas.join(", ")    # papas, mojo, papas, gofio
p tapas.empty?           # false
p [[1, 2], [3, [4]]].flatten   # [1, 2, 3, 4]: aplana los arrays de dentro

join convierte el array en un único texto, con el separador que le digas. Y tally cuenta cuántas veces aparece cada elemento y lo devuelve en un hash: tapas.tally da {"papas" => 2, "mojo" => 1, "gofio" => 1}.

Arrays a partir de rangos

Un rango (0..9) se convierte en array con to_a:

("CARA_A".."CARA_D").to_a   # ["CARA_A", "CARA_B", "CARA_C", "CARA_D"]

digitos = (0..9).to_a       # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
digitos.include?(5)         # true
digitos.min                 # 0
digitos.max                 # 9
digitos.reject { |n| n < 5 }  # [5, 6, 7, 8, 9]

Errores frecuentes

Las salidas son de Ruby 4.0.9; en Ruby 3.4.12 salen igual.

1. Llamar a un método sobre una posición que no existe. array[2] no falla: devuelve nil. El error llega en la línea siguiente, cuando usas ese nil:

tapas = ["papas", "manises"]
puts tapas[2].upcase
nil_metodo.rb:2:in '<main>': undefined method 'upcase' for nil (NoMethodError)

Si la posición tiene que existir, usa fetch: falla en el sitio correcto y te dice qué posiciones hay.

array = ["papas", "manises"]
array.fetch(345)
fetch.rb:2:in 'Array#fetch': index 345 outside of array bounds: -2...2 (IndexError)

2. Crear un array de arrays con Array.new(3, []). Parece que crea tres listas vacías, pero crea una sola y la pone tres veces. Es como tres etiquetas pegadas en la misma caja:

mesas = Array.new(3, [])
mesas[0] << "Ana"
p mesas   # [["Ana"], ["Ana"], ["Ana"]]

Con un bloque, cada posición recibe su propio array:

mesas = Array.new(3) { [] }
mesas[0] << "Ana"
p mesas   # [["Ana"], [], []]

Con Array.new(3, "cerveza") no lo notas porque no cambias los textos, pero las tres posiciones también son el mismo objeto.

3. Borrar elementos mientras recorres el array. Al borrar uno, los demás se mueven una posición y each se salta el siguiente:

numeros = [1, 3, 5, 6]
numeros.each { |n| numeros.delete(n) if n.odd? }
p numeros   # [3, 6]: el 3 se ha librado

Para borrar según una condición, usa reject! (o delete_if), que está pensado para eso:

numeros = [1, 3, 5, 6]
numeros.reject!(&:odd?)
p numeros   # [6]

4. Modificar un array congelado. Es el FrozenError de la sección de freeze. Si necesitas una versión cambiada, crea una nueva con +, map o dup.

Compruébalo con un test

Un array casi nunca va suelto: suele estar dentro de un objeto que decide qué se puede hacer con él. Este carrito guarda los productos en un array. Crea carrito.rb:

class Carrito
  attr_reader :productos

  def initialize
    @productos = []
  end

  def anadir(producto)
    @productos << producto
    self
  end

  def quitar(producto)
    @productos.delete(producto)
  end

  def resumen
    @productos.tally.map { |producto, cantidad| "#{cantidad} x #{producto}" }
  end
end

Y carrito_test.rb, con Minitest, que viene con Ruby:

require "minitest/autorun"
require_relative "carrito"

class CarritoTest < Minitest::Test
  def test_empieza_vacio
    assert_empty Carrito.new.productos
  end

  def test_anade_al_final_en_orden
    carrito = Carrito.new.anadir("papas").anadir("mojo")
    assert_equal ["papas", "mojo"], carrito.productos
  end

  def test_quitar_borra_todas_las_copias
    carrito = Carrito.new.anadir("papas").anadir("mojo").anadir("papas")
    assert_equal "papas", carrito.quitar("papas")
    assert_equal ["mojo"], carrito.productos
  end

  def test_resumen_agrupa_repetidos
    carrito = Carrito.new.anadir("papas").anadir("papas").anadir("mojo")
    assert_equal ["2 x papas", "1 x mojo"], carrito.resumen
  end
end
ruby carrito_test.rb
4 runs, 6 assertions, 0 failures, 0 errors, 0 skips

El tercer test deja escrito algo que sorprende a mucha gente: delete borra todas las copias de ese valor, no solo la primera. Para quitar solo una, busca su posición con index y bórrala con delete_at. Si es tu primer test en Ruby, empieza por la introducción al testing en Ruby.

Cuándo no usar un array

El array es la herramienta para una lista ordenada en la que importa la posición. Hay casos en los que otra encaja mejor:

  • Si buscas por nombre, no por posición, usa un hash. Un teléfono se busca por la persona, no por «el tercero de la lista».
  • Si no quieres repetidos y preguntas mucho «¿está?», usa un Set. include? en un array mira los elementos uno a uno; en un Set va directo, como buscar en un índice en vez de leer el libro entero. En Ruby 4.0 Set es parte del núcleo, y en Ruby 3.4 se carga solo, sin require.
vistos = Set.new
vistos << "papas" << "mojo" << "papas"
p vistos                    # Set["papas", "mojo"] en Ruby 4.0
p vistos.include?("mojo")   # true

En Ruby 3.4, el p vistos se muestra como #<Set: {"papas", "mojo"}>; el contenido es el mismo.

  • Si cada posición significa algo distinto (["Ana", 41, "La Laguna"]: nombre, edad y ciudad), es un registro, no una lista. Un hash con claves o un Struct dicen qué es cada cosa; persona[1] no lo dice.

Ejercicio de cinco minutos

  1. Partiendo de %w[papas mojo papas gofio], consigue "gofio, mojo, papas": sin repetidos, en orden alfabético y separados por comas.
  2. Añade al Carrito un método quitar_uno que quite solo la primera copia de un producto, y escribe primero su test.
  3. Crea un array de tres mesas con Array.new(3, []), sienta a alguien en la primera y comprueba con mesas[0].equal?(mesas[1]) que son la misma lista.

Fuentes

Los ejemplos del artículo original se ejecutaron con Ruby 4.0.9 (imagen oficial ruby:latest de Docker) en noviembre de 2026, y los resultados de los comentarios son los reales. El 12 de noviembre de 2026 se ha repetido todo, junto con las secciones nuevas (métodos de uso diario, errores frecuentes, test y Set), con las imágenes oficiales ruby:4.0 (Ruby 4.0.9, Minitest 6.0.0) y ruby:3.4 (Ruby 3.4.12, Minitest 5.25.4): la salida es la misma salvo el formato de Set#inspect. La imagen de índices del original se ha sustituido por el ejemplo de a = %w[ant bat …], porque era un escaneo de un libro de terceros.