Taller ruby

Ruby

¿Quién soy?

Juan Vázquez MurgaSoftware Analyst & Web Developer

[email protected]@jnillo9

mailto:[email protected]

Juan Vázquez MurgaSoftware Analyst & Web Developer

[email protected]@jnillo9

¡Ruby Developer!

mailto:[email protected]

Bibliografía Recomendada

Bibliografía

● Libros:

- The Ruby Programming Language

- Design Patterns in Ruby

- Programming Ruby: The Pragmatic Programmer's Guide

● Webs:

– www.apidoc.com

– www.lang-ruby.org

– www.stackoverflow.com, github.com (gist)....

http://www.lang-ruby.org/

¿Qué vamos a ver?

1) Introducción al lenguaje

Índice


2) Vistazo al entorno: terminal, IDE, ...


2) Vistazo al entorno: terminal, IDE, …

3) Conceptos Básicos: variables, funciones...




4) OOP: clases, módulos, mixins...





5) Bloques, Procs y Lambda






6) Manejo de hilos






6) Manejo de hilos

7) ¡Manos a la obra!

Introducción al lenguaje: Ruby

Yukihiro Matsumoto


Yukihiro Matsumoto

Perl + Smaltalk + Eiffel + Ada + Lisp


Yukihiro Matsumoto


Ruby(1995)


Yukihiro Matsumoto


Ruby(1995)

-> Multiparadígma + Interpretado + Dinámico + Tipado


Yukihiro Matsumoto


Ruby(1995)

-> Multiparadígma + Interpretado + Dinámico + Tipado

“Pretende ser un lenguaje natural, no sencillo”

El Entorno de Ruby

1) Instalación:– Simple → instalación como paquete del sistema

El Entorno de Ruby


– RVM → gestor de entornos Ruby

El Entorno de Ruby



2) Ejecución:– Irb → consola de Ruby

El Entorno de Ruby




– Scripts → *.rb

El Entorno de Ruby





– Entornos Web → Ruby on Rails

El Entorno de Ruby






3) Herramientas: ¿IDE o no IDE? – Radrails, RubyGem, Netbeans,...

El Entorno de Ruby






3) Herramientas: ¿IDE o no IDE? – Radrails, RubyGem, Netbeans,...

– ¡¡VIM!!

Conceptos Básicos

1) Variables

Conceptos Básicos

1) Variables x = “hola” # String

x = 2 # Integerx = [] # Arrayx = {} # Hash…..

Conceptos Básicos


x = 2 # Integerx = [] # Arrayx = {} # Hash…..## Declaración explicita:

x = Array.new() # Array []x = Hash.new() # Hash {}

Conceptos Básicos




## Inicializaciones:

x = Array.new(1) # ??

Conceptos Básicos





x = Array.new(1) # [nil]x = Array.new(1,1) # ??

Conceptos Básicos





x = Array.new(1) # [nil]x = Array.new(1,1) # [1]

Conceptos Básicos

2) Funciones

Conceptos Básicos

2) Funciones - Estructura:

def [nombre de la función] ([lista de parámetros]) ….. end

Conceptos Básicos



- Ejemplo:

def par? (x) x%2==0 end

Conceptos Básicos



- Ejemplo:

def par? (x) x%2==0 end

Y el Return???

Conceptos Básicos

3) Búcles: - Tenemos:

Conceptos Básicos


While [bool-exp] do ---end

Conceptos Básicos


while [bool-exp] do ---end

for [VAR] in [Array] do ---end

Conceptos Básicos




[Exp].each do [|Var|] ---end

Conceptos Básicos





[Integer].times do ---end

Conceptos Básicos





[Integer].times do ---end

loop do ….end

Conceptos Básicos

4) Condicionales: - Tenemos:

Conceptos Básicos


if [bool-exp] do ---end

Conceptos Básicos



if [bool-exp] do …else …end

Conceptos Básicos




unless [bool-exp] do ---end

Conceptos Básicos




unless [bool-exp] do ---end

[exp]? Ac1 : Ac2

[Action] if [Exp]...

¿Pocos conceptos básico?

www.apidock.com

OOP: clases, módulos y mixin

OOP: clases, módulos y mixins

1) Clases: - Declaración:

class [Nombre_clase] ... end

- Ejemplo: class Coche # Declaración de atributos y acesos def initialize([parametros]) #Incializamos atributos de instancia y de clase end end


1) Clases: - Ejemplo:

class Coche @@coches = 0 # Atributos de clase

