Los arrays son una estructura de datos común con la que trabajar.
Por eso, existe una colección de métodos que puedes usar para trabajar con arrays.
Entre ellos hay métodos para ordenar, invertir, insertar y mucho más.
Algunos de estos métodos son destructivos, lo que significa que modifican el array original.
Otros son no destructivos, es decir, devuelven un nuevo array y no modifican el original.
Estos son algunos de los métodos más comunes que puedes usar cuando trabajas 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á hacia 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 específico 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 toman 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 notar que reverse devuelve un nuevo array y no modifica el array original.
Si quieres modificar el array original, agrega 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]
Concat(+)
El método para agregar (<<) 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 agregas un array a otro array, el array se añadirá como un solo 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 la cantidad de elementos en un array, puedes usar el método size.
numbers = [1, 2, 3]
numbers.size # => 3
count
Cuando quieres contar cuántas veces está presente un elemento 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]
Ejercicio de aprendizaje
