#Ejemplo de una clase en Ruby:

class HolaMundo
def initialize()
saluda()
end
def saluda()
puts "Hello World"
end
end

#Ejemplo de declaracin e instancia de un objeto
objeto = HolaMundo.new()

#Llamar a un mtodo de una clase:
objeto.saluda

- Comentarios:
#Una linea
=begin
Mas de una lnea
=end

- Las variables en ruby pueden guardar cualquier tipo de dato

- Conversin de tipos de datos:
frmula:
nombreVariable.to_tipoDato
Ej:
hola.to_i
Tipos de datos disponibles (Pueden haber ms):
to_i : Integer
to_f : Float
to_s : String

Ms Estrictos (Para que se comporten como ese tipo de dato):
to_str
to_int

- Alcance de las variables
Globales: Se pueden usar en cualquier parte del codigo
$nombre
Instancia: Se usan dentro de la clase
@nombre
Locales: Disponible dentro del metodo declarado
nombre

- Concatenar variables:
Ej: resultado = 2 + 3
puts "El resultado de 2 + 3 = #{resultado}"

- Sentencia if:
Ejemplo:
edad = 25
if edad < 18
puts "Eres menor de edad"
elsif edad >=60
puts "Eres un viejo ql"
elsif edad == 25
puts "Eres chorizo"
else
puts "Eres mayor de edad"
end

- Operadores lgicos ( not ; and ; or )
not: Invierte el true en false.
Ejemplo:
edad = 8
if not edad > 18
puts "Eres menor"
else
puts "Eres mayor"
end
and: como el && en Java.
or: como el || en Java.

- Sentencia unless:
Es lo contrario al if:
Ejemplo:
edad = 18
unless edad > 18
puts "Eres menor de edad"
end

- Sentencia Case:
Ej:
#Case Normal
case edad
when 0..11 then
print "pequeo"
when 12..17 then
print "Es un adolescente"
when 18..29 then
print "Eres un joven"
when 39 then
print "Eres viejo"
else
print "Error en la variable"
end

#Case con asignacion
respuesta = case edad
when 0..11 then
"pequeo"
when 12..17 then
"Es un adolescente"
when 18..29 then
"Eres un joven"
when 39 then
"Eres viejo"
else
"Error en la variable"
end
print "Case con asignacion: #{edad} \n"
sustantivo = "Codigo Facilito"
#Case con strings
respuesta = case sustantivo
when "Codigo Facilito", "dvxtuts"
then "Comunidades de tutoriales"
when "Facebook", "Twitter"
then "Redes sociales"
end
print "#{respuesta} \n"

- Ciclo For:
break: Cuando se ejecuta se sale del ciclo.
next: Se salta un paso del ciclo
redo: Repite un paso del ciclo
Ej:
for i in(0 .. 9)
if i == 2
#break
#next
#redo
end
print i
print "\n"
end

- Ciclos ( Each ; Upto ; Downto ; Times ):
each: Permite recorrer un rango.
Ej:
(1..10).each { |i| print i }

upto: Permite hacer cuentas sucesivas:
Ej:
1.upto(10) { |i| print i
print "\n" }

downto: Permite hacer cuentas regresivas:
Ej:
10.downto(1) { |i| print i
print "\n" }

times: Siempre empieza en 0 y el valor inicial es la cantidad de veces que se va
a repetir.
Ej:
10.times { |i| print i + 1
print "\n" }

- Ciclos While - Until:
- While Ejemplo:
i = 0
while i < 5 do
print i
i += 1
end

- Do-While ejemplo:
i = 0
begin
print i
i += 1
end while i < 5

- Until ( Viene siendo el contrario al while, o sea mientras que la condicin no
se cumpla se ejecuta ):
i = 0
begin
print i
i += 1
end until i > 5

- Arreglos:
declarar un arreglo:
arreglo = [1, 2, 3]
#print [1,2,3][-1]#Obtener ultimo elemento
#arreglo = [1, 2, 3] << "Nuevo Valor" #Agregar nuevo elemento
#arreglo = [1, 2, 3].push("Nuevo valor") # Agregar nuevo elemento
segunda forma

- Operaciones con arreglos:
Ej:
ejemplo = [1, 2, 3, 4, 5, 6]
#Recorrer Arreglo Forma 1
for i in ejemplo
puts i
end
#Recorrer arreglo forma 2:
ejemplo.each do |i|
puts i
end
#Modifica los resultados de cada arreglo
otro = ejemplo.map { |i| i + 1 }
#Almacenar arreglos que cumplan cierta condicion
otro = ejemplo.select { |numero| numero % 2 == 0 } # Si el resto de
numero es par, se almacena
# |valor|: Nmero capturado
#Eliminar valores del arreglo
otro = ejemplo.delete_if { |numero| numero % 2 == 0}

