Curso Ruby I PDF

Lenguaje Ruby y su entorno
Curso de Ruby I: Introducción
Pedro Navajas Modelo
Laboratorio de Software Libre

Escuela Politécnica Superior
Universidad de Córdoba
16 de Marzo de 2011
Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 1 / 31

Tabla de contenidos
1 Ruby: ese gran lenguaje
Características de Ruby
2 Introducción a Ruby
Primer contacto con Ruby
Cadenas
Un primer programa usando cadenas
Expresiones regulares
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Bloque “for” e iteradores
Iteradores

Ruby: ese gran lenguaje Características de Ruby

Introducción a Ruby
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores
Un lenguaje de programación interpretado
Posibilidad de llamadas directas al sistema operativo

Potentes expresiones sobre cadenas de caracteres y expresiones
regulares
Facilidades de desarrollo y desarrollo incremental


regulares


regulares

Un lenguaje de programación orientado a objetos
Todo es un objeto (¡incluso nil!)

Características de la POO (herencia, clases, métodos...)
Métodos singleton
Iteradores y cierres


Métodos singleton


Métodos singleton


Métodos singleton

Un lenguaje de programación dinámico
Son innecesarias las declaraciones de variables

Las variables no tienen tipo
La sintaxis es simple y consistente
La gestión de memoria se realiza automáticamente







Un lenguaje de programación potente y flexible
Enteros de precisión múltiple

Modelo de procesamiento de excepciones
Carga dinámica
Hilos...
... y mucha mas diversión


Carga dinámica
Hilos...


Carga dinámica
Hilos...


Carga dinámica
Hilos...


Carga dinámica
Hilos...

Antes de comenzar con la parte interesante, una última información

teórica sobre algunos programas que nos serán de utilidad
irb: irb es una consola interactiva de ruby, en ella podemos
escribir todo el código que deseemos
irb mantendrá todas las variables y clases mientras siga
ejecutándose
irb soporta “autocompletion” si se invoca mediante irb -r
irb/completion
ri: ri es el equivalente a las páginas de manual de usuario de linux
Para invocar ri, basta con ejecutar ri seguido de el nombre de una
clase o método:
# ri String
# ri String.chop


ejecutándose
irb/completion
clase o método:
# ri String
# ri String.chop


ejecutándose
irb/completion
clase o método:
# ri String
# ri String.chop


ejecutándose
irb/completion
clase o método:
# ri String
# ri String.chop


ejecutándose
irb/completion
clase o método:
# ri String
# ri String.chop


ejecutándose
irb/completion
clase o método:
# ri String
# ri String.chop


ejecutándose
irb/completion
clase o método:
# ri String
# ri String.chop


ejecutándose
irb/completion
clase o método:
# ri String
# ri String.chop

Introducción a Ruby Primer contacto con Ruby
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

# irb -r irb/completion
def fact(n)
if n == 0
1
else
n * fact(n-1)
end
end
# Si queremos que se llame a la funcion con

# el argumento con el que se invoque al programa
print fact(ARGV[0].to_i), “\n“

def fact(n)
if n == 0
1
else
n * fact(n-1)
end
end


def fact(n)
if n == 0
1
else
n * fact(n-1)
end
end


Una funcion de suma
Como vimos anteriormente, en ruby las variables no tienen tipos

Esto implica que al pasar variables a funciones, estas no
necesitan tipo
Implica, además, que ruby tan solo se limita a ejecutar el método
llamado para un objeto, da igual cual sea éste mientras tenga ese
método
Veamos un ejemplo
def suma(a, b)
a + b
end
print suma(3, 3).to_s + “\n“
print suma(“hola “, “mundo“) + “\n“

Una funcion de suma

necesitan tipo
método
Veamos un ejemplo
def suma(a, b)
a + b
end

Una funcion de suma

necesitan tipo
método
Veamos un ejemplo
def suma(a, b)
a + b
end

Una funcion de suma

necesitan tipo
método
Veamos un ejemplo
def suma(a, b)
a + b
end

Introducción a Ruby Cadenas
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

En ruby, las cadenas son objetos pertenecientes a la clase String (¡¡no

confundir con pertenecientes al tipo String!!). A continuación vamos a
ver unos ejemplos de manejod de cadenas en ruby.
# Declaración de una cadena

a=“alom ybur“
# Concatenación de operaciones sobre la cadena
a.reverse.capitalize.gsub(/l/, ’*’)
# Extracción de los 4 primeros caracteres
a.reverse[0..4]
# Comparacion de cadenas
a=“HOLA“
b=“hola“
a == b.swapcase
# ¿Por que no orientarlo todo a objetos?
a.eql?(b.swapcase)
a == b

En ruby, las cadenas son objetos pertenecientes a la clase String (¡¡no

confundir con pertenecientes al tipo String!!). A continuación vamos a
ver unos ejemplos de manejod de cadenas en ruby.
# Declaración de una cadena

