NORMAS EN LAS PALABRAS

Un nombre es una letra mayúscula, una letra minúscula o un guión bajo, seguido
por cualquier combinación de mayúsculas, minúsculas, números o guiones bajos.
Los nombres en Ruby se usan para referirse a constantes, variables, métodos,
clases y módulos. La primera letra de un nombre ayuda a Ruby a distinguirlos.
Algunos nombres, son palabras reservadas y no pueden usarse como variable,
método, clase o módulo. El conjunto de las minúsculas abarca de la 'a' a la 'z'
incluyendo el guión bajo '_'. El conjunto de las mayúsculas abarca de la 'A' a la 'Z'
y los números (del '0' al '9').
VARIABLES
Las variables contienen cualquier tipo de dato. El propio nombre de la variable,
muestra su alcance (local, global,…):

• Una variable local consiste en una letra minúscula o guión bajo seguido de
cualquier mayúscula o minúscula. P.ej.: sunil, _z, rock_and_roll

• Una variable de un objeto (más adelante se hablará de clases y objetos)

empieza con la arroba, seguido de cualquier mayúscula o minúscula. P.ej.:
@sign, @_, @Counter
• Una variable de clase empieza con dos arrobas seguido por cualquier
mayúscula o minúscula. P.ej: @@signo, @@_, @@Counter
• Una variable global empieza por el signo dólar, seguido por cualquier
carácter(no sólo mayúsculas o minúsculas). P.ej: $counter, $COUNTER, $-
x.

CONSTANTES
Una constante empieza por una letra mayúscula, seguido por cualquier mayúscula
o minúscula. Los nombres de clases y de módulos son constantes, y siguen unas
normas. Ejemplos: module MyMath, PI=3.1416, class Perro.
Los nombres de métodos deben empezar por una minúscula (letra o guión bajo).
La ? y la ! son los únicos caracteres ajenos al grupos de las mayúsculas y
minúsculas, que se permiten como sufijos de los métodos. Más adelante se
explicará su uso.
Por norma, se usa el guión bajo para separar palabras compuestas en los
nombres de métodos y de variables. Para los nombres de clases, módulos y
constantes, la norma dice de usar letras mayúsculas en vez de guiones bajos,
para distinguirlas. Ejemplos:
variables y métodos: real_madrid, futbol_club_barcelona
clases, módulos y constantes: RealMadrid, FutbolClubBarcelona
Hay que notar que una variable puede referirse a distintos valores a lo largo del
tiempo. Una constante en Ruby puede ser una referencia a un objeto. Las
constantes son creadas en el momento de su primera asignación, normalmente en
la definición de una clase o un módulo; no deben estar definidas en los métodos.
Se puede variar el valor de una constante, pero esto genera un valor de aviso.

ALCANCE DE LAS CONSTANTES

Las constantes definidas dentro de una clase o módulo pueden ser usadas en
cualquier lugar dentro de la clase o módulo.
Fuera de la clase o módulo, se pueden usar mediante el opoerador :: precedido de
una palabra que indique el módulo o clase apropiados.
Las constantes definidas fuera de cualquier clase o módulo pueden ser usadas
mediante el operador :: pero sin palabra que lo preceda.
Las constantes no pueden ser definidas dentro de un método.

ESCRIBIENDO MÉTODOS
Un bloque de instrucciones que define un método, empieza por la palabra def y
acaba por la end. Los parámetros son la lista de variables que van entre
paréntesis. Aunque en Ruby, dichos paréntesis son opcionales: puts, p y gets son
muy usados, y por ello que el uso de paréntesis sea opcional. En Rails, se llama a
los métodos sin paréntesis.
Un método devuelve el valor de su última línea. Por norma, es recomendable dejar
una línea en blanco entre las definiciones de métodos:
#metodos.rb

# Definición de un método
def hello
puts 'Hola'
end
#uso del método
hello

# Método con un argumento

def hello1(nombre)
puts 'Hola ' + nombre
return 'correcto'
end
puts(hello1('Pedro'))

# Método con un argumento (sin paréntesis, no funciona en versiones nuevas)

def hello2 nombre2
puts 'Hola ' + nombre
return 'correcto'
end
puts(hello2 'Juan')
Esto es lo que obtenemos
>ruby metodos.rb
Hola
Hola Pedro
correcto
Hola Juan
correcto
metodos.rb:18 warning: parenthesize argument(s) for future version
>Exit code: 0

LOS MÉTODOS BANG (!)

Los métodos que acaban con una ! son métodos que modifican al objeto. Por lo
tanto, estos métodos son considerados como peligrosos, y existen métodos
iguales, pero sin el !. Por su peligrosidad, el nombre "bang". Ejemplo:
a = "En una lugar de la mancha"

#método sin bang: el objeto no se modifica

b = a.upcase
puts b
puts a