- Hash (Elementos con una clave asociada que es comnmente una palabra clave):
Ej:
cursos = {'ruby' => 21, 'pag_web' => 15, 'html5' => 15}
#Agregar elementos
cursos['java'] = 30
#Recorrer un hash
cursos.each do |key, value| #key: ndice value: valor
puts "#{key} tiene #{value} videos"
end
#obtener todos los keys (Como un arreglo)
indices = cursos.keys
#obtener todos los valores (Como un arreglo)
valores = cursos.values

- Lambdas (Funciones annimas; las puedes asociar a una variable para que devuelva
alguna wea):
Cuando ejecutes una sola lnea, como esta, usa llaves.
lamb = lambda { |numero| numero + 1 }
Cuando uses ms de una lnea, ejectalo as:
lamb = lambda do |nombre|
if nombre == 'Hola Uriel'
return 'Hola Uriel'
else
retuen 'Hola Anonimo'
end
end
Ej:
#Ejemplo bsico
lamb = lambda {"Hola Mundo"}
puts lamb.call#Llamar al lambda

#Ejemplo con un envo de parmetro
lamb = lambda { |numero| numero + 1 }
puts lamb.call(1)
#Ejemplo ms complejo
lamb = lambda do |nombre|
if nombre == 'Hola Uriel'
return 'Hola Uriel'
else
retuen 'Hola Anonimo'
end
end
#otra forma
puts lambda { "Hola Mundo" }.call

- En ruby se pueden modificar las clases existentes, como la Array, por ejemplo.

- Blocks (Ejecutar un bloque de cdigo por cada elemento que exista):
Ej:
class Array
def iterar
#self arreglo que mand a llamar el mtodo iterar
self.each_with_index do |n, i| #n: nmero #i: indice
self[i] = yield(n)#yield llama a lo que hay en la declaracin
del mtodo, abajo
end
end
end
arreglo = [1, 2, 3]
arreglo.iterar do |n|
n**2 #Esto ejecuta yield
end
Estudiar ms.

- Procedures ( Agrupa bloques y los puedes ejecutar cuantas veces quieras ):
Ej:
class Array
def iterar(bloque)
self.each_with_index do |n, i|
self[i] = bloque.call(n)#Llamar bloque
end
end
end
arreglo = [1, 2, 3]
#Crear Procedimiento
elevarCuadrado = Proc.new do |n|
n**2
end
arreglo.iterar(elevarCuadrado)#Ejecutar mtodo del bloque

- Import en Ruby:
require_relative "nombre_clase.rb"

- Mtodos
1.next: Devuelve el nmero siguiente, en este caso 2.
1.method(''): Llama a cualquier mtodo.
Ej:
siguiente = 1.method("next")
puts siguiente.call

Por convencin, es mejor que vaya con minsculas y sin espacios.

nombreObjeto.nombreMetodo.class: Devuelve el estado de un objeto. Por
ejemplo, si el mtodo retorna algn dato, esta deficin retornara el tipo de dato del
retorno del mtodo.

La definicin de parmetros y el retorno de valores es igual que en java, slo
que se define el nombre de la variable y el return sin ;

Estructura mtodo:
def name
end

- Parmetros:
#Definir parmetros
=begin
def suma(uno, dos, tres = 0)
return uno + dos + tres
end
puts suma(1, 2, 3)#Aun con la definicin de 0, pasa el parmetro
=end

=begin
#*nombre: Se pueden pasar una infinidad de parmetros
def suma(*numeros)
sumaT = 0
for i in numeros
sumaT += i
end
return sumaT
end
puts suma(1,23,4,5,5,6,5,6,7,8)
=end

=begin
#Otra forma para los mtodos
def calculadora(uno,dos,tres = 0, opciones = {})
if opciones['suma'] == 1
return 1 + 2 + 3
elsif opciones['multiplica'] == 1
return 1 * 2 * 3
end
end
numeros = [2,3,1]
opc = {"multiplica" => 1}
puts calculadora(*numeros, opc)
=end

- Constructor:
- En ruby se puede definir un slo constructor, a diferencia de otros lenguajes
como Java.
Ej:
def initialize(nombre = "Sin nombre", raza = "Sin Raza")
@nombre = nombre
@raza = raza
end

- Hay tres tipos de alcances en los mtodos:
public: lo puede llamar cualquiera.
private: Llamados slo desde la clase.
protected: Llamados dentro de la clase, y otros objetos de la misma
clase, como por ejemplo otro objeto de la misma clase.

Ej:
private
def getRaza()
return @raza
end

