La colosal montaña rusa de Chaitana

Los arrays son una estructura de datos habitual con la que trabajar. Por ello, existe una colección de métodos que se pueden usar para trabajar con arrays. Entre ellos se incluyen ordenar, invertir, insertar y muchos más.

Algunos de estos métodos son destructivos, lo que significa que modifican el array original. Otros no son destructivos, es decir, devuelven un nuevo array y no modifican el original.

Estos son algunos de los métodos más comunes que se pueden usar al trabajar con arrays:

insert

Cuando insertas un elemento en un array, puedes usar el método insert, que toma un índice y un elemento como argumentos. El elemento se insertará en el índice especificado y el resto del array se desplazará a la derecha. Si el índice está fuera de los límites, se lanzará un IndexError.

numbers = [1, 2, 3]
numbers.insert(1, 4)
numbers # => [1, 4, 2, 3]

numbers.insert(5, 5) # => Error: Index out of bounds (IndexError)

delete

Cuando quieres eliminar un elemento concreto de un array, puedes usar el método delete, que toma un elemento como argumento. El método devuelve el elemento que se eliminó. Si el elemento no existe en el array, se devolverá nil.

numbers = [1, 2, 3]
numbers.delete(2) # => 2
numbers           # => [1, 3]

first & last

Cuando quieres obtener el primer o el último elemento de un array, puedes usar los métodos first y last. Estos métodos aceptan un argumento opcional que especifica cuántos elementos devolver. Pueden mejorar la legibilidad en comparación con usar el índice 0 o -1, o con usar un rango. Si el array está vacío, se lanzará un Enumerable::EmptyError.

numbers = [1, 2, 3]
numbers.first # => 1
numbers.last  # => 3

numbers.first(2) # => [1, 2]
numbers.last(2)  # => [2, 3]

empty_array = [] of Int32
empty_array.last # => Error: Empty enumerable (Enumerable::EmptyError)

reverse

Cuando quieres invertir un array, puedes usar el método reverse, que devuelve un nuevo array con los elementos en orden inverso. Es importante tener en cuenta que reverse devuelve un nuevo array y no modifica el array original. Si quieres modificar el array original, añade un ! al final del nombre del método.

numbers = [1, 2, 3]
numbers.reverse # => [3, 2, 1]
numbers         # => [1, 2, 3]

numbers.reverse! # => [3, 2, 1]
numbers          # => [3, 2, 1]

Concatenación (+)

El método append (<<) es útil cuando quieres añadir objetos a un array. Sin embargo, cuando combinas dos arrays, puedes usar el operador +, que devuelve un nuevo array con los elementos de ambos arrays.

[1, 2] + [3, 4] # => [1, 2, 3, 4]

Si añades un array a otro array, el array se añadirá como un único elemento.

[1, 2] << [3, 4] # => [1, 2, [3, 4]]

empty?

Cuando quieres comprobar si un array está vacío, puedes usar el método empty?, que devuelve true si el array está vacío y false en caso contrario. Esto mejora la legibilidad en comparación con comprobar la longitud del array contra 0.

[].empty? # => true
[1, 2, 3].empty? # => false

index

Cuando quieres obtener el índice de un elemento en un array, puedes usar el método index, que toma un elemento como argumento. Si el elemento no existe en el array, se devolverá nil.

numbers = [1, 2, 3]
numbers.index(2) # => 1

size

Cuando quieres saber cuántos elementos tiene un array, puedes usar el método size.

numbers = [1, 2, 3]
numbers.size # => 3

count

Cuando quieres contar el número de veces que un elemento está presente en un array, puedes usar el método count.

fruits = ["apple", "banana", "apple"]
fruits.count("apple")      # => 2
fruits.count("banana")     # => 1
fruits.count("watermelon") # => 0

sort

Cuando quieres ordenar un array, puedes usar el método sort, que devuelve un nuevo array con los elementos ordenados. Al igual que con reverse, este método devuelve un nuevo array y no modifica el array original.

numbers = [3, 2, 1]
numbers.sort # => [1, 2, 3]
numbers      # => [3, 2, 1]

numbers.sort! # => [1, 2, 3]
numbers       # => [1, 2, 3]