RUEDAS = 4 # Constantes

attr_accessor :color,:modelo # Acceso a atributos

def initialize(color, modelo) @color = color @modelo = modelo @@coches += 1 end …

end


2) Módulos: - Declaración:

module [NombreModelo] … end

- Ejemplo:

module Acciones def cambiar_rueda puts “rueda cambiada con éxito!!” end

end


2) Módulos: - Ejemplo:

module Acciones MAX_REP = 3 def cambiar_rueda puts “rueda cambiada con éxito!!” end

def self.hola puts “hola estoy es un modulo” end

end


3) Mixin: - ¿Qué es?:



Class

SuperClass

Herencia Simple



Class

SuperClass

¡¡¡MIXIN!!!

} Include OR extends

module 1

module 2

module N

.

.

.

Herencia Simple

Block, Proc y Lambda

Bloques, Proc y Lambda

1) Bloques: - ¿Qué es?:Piezas de código que se manejan como variables. Ej.-

class Klase def metodo_1(&block) #Pasamos por parámetros el bloque block.call end end

k = Klase.new k.method_1 do p “Hola a todos” end


2) Proc: - ¿Qué es?:Piezas de código que se almacenan en variables. Ej.-

class Klase def metodo_1(proc) #Pasamos por parámetros el Proc proc.call end end

k = Klase.new proc = Proc.new{ p “Hola a todos” } k.method_1 proc


3) Lambda: - ¿Qué es?:Piezas de código que se almacenan en variables. Ej.-

class Klase def metodo_1(proc) #Pasamos por parámetros el Proc proc.call end end

k = Klase.new proc = Proc.new{ p “Hola a todos” } k.method_1 proc


Block Vs Proc:

- Block piezas de código que puedes hacer paso por referencia.

- Su almacenamiento es efímero.

- Proc permite almacenar piezas de código en variables.- Usarse múltiples veces.

- Pasar como parámetros a métodos y funciones.


Proc Vs Lambda: - Proc no comprueba el numero de parámetros de

entrada. Lambda si comprueba parámetros de entrada.

p = Proc.new{|a, b, c| puts “El valor de a es #{a} y b es #{b} y c es #{c.class}"}

p.call (4,5) # El valor de a es 4 y b es 5 y c NilClass

l = lambda{|a, b, c| puts "Parametro #{a} y a #{b} y a #{c.class}"}

l.call (4,5) # ArgumentError: wrong number of arguments (2 for 3)...


Proc Vs Lambda: - Lambda tiene “mini-returns” y el return en un Proc es

“definitivo”.

def lambda_return lambda { return "lambda" }.call return "lambda_return método"end

# lambda_return método

def proc_return Proc.new { return "Proc.new"}.call return "proc_return metodo" end

# Proc.new


Proc Vs Lambda: - Proc no devuelve valores y Lambda si puede devolver

valores por que actúa como método.

def generic_return(code) one, two = 1, 2 three, four = code.call(one, two) return "Give me a #{three} and a #{four}"end

puts generic_return(lambda { |x, y| return x + 2, y + 2 })puts generic_return(Proc.new { |x, y| return x + 2, y + 2 })puts generic_return(Proc.new { |x, y| x + 2; y + 2 })puts generic_return(Proc.new { |x, y| [x + 2, y + 2] })

# => Give me a 3 and a 4# => *.rb:X: unexpected return (LocalJumpError)# => Give me a 4 and a # => Give me a 3 and a 4

Manejo de hilos

Manejo de hilos

Declaración:

th = Thread.new([Parámetros]) { [|Parámetros|]

… }

Manejo de hilos

Declaración:


… }

Ejecución:

th.join # Ejecutamos el código almacenado en este hilo

Variables de hilos:

Thread.current['variable'] # 'variable' es una variable almacenada

# en el hilo actual.

Manejo de hilos

Declaración:


… }

Ejecución:

th.join # Ejecutamos el código almacenado en este hilo

Variables de hilos:

Thread.current['variable'] # 'variable' es una variable almacenada

# en el hilo actual.

Métodos interesantes:

Thread.list # Listado de hilos creados

Thread::kill # Elimina un hilo.

Manejo de hilos

Ejemplo:count = 0

arr = []

10.times do |i|

arr[i] = Thread.new {

sleep(rand(0)/10.0)

Thread.current["mycount"] = count

count += 1

}

end

arr.each {|t| t.join; print t["mycount"], ", " }

puts "count = #{count}"

Manos a la obra!!!

Technology

Taller ruby