- Mtodos Anidados (Dentro de un mtodo defininimos otros mtodos):
- La nica forma de llamar mtodos anidados, es llamar primero al mtodo en
donde los defines.
- Los vas a usar cuando tengas que calcular una coordenada y, sin antes llamar
a una coordenada x.
Ej:
class X
def initialize()
end
def x
puts "X"
def y
puts "Y"
end
def z
puts "Z"
end
end
end
obj = X.new()
obj.x
obj.y

- Mtodos Singleton (Se asignan a un objeto, y son nicos para aquel):
Los usas cuando tienes interfaces, cuando presionas un botn y creas un
evento.
Ej:
dog = Perro.new('Firulais', 'Chihuahua')
def dog.hablar
return "Hola Humano"
end
dog.hablar

- Clases Singleton:
Se usa cuando quieres tener un objeto especial, por ejemplo un perro especial.
Creas una clase singleton, todos los mtodos se aaden como singleton.
Ej:
dog = Perro.new()
dog2 = Perro.new()
class << dog
def hablar
return "Hola humano"
end
end
puts dog.hablar
#Condicional para comprobar si hay mtodos singleton
if dog2.respond_to?(:hablar) then
puts dog.hablar
else
puts "Este perro no sabe hablar"
end

- Excepciones:
Estructura:
begin #Try Java
#Codigo
rescue => err #Catch Java
err.message
#codigo
ensure # Finally Java
#codigo
end
EJ:
#Estructura bsica manejo de excepciones
begin
1/0
rescue Exception => err
puts err.message
end
#Crear tus propios manejos de excepciones, con una funcin
def verdadero(valor)#Siempre el valor recibido ser true
#archivo = File.open("") #Abrir un archivo
raise TypeError, 'Tienes que mandar un valor verdadero' if valor
== false
rescue => err
puts err.message
ensure
#archivo.close()
#puts "Slo me aseguro de cerrar el archivo"
end

- Mtodos Accesadores:
- Getter y setter en Java.
Cmo definirlos:
#forma1
def nombre()
return @nombre
end

def nombre=(par)
@nombre = par
end

#Forma 2
attr_accessor :nombre #Crea el accesador y el mutador del
atributo

- Herencia:
Ejemplo de clase:
class Mamifero
def initialize()
puts "Ha nacido un nuevo mamifero"
end
def respirar
puts "ssss ssss"
end
end

class Perro < Mamifero
def initialize(nombre = "Sin nombre", raza = "Sin raza")
super()#Llamar al constructor de la clase padre
@nombre = nombre
@raza = raza
end
def ladrar
puts "Guau, guau"
end
attr_accessor :nombre
end

- Sobreescritura de mtodos:
Programacin diferencias -> De lo ms general a los ms especfico
Polimorfismo: El mismo mtodo se comporta de distinta forma, segn el objeto
creado.
En ruby no existe la sobrecarga de parmetros, porque se pueden mandar
arreglos, hash como parmetros haciendo el manejo an ms fcil.
Ej:
class Mamifero
def initialize()
puts "Ha nacido un nuevo mamifero"
end
def respirar
puts "ssss ssss"
end
def hacer_ruido
return "sss"
end
end
class Perro < Mamifero
def initialize(nombre = "Sin nombre", raza = "Sin raza")
super()#Llamar al constructor de la clase padre
@nombre = nombre
@raza = raza
end
def hacer_ruido
#return super Llama al mtodo en la clase padre
return super << " woaf!!"#le agrega esta cadena al retorno
de hacer_rudio del padre
end
attr_accessor :nombre
end
class Gato < Mamifero
def initialize(nombre = "sin nombre")
@nombre = nombre
end
def hacer_ruido
return super << " Miaw!!!"
end
end

- Herencia Mltiple:
Para paliar los problemas que tiene la herencia mltiple, Ruby nos ofrece un
concepto que son los mdulos, que son como las clases, sin embargo tiene sus
diferencias, como por ejemplo en las clases podemos tener muchos objeto de una
clase, tambin podemos crear herencia.
En cambio no podemos crear un objeto de un mdulo y ni aplicar herencia.
Ej:
#Los modulos deben de ir primero
module Carnivoro
def comer(comida)
raise "los carnivoros solo comen carne" unless
comida.kind_of?(Conejo)
puts "Estoy comiendo carne"
end
end

module Herviboro
def comer(comida)
raise "los herviboros solo comen hierba" unless
comida.kind_of?(Hierba)
puts "Estoy comiendo pasto"
end
end

module Mamifero
def respirar
return "sss sss"
end
end

class Hierba
end
class Conejo
include Mamifero#Ejemplo de un mdulo
include Herviboro
end
class Leon
include Mamifero
include Carnivoro
end