a=“alom ybur“
# Concatenación de operaciones sobre la cadena
a.reverse.capitalize.gsub(/l/, ’*’)
# Extracción de los 4 primeros caracteres
a.reverse[0..4]
# Comparacion de cadenas
a=“HOLA“
b=“hola“
a == b.swapcase
# ¿Por que no orientarlo todo a objetos?
a.eql?(b.swapcase)
a == b

# Salvar como guess.rb (sacado de es.tldp.org)

words = [’foobar’, ’baz’, ’quux’]
secret = words[rand(3)]
print “adivina? “
while guess = STDIN.gets
guess.chop!
if guess == secret
print “¡Ganas!\n“
break
else
print “Lo siento. Pierdes\n“
end
print “adivina? “
end
print “La palabra era “, secret, “.\n“

Introducción a Ruby Expresiones regulares
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

Las expresiones regulares son una de las ventajas de ruby

y una herramienta poderosísima y de enorme utilidad.
Pero no se van a explicar, tan solo veremos ejemplos de su uso en
ruby.
def chab(s) # contiene un hexadecinal entre ángulos
(s =~ /<0[Xx][\dA-Fa-f]+>/) != nil
end
chab “<0x38z7e>“ # letra errónea
chab “<0xfc0004>“ # esto si cuadra
“abcdef“ =~ /d/ # Devuelve la posicion de “d“
“hola que pasa“.gsub(/(.l)/, “a“)
“hola que pasa“.gsub(/(.l)/, “\\1\\1“)
Más información en The linux documentatiom project1
1
http://es.tldp.org/Manuales-LuCAS/doc-guia-usuario-ruby/doc-guia-usuario-ruby-
html/c173.html

ruby.
(s =~ /<0[Xx][\dA-Fa-f]+>/) != nil
end
1
html/c173.html

ruby.
(s =~ /<0[Xx][\dA-Fa-f]+>/) != nil
end
1
html/c173.html

ruby.
(s =~ /<0[Xx][\dA-Fa-f]+>/) != nil
end
1
html/c173.html
Introducción a Ruby Vectores (Arrays)
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

Los arrays en ruby son una maravilla
# Declaracion y manejo básico

ary = [1, 2, “3“]
nuevo = ary + [“foo“, “bar“]
ary * 2
# También hay acceso directo a los elementos

ary[0] # Acceso al primer elemento del vector
ary[4, 2] # Dame dos elementos a partir del quinto
ary[0..2] # Todos desde el primer al tercer elemento
ary[-2] # Acceso al 2o por la cola
# Los arrays se pueden convertir a y obtener

# de cadenas utilizado join y split respectivamente:
str = ary.join(’:’)
str.split(’:’)


ary = [1, 2, “3“]
ary * 2


str.split(’:’)


ary = [1, 2, “3“]
ary * 2


str.split(’:’)


ary = [1, 2, “3“]
ary * 2


str.split(’:’)

Introducción a Ruby Hashes
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

Un hash podría definirse como un diccionario, en el que se define una

lista de claves que tienen asociados un valor correspondiente.
Los hashes se definen entre llaves “{” “}” y el valor se asocia con una
flecha “=>”.
# Definimos un hash de dos claves

mihash = {1 => 2, “2“ => [3, 5]}
# Accedemos a los dos por su clave
mihash[1]
mihash[“2“]
# Añadimos un valor
mihash[“meloinvento“] = “sisi“
# Borramos un valor
mihash[“2“] = nil
Como toda clase ruby, tiene numerosos metodos adicionales (sort,

lenght, collect...)


flecha “=>”.

mihash = {1 => 2, “2“ => [3, 5]}
mihash[1]
mihash[“2“]
# Borramos un valor

lenght, collect...)


flecha “=>”.

mihash = {1 => 2, “2“ => [3, 5]}
mihash[1]
mihash[“2“]
# Borramos un valor

lenght, collect...)

Bloque de control Bloque “case”
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

La sentencia case utiliza internamente el operador === (que se podría

traducir como “contiene”) para verificar las distintas condiciones.
Un uso de ese operador sería: (1..9) === 3 que devolvería “true”.
i=8
case i
when 1, 2..5
print “1..5\n“
when 6..10
print “6..10\n“
end
case ’abcdef’
when ’aaa’, ’bbb’
print “aaa o bbb\n“
when /def/
print “incluye /def/\n“
end


i=8
case i
when 1, 2..5
print “1..5\n“
when 6..10
print “6..10\n“
end
case ’abcdef’
when /def/
end


i=8
case i
when 1, 2..5
print “1..5\n“
when 6..10
print “6..10\n“
end
case ’abcdef’
when /def/
end

Bloque de control Bloque “while”
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

El bucle while es muy similar al bucle while de otros lenguajes, la

sintaxis es la siguiente:
while (condicion)
acciones
redo if condicion3
acciones
next if condicion4
acciones
break if condicion2
acciones
end
El bucle while tiene un “compañero”: el bucle until

De la misma forma, la sentencia if tiene un opuesto: unless

El bucle while es muy similar al bucle while de otros lenguajes, la

sintaxis es la siguiente:
while (condicion)
acciones
redo if condicion3
acciones
next if condicion4
acciones
break if condicion2
acciones
end
El bucle while tiene un “compañero”: el bucle until

