Overblog Seguir este blog
Edit post Administration Create my blog
4 febrero 2014 2 04 /02 /febrero /2014 15:01

Continuamos despúes de un largo tiempo con los tutororiales, en esta ocación tenemos los arreglos o matrices, que nos permiten agrupar distintos datos para luego acceder facilmente a ellos, en Ruby es muy facil.

 

Sintaxis:

 

[ valor1 , valor2 , valor3 ]

 

Practicamente tenemos que colocar entre 2 corchetes " [ " y " ] " todos los valores que queramos, estos valores (que pueden ser números, letras o cualquier objeto) deben estar separados por comas, no necesariamente todos los valores tienen que ser del mismo tipo, se pueden mezclar y también una matriz es un objeto de la clase Array.

 

Por ejemplo un arreglo en el irb:

 

irb(main):001:0> [1,3.6,"algo"]

=> [1, 3.6, "algo"]

 

Nos devuelve que ha reconocido la matriz, ahora podemos almacenarlo en una variable:

 

irb(main):002:0> arreglo = [1,3.6,'algo']

=> [1, 3.6, "algo"]

irb(main):003:0> arreglo.count

=> 3

 

Como podemos observar arreglo ha almacenado los 3 valores, el 1, el 3.6 y la palabra algo, ahora ya que arreglo es un objeto matriz, entonces tiene diversas propiedades y métodos, entre ellas tiene el método count, que nos cuenta cuantos datos tienen en su interior.

 

Colocando y obteniendo valores de la matriz:

 

Bueno ahora tener un arreglo nos sirve mucho y debemos poder trabajar con él, por ello vamos a obtener los valores:

 

First y last

 

Nos sirven para acceder al primer y ultimo valor

 

irb(main):004:0> arreglo.first

=> 1

irb(main):005:0> arreglo.last

=> "algo"

 

hemos usado la propiedad first que nos devuelve el primer valor "1" y luego hemos usadlo la propiedad last que nos devuelve el segundo valor "algo", ahora vamos a hacer algunas cosas mas con el first y el last:

 

irb(main):010:0> arreglo.first 2

=> [1, 3.6]

irb(main):011:0> arreglo.last 2

=> [3.6, "algo"]

irb(main):012:0> arreglo.first(2).last

=> 3.6

irb(main):013:0> arreglo.last(2).first

=> 3.6

 

En la línea 10, hemos usado el first 2, quiere decir que nos va a traer los 2 primeros valores, pero ya los trae agrupados en una matriz y esta contiene los 2 primeros valores solicitados, en la siguiente linea 11, usamos el last 2 que hace lo mismo, solo que contiene los 2 últimos valores, en la tercera línea tenemos un caso interesante; en ves de llamar a first 2, usamos los parentesis first(2), esto lo hacemos para evitar tener un caso trivial, en ruby el uso de parentesis es opcional siempre y cuando no sea trivial, (porque si ponemos first 2.last, lo que entiende Ruby es que del numero 2 va a tratar de utilizar el metodo last y como no lo tiene va a dar un error), entonces ya que el first(2) devuelve los 2 primeros valores, le indicamos que de esos 2 valores saque el último valor, que sería 3.6; en la siguiente linea 13, es lo mismo pero empezando desde el ultimo, sacando los 2 ultimos valores y luego tomando el primero de esos 2 ultimos valores, que volvería a ser 3.6, en otras palabras hemos sacado el segundo y el penúltimo valor de una forma muy facil.

 

Obteniendo un valor específico con índice

 

Un aspecto importante de un arreglo o matriz es que todos los datos tienen asociado un número de orden, que empieza desde 0, a ese número se le conoce también como índice, entonces podemos obtener cada valor de forma unitaria indicando el índice:

 

irb(main):020:0> arreglo[0]

=> 1

irb(main):021:0> arreglo[1]

=> 3.6

irb(main):022:0> arreglo[2]

=> "algo"

 

Como se puede ver, para acceder por el número de índice se debe colocar el número entre corchetes " [ " y " ] " con ello nos devuelve el valor de forma muy específica, si le ponemos un índice que no esta en el rango nos va a devolver nil:

 

irb(main):023:0> arreglo[3]

=> nil

 

Tambien podemos acceder desde los ultimos valores, colocando un valor negativo en el índice empezando desde el -1.

 

irb(main):015:0> arreglo[-1]

=> "algo"

irb(main):016:0> arreglo[-2]

=> 3.6

irb(main):024:0> arreglo[-3]

=> 1

irb(main):025:0> arreglo[-4]

=> nil

 