#método con bang: el objeto se modifica

c = a.upcase!
puts c
puts a
Normalmente, por cada método con !, existe el mismo método sin !. Aquellos sin
bang, nos dan el mismo resultado, pero sin modificar el objeto (en este caso el
string).

ALIAS
alias nuevo_nombre nombre_original
alias crea un nuevo nombre que se refiere a un método existente. Cuando a un
método se le pone un alias, el nuevo nombre se refiere al método original: si el
método se cambia, el nuevo nombre seguirá invocando el original.
def viejo_metodo
"viejo metodo"
end
alias nuevo_metodo viejo_metodo
def viejo_metodo
"viejo metodo mejorado"
end
puts viejo_metodo
puts nuevo_metodo
En el resultado, vemos como nuevo_metodo hace referencia al viejo_metodo sin
modficar:
viejo metodo mejorado
viejo metodo

RANGOS
El principal uso y quizás el más apropiado para los rangos, es expresar una
secuencia: las secuencias tienen un punto inicial y un punto final, y una forma de
producir los sucesivos valores entre ambos. En Ruby, esas secuencias son
creadas usando los operandos .. y …
.. genera una secuencia donde los puntos límites están incluidos.
(1..3).to_a

#es la secuencia 1, 2, 3
…* genera una secuencia en la que no está incluida el límite superior.
(1...5).to_a

#equivale a 1, 2, 3, 4
En Ruby los rangos no son almacenados como una lista: los rangos se almacenan
como un objeto Range, y contiene referencias a dos objetos Fixnum (su límite
superior e inferior). Se puede convertir un rango en un array ( array = lista,
conjunto ordenado de elementos), mediante el método to_a.
(1..10).to_a

#obtenemos [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

MÉTODOS
Los rangos en ruby tienen diversos métodos:
nums = -1...9
puts nums.include?(5) # true
puts nums.min # -1
puts nums.max #9
puts nums.reject {|i| i < 5} # [5, 6, 7, 8, 9]
Uno de los usos útiles de los rangos, es comprobar si un determinado valor está
en el intervalo representado por el rango. Para eso usamos el operador ===
(1..10) === 5 # true
(1..10) === 15 # false
(1..10) === 3.14159 # true
('a'..'j') === 'c' # true
Un array puede ser un conjunto de elementos distintos:
=begin
un array cuyos elementos
apuntan a otros tres objetos:
un decimal, un string y un array
=end
sabor = 'mango'
vec4 = [80.5, sabor, [true, false]]
puts vec4[2]

USANDO %W
Algunas veces, crear arrays de palabras puede ser tedioso debido a tantas
comillas y comas. Afortunadamente, Ruby tiene una forma más cómoda para
hacerlo:
nombres1 = [ 'ann', 'richard', 'william', 'susan', 'pat' ]
puts nombres1[0] # ann
puts nombres1[3] # susan

# esto es más sencillo y más rápido:

nombres2 = %w{ ann richard william susan pat }
puts nombres2[0] # ann
puts nombres2[3] # susan
El método each
El método each extrae cada elemento del array dentro de la variable que se le
especifique (que irá entra dos barras | |), que se usará en bloque do…end.
ciudades = %w{ Pune Mumbai Bangalore }
ciudades.each do |ciudad|
puts '¡Me gusta ' + ciudad + '!'
puts '¿A ti no?'
end

#El método {{**delete**}} borra un elemento

ciudades.delete('Mumbai')
ciudades.each do |ciudad|
puts '¡Me gustaba '+ciudad+'!'
puts '¿A ti ya no?'
end
Por lo tanto el método each nos permite hacer una cosa (la que sea) con cada
objeto del array. En el ejemplo, fuimos elemento por elemento del array sin usar
los índices. Hay que destacar:
Los variable entre los "postes" se refiere a cada ítem del array a medida que
avanzamos en el loop. Se puede usar cualquier nombre, pero es mejor dotarlo de
cierto significado.
El do…end identifica el bloque de código que se ejecutará con cada elemento del
array. Los bloques son usados intensivamente en Ruby, y se tratarán en
profundidad más adelante.
Un bloque es una porción de código encerrada entre paréntesis {} o entre do…
end. Por lo tanto, un bloque es una forma de agrupar instrucciones, y solo puede
aparecer después de usar un método: el bloque empieza en la misma línea que
usa el método. El código dentro del bloque no es ejectuado en el instante que el
intérprete de Ruby lo encuentra: Ruby se recordará del bloque (variables locales,
…) y después entra en el método, ejecutando el bloque cuando es preciso.
Supongamos que existen dos métodos llamados greet1 y greet2:
#greet1, no necesita argumentos
greet1 {puts 'Hola'}

#greet2, necesita un argumento

