Arreglos

Arreglos

Hasta ahora hemos trabajado con cadenas de texto, números y booleanos. En este capítulo vamos a hablar de un nuevo tipo de datos: los arreglos.
Un arreglo es una lista ordenada de elementos de cualquier tipo. Para crear tu primer arreglo abre IRB y escribe lo siguiente:
1
array = [1, "Pedro", true, false, "Juan"]
Copied!
La sintaxis de un arreglo es muy simple. Los elementos del arreglo se envuelven entre corchetes y se separan con coma. Fíjate que el arreglo que creamos contiene números, cadenas de texto y booleanos. Cada elemento del arreglo puede ser de cualquier tipo (incluso otros arreglos!).

Obteniendo elementos del arreglo

Para obtener la primera posición del arreglo que acabamos de crear utilizas array[0]:
1
$ irb
2
> array = [1, "Pedro", true, false, "Juan"]
3
=> [1, "Pedro", true, false, "Juan"]
4
> array[0]
5
=> 1
Copied!
La sintaxis para obtener un elemento del arreglo es [n] donde n es la posición empezando en 0. Imprime los demás elementos del arreglo:
1
> array[1]
2
=> "Pedro"
3
> array[2]
4
=> true
5
> array[3]
6
=> false
7
> array[4]
8
=> "Juan"
Copied!

Recorriendo un arreglo

En el ejemplo anterior pudimos imprimir cada una de las posiciones porque era un arreglo de pocos elementos. Sin embargo esto no siempre es práctico. Primero, el arreglo puede ser muy grande o puede que no sepamos el tamaño del arreglo de antemano. Crea un archivo llamado arrays.rb y escribe el siguiente código:
1
array = [1, "Pedro", true, false, "Juan"]
2
3
array.each do |element|
4
puts element
5
end
Copied!
El resultado debe ser el siguiente:
1
$ ruby arrays.rb
2
1
3
Pedro
4
true
5
false
6
Juan
Copied!
Si necesitamos el índice de cada elemento podemos utilizar el método each_with_index en vez de each:
1
array = [1, "Pedro", true, false, "Juan"]
2
3
array.each_with_index do |element, index|
4
puts "#{index}: #{element}"
5
end
Copied!
El resultado cuando lo ejecutamos debe ser el siguiente:
1
$ ruby arrays.rb
2
0: 1
3
1: Pedro
4
2: true
5
3: false
6
4: Juan
Copied!

Reemplazando un elemento

Es posible reemplazar el valor de cualquier elemento del arreglo. Por ejemplo:
1
array = [1, "Pedro", true, false, "Juan"]
2
array[1] = "Germán" # reemplazamos el elemento en la posición 1
3
4
# [1, "Germán", true, false, "Juan"]
Copied!
En este ejemplo estamos reemplazando la posición 1 del arreglo (que realmente es la segunda porque recuerda que empieza en 0) con el valor "Germán". La línea más importante es la siguiente:
1
array[1] = "Germán"
Copied!
Como ejercicio intenta reemplazar el último elemento ("Juan") por otro valor.

Insertando nuevos elementos

Es posible insertar nuevos elementos en un arreglo (puede estar vacío o tener elementos). Por ejemplo:
1
array = ["Pedro"]
2
array.push("Germán") # ["Pedro", "Germán"]
3
array << "Diana" # ["Pedro", "Germán", "Diana"]
Copied!
Tanto el método push como el operador << nos permiten agregar un elemento al final de la lista. ¿Qué pasa si queremos agregar un elemento en otra posición? Para eso sirve el método insert:
1
array = ["Pedro", "Germán", "Diana"]
2
array.insert(0, "Juan") # ["Juan", "Pedro", "Germán", "Diana"]
Copied!
El método insert recibe 2 argumentos: la posición en la que se quiere insertar el elemento y el valor del nuevo elemento. Todos los elementos desde esa posición se mueven a la derecha.

Eliminando elementos

Para eliminar elementos de un arreglo utiliza delete_at:
1
array = ["Pedro", "Germán", "Diana"]
2
array.delete_at(1) # ["Pedro", "Diana"]
Copied!

Un Ejemplo

Pongamos en práctica lo que hemos visto hasta ahora y creemos un programa que le permita al usuario ingresar los nombres de algunas personas y seleccione una al azar. Crea un archivo llamado choose.rb y escribe lo siguiente:
1
print "Ingresa el número de personas que participarán: "
2
num = gets.chomp.to_i
3
4
people = []
5
num.times do
6
print "Ingresa el nombre de la persona: "
7
people << gets.chomp # insertamos cada persona en el arreglo
8
end
9
10
puts "La persona seleccionada es #{people.sample}"
Copied!
Las primeras dos líneas obtienen el número de personas que el usuario quiere ingresar. Después creamos un arreglo vacío en el que vamos a ir agregando las personas. Utilizando el ciclo times le pedimos el usuario que ingrese el nombre de cada persona. Por último, seleccionamos un elemento del arreglo al azar utilizando el método sample.
Ejecutemos el archivo y probémoslo:
1
$ ruby choose.rb
2
Ingresa el número de personas que participarán: 3
3
Ingresa el nombre de la persona: Pedro
4
Ingresa el nombre de la persona: Juan
5
Ingresa el nombre de la persona: Germán
6
La persona seleccionada es Pedro
Copied!

Métodos útiles

Ya hemos visto métodos como push para insertar, each para recorrer, delete_at para eliminar y sample para seleccionar un elemento de forma aleatoria en los arreglos. Otros métodos útiles son:
Método
Descripción
first
Retorna el primer elemento del arreglo
last
Retorna el último elemento del arreglo
shuffle
Retorna un nuevo arrego mezclado aleatoriamente
length
Retorna el tamaño del arreglo
Puedes ver todos los métodos en la documentación de Array.

Métodos con exclamación al final

En la documentación de Ruby vas a encontrar algunos métodos que terminan con un signo de exclamación al final como shuffle! y reverse!. Esos métodos se deben utilizar con cuidado porque modifican el arreglo original. Generalmente estos métodos tienen otra versión sin signo de exclamación que retornan un nuevo arreglo sin modificar el original (p.e. shuffle y reverse).
En general intenta utilizar los métodos que no tienen el signo de exclamación al final a menos de que sea necesario modificar el arreglo original.
Por ejemplo, si quieres mezclar los lementos de un arreglo puedes hacerlo de dos formas:
1
array = [1, 2, 3, 4, 5]
2
3
array.shuffle! # modifica el arreglo original, no es necesario asignarlo a otra variable
4
another_array = array.suffle # no modifica el arreglo original, es necesario asignarlo a otra variable
Copied!

Argumentos de un programa

Hasta ahora hemos solicitado información del usuario utilizando gets.chomp. Sin embargo, existe otra forma en que el usuario nos puede pasar información y es a través de los argumentos del programa.
Cuando ejecutamos un programa podemos pasarle varios argumentos separados por espacio. por ejemplo:
1
$ ruby program.rb argumento1 argumento2 argumento3
Copied!
Podemos acceder a estos argumentos a través de una variable llamada ARGV (que es un arreglo). Para probarlo crea un archivo llamado args.rb y escribe lo siguiente:
1
ARGV.each do |arg|
2
puts arg
3
end
Copied!
Si ejecutas el archivo deberías ver algo como lo siguiente:
1
$ ruby args.rb argumento1 argumento2 argumento3
2
argumento1
3
argumento2
4
argumento3
Copied!
Es simplemente otra forma en la que puedes recibir información del usuario.
Last modified 3yr ago