Al igual que en la forma positiva, si nos pasamos del rango nos devolverá un nil.

 

Preguntando por datos

 

Bueno ahora hay que consultar si algun dato se encuentra en la matriz, para ello podemos usar el método member? o include? (ambos funcionan igual)

 

irb(main):078:0> arreglo.member? "algo"

=> true

irb(main):079:0> arreglo.include? "algo"

=> true

 

Si el dato esta en el arreglo nos devolverá un true de lo contrario false, también es posible preguntar en que número de índice se encuentra determinado dato:

 

irb(main):080:0> arreglo.find_index "algo"

=> 2

irb(main):081:0> arreglo.find_index "algos"

=> nil

 

El método find_index hace ese trabajo y nos retorna el valor del dato si es que lo encuentra, en caso contrario nos devolverá nil.

 

Agregando datos

 

Agregar un dato en una matriz es bastante sencillo, se puede utilizar el operador << que agrega un dato a la matriz

 

irb(main):098:0> arreglo << :adicional

=> [1, 3.6, "algo", :adicional]

 

Como vemos hemos agregado el símbolo :adicional y se encuentra al final del arreglo, tambien podemos agregar otro elemento como una matriz por ejemplo:

 

arreglo = arreglo + [2]  que es lo mismo que arreglo += [2]

 

irb(main):105:0> arreglo += [2]

=> [1, 3.6, "algo", :adicional, 2]

 

Y ya ha agregado el arreglo (que puede tambien tener mas elementos) a la matriz, otra forma es conociendo el indice:

 

irb(main):106:0> arreglo[5]=true

=> true

irb(main):107:0> arreglo

=> [1, 3.6, "algo", :adicional, 2, true]

 

Hemos agregado el valor boolean "true" al final, indicandole explicitamente el número, tambien podemos usar una variable de la siguiente manera

 

irb(main):111:0> arreglo[arreglo.count]=false

=> false

irb(main):112:0> arreglo

=> [1, 3.6, "algo", :adicional, 2, true, false]

 

Y agregamos el "false" tambien dentro del arreglo, otra forma:

 

irb(main):221:0> arreglo.push 3

=> [1, 3.6, :adicional, 2, false, 3]

 

Agrega el valor 3 al final del arreglo, también se puede:

 

irb(main):222:0> arreglo.unshift :otro

=> [:otro, 1, 3.6, :adicional, 2, false, 3]

 

Se ha agregado el simbolo :otro al inicio de todo el arreglo

 

Eliminando datos

 

Podemos eliminar los datos de la matriz de forma sencilla:

 

irb(main):107:0> arreglo

=> [1, 3.6, "algo", :adicional, 2, true, false]

irb(main):113:0> arreglo.delete "algo"

=> "algo"

irb(main):114:0> arreglo

=> [1, 3.6, :adicional, 2, true, false]

 

El método delete recibió la palabra "algo" y en consecuencia ha eliminado el dato "algo" (si hubieran 2 palabras "algo" también las eliminaría a las 2), otra forma es:

 

irb(main):114:0> arreglo

=> [1, 3.6, :adicional, 2, true, false]

irb(main):115:0> arreglo.delete_at 4

=> true

irb(main):116:0> arreglo

=> [1, 3.6, :adicional, 2, false]

 

Ha eliminado el dato que ocupaba la posición 4 del índice, otra forma también es:

 

irb(main):223:0> arreglo.pop

=> 3

irb(main):224:0> arreglo

=> [:otro, 1, 3.6, :adicional, 2, false]

 

Donde el método pop elimina el último dato del arreglo, una forma más también:

 

irb(main):225:0> arreglo.shift

=> :otro

irb(main):226:0> arreglo

=> [1, 3.6, :adicional, 2, false]

 

Donde se elimina el primer valor del arreglo, otra forma aritmética.

 

irb(main):255:0> arreglo -= [3.6]

=> [1, :adicional, 2, false]

 

En las formas aritméticas de eliminación se debe considerar que el valor debe estar como un tipo arreglo, es decir, entre corchetes " [ " y " ] " y en el ejemplo es la versión resumida de arreglo = arreglo - [3.6]

 

Actualizando datos

 

Una forma de actualizar los datos es conociendo el índice y se reemplaza los valores

 

irb(main):241:0> arreglo

=> [1, 3.6, :adicional, 2, false]

irb(main):246:0> arreglo[3]

=> 2

irb(main):247:0> arreglo[3]=9

=> 9

irb(main):248:0> arreglo

=> [1, 3.6, :adicional, 9, false]

 

De esta manera se está cambiando el valor "2" por el valor "9", seleccionado el índice 3, otra forma sería introduciendo el índice como variable:

 