greet2 ("argumento_cualquiera") {puts 'Hola'}
Lo usual es usar los paréntesis para bloques de una línea y el do…end para más
de una línea.
YIELD
Un método puede usar el bloque mediante la palabra yield:
def metodo
puts 'Comienzo del metodo'
yield
yield
puts 'Final del metodo'
end

metodo{puts 'Dentro del bloque'}

La salida es:
'Comienzo del metodo'
'Dentro del bloque' # primer yield
'Dentro del bloque' # segundo yield
'Final del metodo'
Lo que sucede es que en el momento que el intérprete llega al yield, se ejecuta el
código dentro del bloque, y luego se retorna al método.

ARGUMENTOS EN LOS BLOQUES

En los bloques se pueden usar argumentos especificándolos dentro de dos barras
verticales | |. Y si se usan, en el yield no podemos olvidar darles valor:
def metodo
yield('hola', 99)
end

metodo{|str,num| puts str + ' ' + num.to_s} #hola 99

Un bloque de código devuelve un valor: el valor de la última expresión evaluada. Y
este valor devuelto por yield, puede usarse dentro del método que invoca el
bloque.
Condicionales y bucles

En Ruby, nil y false significan falso, todo lo demás (incluyendo true, 0) significan
verdadero. En Ruby, nil es un objeto: por tanto, tiene sus métodos, y lo que es
más, puedes añadir los métodos que se quieran.

Ejemplo de if,else:
xyz = 5
if xyz > 4
puts 'La variable xyz es mayor que 4'
puts 'Puedo poner más instrucciones dentro del if'
if xyz == 5
puts 'Se puede anidar un bloque if,else,end dentro de otro'
else
puts "Parte del bloque anidado"
end
else
puts 'La variable xyz no es mayor que 5'
puts 'También puedo poner múltiples sentencias'
end

ELSIF
else se ejecutaba si la condición en if no se cumplía. Para poder tomar más
decisiones, en función del valor de la variable, se usa elsif:
#usando if,else anidados

puts 'Hola, cuál es tu nombre?'

STDOUT.flush
nombre = gets.chomp
puts 'Hola, ' + nombre + '.'

if nombre == 'Mojamuto'
puts 'Pedazo de nombre!!!'
else
if name == 'Enjuto'
puts '...este nombre no es moco de pavo...'
end
end
#usando elsif

puts 'Hola, cuál es tu nombre?'

STDOUT.flush
nombre = gets.chomp
puts 'Hola, ' + nombre + '.'

if nombre == 'Mojamuto'
puts 'Pedazo de nombre!!!'
elsif nombre == 'Enjuto'
puts '...este nombre no es moco de pavo...'
end
#otra modificación, usando el || ("o" lógico)

puts 'Hola, cuál es tu nombre?'

STDOUT.flush
nombre = gets.chomp
puts 'Hola, ' + nombre + '.'

if nombre = 'Mojamuto' || 'Enjuto'

puts 'Pedazo de nombre!!!'
end

CASE
Esta instrucción es muy parecida al if: se crean una serie de condiciones, y se
ejecuta la primera condición que se cumpla. Por ejemplo:
xyz = 10

if xyz % 2 == 0
puts 'La variable xyz es par'
else
puts 'La variable xyz es impar'
end
es equivalente a:
xyz = 10

par = case
when xyz % 2 == 0: true
when xyz % 2 != 0: false
end

puts par
unless
Ruby tiene una forma contraria al if: la instrucción unless. Y digo contraria, por
que en if se ejecutaba el bloque (do … end) si se cumplía la condición; con unless
se ejecutará el bloque mientras NO se cumpla.
nombre = 'Pepe'
unless nombre == 'Enjuto'
puts 'Ese nombre no tiene arte ninguno'
end

=begin
Si el nombre no es Enjuto,
siempre se ejecutará el bloque.
=end

WHILE
Se pueden hacer bucles (bucle = algo que se repite) con la instrucción while:
# Loops
var = 0
while var < 10
puts var.to_s
var += 1
end

TIMES
Este es un ejemplo de cómo en Ruby es todo un objeto, inclusive los números. El
método times necesita dos cosas:
• un número entero, del cuál es el método
• un bloque
Lo que hace times es iterar el bloque ese "número" de veces.
10.times do |num|
puts num
end
Fijarse, que la variable num va de 0 a 9; por lo tanto, el bloque se itera 10 veces.
Ruby tiene con un generador de números aleatores: el método rand. Usando rand
se obtiene un número aleatorio x, tal que 0 <= x < 1. Si se le dá un parámetro, por
ejemplo rand(5), entonces 0 <= x < 5.
def carta_aleatoria
palos = %w{ corazones treboles picas diamantes}
numero = %w{ 1 2 3 4 5 6 7 8 9 10 J Q K }

#Quiero una carta aleatoria que tiene:

# -un palo aleatorio
# -un número aleatorio