De la misma forma, la sentencia if tiene un opuesto: unless

Bloque de control Bloque “for” e iteradores
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

El bucle for es en realidad un iterador que se encarga de actuar sobre

“colecciones” de datos.
for elm in [100,-9.6,“pickle“]

print “#{elm}\t(#{elm.type})\n“
end
Este ejemplo, no es sino una “traducción” de como lo hace ruby

mediante iteradores, que sería del siguiente modo:
[100,-9.6,“pickle“].each { |elemento|
print “#{elemento}\t(#{elemento.type})\n“
}



end

}



end

}



end

}

Bloque de control Iteradores
Sección Actual:
Cadenas
Vectores (Arrays)
Hashes
3 Bloque de control
Bloque “case”
Bloque “while”
Iteradores

Los iteradores son unas herramientas que ofrecen algunos

lenguajes de programación
Su concepto es sencillo: ejecutar un determinado código por cada
uno de los elementos de una colección
Permiten trabajar con colecciones independientemente del tipo de
dato que contengan
int i = 0;
char s = “cadena”;
for (i = 0; i < strlen(s); i++)
{ ... }


dato que contengan
int i = 0;
{ ... }


dato que contengan
int i = 0;
{ ... }


dato que contengan
int i = 0;
{ ... }


dato que contengan
int i = 0;
for (i = 0; s[i] != ’\0’; i++)
{ ... }

Un enfoque a más alto nivel
Un primer acercamiento, es tomar cada objeto de la iteracion

como algo independiente
#!/bin/bash
for file in *.ebuild
do
ebuild $file digest
done
El iterador es bajo nivel y externo a la coleccion


#!/bin/bash
do
ebuild $file digest
done


#!/bin/bash
do
ebuild $file digest
done

El enfoque de ruby (I)
Los iteradores en ruby son algo ímplicito a cada colección

“hellomoto”.each_byte {|x| print x + “\n” }
Aunque la clase String cambie, siempre se podrá iterar sobre sus
carácteres
mifichero = File.open(“fichero.txt“)
mifichero.each_line { |linea|
print “LINEA: #{linea}“
break if linea.include?(“salir“)
}


“hellomoto”.each_byte {|x| print x + “\n” }
carácteres
}


“hellomoto”.each_byte {|x| printf (“ %c\n”, x) }
carácteres
}


carácteres
}


carácteres
}

El enfoque de ruby (II)
Veamos un ejemplo de como iterar modificando la propia

colección
mifich = File.open(“fichero.txt“)
a = Array.new
mifich.each_line{ |x| a « x }
out = File.open(“out.txt“, “w“)
a.collect{|x| x.capitalize}.each{|x| out.write x}
¡Los iteradores son la mejor forma de iterar!


colección
a = Array.new


colección
a = Array.new

Curso Ruby I PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Curso Ruby I PDF

Uploaded by

Copyright:

Available Formats

Lenguaje Ruby y su entorno

Curso de Ruby I: Introducción

Pedro Navajas Modelo

Laboratorio de Software Libre

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 1 / 31

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 2 / 31

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 3 / 31

Un lenguaje de programación interpretado

Posibilidad de llamadas directas al sistema operativo

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 4 / 31

Un lenguaje de programación interpretado

Posibilidad de llamadas directas al sistema operativo

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 4 / 31

Un lenguaje de programación interpretado

Posibilidad de llamadas directas al sistema operativo

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 4 / 31

Un lenguaje de programación orientado a objetos

Todo es un objeto (¡incluso nil!)

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 5 / 31

Un lenguaje de programación orientado a objetos

Todo es un objeto (¡incluso nil!)

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 5 / 31

Un lenguaje de programación orientado a objetos

Todo es un objeto (¡incluso nil!)

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 5 / 31

Un lenguaje de programación orientado a objetos

Todo es un objeto (¡incluso nil!)

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 5 / 31

Un lenguaje de programación dinámico

Son innecesarias las declaraciones de variables

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 6 / 31

Un lenguaje de programación dinámico

Son innecesarias las declaraciones de variables

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 6 / 31

Un lenguaje de programación dinámico

Son innecesarias las declaraciones de variables

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 6 / 31

Un lenguaje de programación dinámico

Son innecesarias las declaraciones de variables

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 6 / 31

Un lenguaje de programación potente y flexible

Enteros de precisión múltiple

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 7 / 31

Un lenguaje de programación potente y flexible

Enteros de precisión múltiple

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 7 / 31

Un lenguaje de programación potente y flexible

Enteros de precisión múltiple

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 7 / 31

Un lenguaje de programación potente y flexible

Enteros de precisión múltiple

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 7 / 31

Un lenguaje de programación potente y flexible

Enteros de precisión múltiple

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 7 / 31

Antes de comenzar con la parte interesante, una última información

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 8 / 31

Antes de comenzar con la parte interesante, una última información

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 8 / 31

Antes de comenzar con la parte interesante, una última información

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 8 / 31

Antes de comenzar con la parte interesante, una última información

Pedro Navajas Modelo (UCO) Curso de Ruby Laboratorio de Software Libre 8 / 31