irb(main):248:0> arreglo

=> [1, 3.6, :adicional, 9, false]

irb(main):249:0> arreglo[arreglo.find_index :adicional] = "nuevo"

=> "nuevo"

irb(main):250:0> arreglo

=> [1, 3.6, "nuevo", 9, false]

 

Se cambió el símbolo :adicional por la palabra "nuevo"

 

Algunas operaciones con las matrices

 

Se puede por ejemplo invertir las matrices,rotar, etc.

 

irb(main):257:0> arreglo

=> [1, :adicional, 2, false]

irb(main):258:0> arreglo.reverse

=> [false, 2, :adicional, 1]

irb(main):260:0> arreglo.rotate

=> [:adicional, 2, false, 1]

irb(main):261:0> arreglo.rotate 2

=> [2, false, 1, :adicional]

irb(main):268:0> arreglo

=> [1, :adicional, 2, false]

 

Los arreglos, matrices, arrays o como quiera llamárseles, son muy fáciles de manejar en Ruby, obviamente existen muchos más métodos y características pero se mencionan las más comunes para que sea más facil introducirse en este mundo Ruby.

 

Bueno hemos avanzado con el capitulo 13 continuaremos con el capitulo 14, por favor dudas y comentarios pueden hacerlo si ningún tipo de restriccion, si desean agradecer también comenten.

Compartir este post

Repost 0
Published by Daniel A. Nuñez C. - en Tutorial Ruby
Comenta este artículo

Comentarios

Matias 07/21/2015 05:48

como agregar varios datos en una matriz despues de un enter, se entiende??
EJ: Yo quiero agregar una palabra, y al rato quiero agregar otra palabra y despues se me ocurre agregar otra palabra....
En teoria los datos que uno agrega tiene que estar guardados en la matriz y si yo llamo a esa matriz tiene que devolver los datos que se guardaron!!!

Daniel A. Nuñez C. 07/21/2015 08:03

Hola Matias gracias por preguntar, bueno puedo darte una alternativa que no se encuentra listado en este apartado 13 del tutorial, que sería:
matriz = Array.new # creo un arreglo vacío
palabra = "una palabra" # creo una variable palabra
matriz = palabra, "palabra de al rato", "otra palabra" # agrego palabras, variable o directas y estas estan almacenadas en la matriz
matriz # veo los datos almacenados que son: ["una palabra", "palabra de al rato", "otra palabra"]
palabra1, palabra2, palabra3 = matriz # devuelvo los valores guardados de la matriz en variables, donde palabra1 tiene el primer elementos de la matriz, palabra2 el segundo y palabra3 el ultimo respectivamente.
palabra1 # devuelve "una palabra"
palabra2 # devuelve "palabra de al rato"
palabra3 # devuelve "otra palabra"

Espero que te haya ayudado, si tienes mas consultas no dudes en realizarlas, saludos.

Daniel 11/30/2014 05:39

Buen dia. Felicidades por estos tutoriales. Ruby es un gran lenguaje, pero es complicado encontrar buen material en español y esto es de mucha ayuda. Una duda ¿Si quisiera definir el espacio de mi arreglo, tengo que escribir cada uno de esos elementos? Ejemplo: arreglo=[10] (indicando que mi arreglo tiene 10 espacios) o tengo que hacer "arreglo=[1,2,...,10]" Gracias de nuevo.

Daniel A. Nuñez C. 11/30/2014 15:34

Hola Daniel, gracias por las felicitaciones!, en los lenguajes dinamicos como Ruby no es necesario declarar un tamaño o dimension al arreglo ya que el limite es la cantidad de memoria con el que cuentas, por lo tanto puedes crear un arreglo con arreglo = [] o con arreglo = Array.new, luego puedes agregar elementos como arreglo[0] = 1 o arreglo << 2, espero haberte ayudado con mi respuesta, hay otros mecanismos para crear rapidamente por ejemplo un arreglo que contengan 10 elementos puede ser arreglo = (1..10).to_a, cualquier duda por favor no dudes en realizarmela, saludos!

Presentación

  • : El blog de Daniel A. Nuñez C.
  • El blog de Daniel A. Nuñez C.
  • : Un blog sobre tecnologías y futuro, también sobre lenguaje de programación Ruby y más.
  • Contacto

Perfil

  • Daniel A. Nuñez C.
  • Ingeniero de Sistemas
  • Ingeniero de Sistemas

Donaciones/Donations

Por favor considera realizar una donación

Please make a donation

btn_donateCC_LG.png

Buscar Tema En Este Blog

Archivos