#palo aleatorio
num = palos.length
palo_aleat = rand(num)

#numero aleatorio
num_aleat = rand(numero.length)

puts numero[num_aleat] + ' de ' + palos[palo_aleat]

end

#una carta aleatoria

carta_aleatoria

#10 cartas aleatorias

10.times do
carta_aleatoria
end

#NOTA: la variable del bucle,

#como no su usa en el bloque
#no se define.

CONTROL DE ACCESO Y ACCESORES

En Ruby, la única forma de cambiar el estado de un objeto, es invocando uno de
sus métodos: si controlas el acceso a laso métodos, controlarás el acceso a los
objetos. Una buena regla, es cerrar el acceso a los métodos que puedan dejar al
objeto en un estado no válido.
LOS TRES NIVELES DE ACCESO
public - los métodos públicos (public) pueden ser usados por cualquiera; no hay
un control de acceso.
protected - los métodos protegidos (protected) pueden ser usados únicamente
por objetos de la misma clase y subclases, a las que pertenece el método; pero
nunca por el propio objeto. Por así decirlo, el método sólo lo pueden usar los otros
miembro de la familia.
private - los métodos privados (private) sólo pueden ser usado por el propio
objeto. Técnicamente, se dice que el receptor del método siempre es el mismo:
self.
El control de acceso se determina dinámicamente, a medida que el programa
transcurre. Se obtiene una violación de acceso siempre que se intenta ejecutar un
método no público.
class ControlAcceso
def m1 # este método es público
end
protected
def m2 # este método es protegido
end
private
def m3 # este método es privado
end
 def m4
end
end

ca = ControlAcceso.new
ca.m1
ca.m2
ca.m3
La privacidad de los métodos, también se pueden especificar de esta forma:
class ControlAcceso
def m1 # este método es público
end
def m2 # este método es protegido
end
def m3 # este método es privado
end
def m4 # este método es privado
public :m1
protected :m2
private :m3, :m4
end

ca = ControlAcceso.new
ca.m1
ca.m2
ca.m3
PROTECTED
Tal vez el nivel de acceso protegido (protected) sea un poco lioso de entender. Es
mejor verlo con un ejemplo:
class Persona
def initialize(edad)
@edad = edad
end
def edad
@edad
end
def comparar_edad(op) # op = otra persona
if op.edad > edad
'La edad de la otra persona es mayor.'
else
'La edad de la otra persona es la misma o menor.'
end
end
protected :edad
end
pedro = Persona.new(15)
almudena = Persona.new(17)
puts Pedro.comparar_edad(almudena) # La edad ... es mayor
El objeto que hace la comparación (pedro) necesita preguntar al otro objeto
(almudena) su edad, lo que significa que ejecute su método edad. Por eso el nivel
de acceso es protegido y no privado: al estar protegido "pedro" puede usar el
método de "almudena".
La excepción viene cuando "pedro" se pregunta a sí mismo la edad, por ser un
método protegido, esto no será posible. self no puede ser el receptor de un
método protegido.

MANEJANDO UNA EXCEPCIÓN

Para tratar una excepción, se pone el método que puede causar el error dentro de
un bloque begin…end. Dentro de este bloque, se pueden poner varios rescue
para cada tipo de error que pueda surgir:
def raise_and_rescue
begin
puts 'Estoy antes del raise'
raise 'Un error ha ocurrido' # simulamos un error
puts 'Estoy después del raise'
rescue
puts 'Estoy rescatado del error.'
end
puts 'Estoy después del bloque'
end

raise_and_rescue
La salida es:
Estoy antes del raise
Estoy rescatado del error.
Estoy después del bloque
Observar que el código interrumpido por la excepción, nunca se ejecuta. Una vez
que la excepción es manejada (por el rescue), la ejecución continúa
inmediatamente después del bloque begin fuente del error.
Al escribir rescue sin parámetros, el parámetro StandardError se toma por defecto.
En cada rescue se pueden poner varias excepciones a tratar. En el caso de poner
múltiples rescues:
begin
#
rescue UnTipoDeExcepcion
#
rescue OtroTipoDeExcepcion
#
else
# Otras excepciones
end
Ruby compara la excepción que produce el error, con cada rescue hasta que sea
del mismo tipo; o sea una superclase de la excepción. Si la excepción no
concuerda con ningún rescue, usar else se encarga de manejarla.
Para saber acerca del tipo de excepción, hay que mapear el objeto Exception a
una variable usando rescue:
begin
raise 'Test de excepcion'
rescue Exception => e
puts e.message # Test de excepción
puts e.backtrace.inspect # ["nombre de fichero:linea de la excepción"]
end
Si además de manejar la excepción, se necesita que se ejecute un código, se
usará la instrucción ensure: lo que haya en ese bloque, siempre se ejecutará
cuando el bloque begin…end termine.