Programación en Ruby/Estructuras de decisión e iteración

Estructuras Simples

En Ruby, sólo nil y false son evaluados como falso, todo lo demás (incluyendo 0), es verdadero. En Ruby nil es un objeto. Puedes agregar métodos a nil como a cualquier otro objeto y puedes llamar los métodos de nil como los de cualquier otro objeto. Vamos a explorar algunas estructuras muy simples disponibles en Ruby. El ejemplo que sigue (p014estructuras.rb) muestra la estructura if else end. Es costumbre en ruby no poner paréntesis con if y while.

1 #En Ruby, nil y false son evaluados como falso
2 #todo lo demas (incluyendo 0) es verdadero.
3 # nil es un objeto
4 # if else end
5 var = 5
6 if var > 4
7   puts "La variable es mayor que 4"
8   puts "Puedo tener muchas declaraciones aqui"
9   if var == 5
10     puts "Es posible tener if y else anidados"
11   else
12     puts "Too cool"
13   end
14 else
15   puts "La variable no es mayor que 4"
16   puts "Puedo tener muchas declaraciones aqui"
17 end
18 
19 # Loops
20 var = 0
21 while var < 10
22   puts var.to_s
23   var += 1
24 end

Un ejemplo del uso de elsif está en el programa p015elsif.rb :

1 # ejemplo del uso de elsif 
2 
3 # Ejemplo original
4 puts "Hola, cual es tu nombre?"
5 STDOUT.flush
6 nombre = gets.chomp
7 puts 'Hola, ' + nombre + '.'
8 
9 if nombre == 'Juan'
10         puts 'Que bonito nombre!!'
11 else
12         if nombre == 'Ivan'
13                 puts 'Ivan es Juan en ruso!!'
14         end
15 end
16 
17 # Ejemplo modificado usando elsif
18 puts "Hola, cual es tu nombre?"
19 STDOUT.flush
20 nombre = gets.chomp
21 puts 'Hola, ' + nombre + '.'
22 
23 if nombre == 'Juan'
24         puts 'Que bonito nombre!!'
25 elsif nombre == 'Ivan'
26         puts 'Ivan es Juan en ruso!!'
27 end
28 
29 # Otra modificacion
30 puts "Hola, cual es tu nombre?"
31 STDOUT.flush
32 nombre = gets.chomp
33 puts 'Hola, ' + nombre + '.'
34 
35 # || es el operador logico 'o'
36 if nombre == 'Juan' || nombre == 'Ivan'
37         puts 'Que bonito nombre!!'
38 end

Algunos operadores condicionales comunes son: ==, != <=, >=, <, > Ruby tiene también una forma negativa de if. La estructura unless comienza con la palabra unless y termina con end. El cuerpo es el texto que aparece en medio de las dos. A menos que la expresión que continúe a la palabra unless sea verdadera, el cuerpo es ejecutado, de lo contrario el intérprete lo ignora.

1 unless ARGV.length == 2
2   puts "Usage: program.rb 23 45"
3   exit
4 end

En el programa anterior, el cuerpo es ejecutado a menos que el número de elementos en el array sea igual a 2. El método Kernel.exit termina el programa, regresando un valor de status al sistema operativo. Loops como while están disponibles. Observa el siguiente ejemplo:

1 #Loops
2 
3 var = 0
4 while var < 10
5   puts var.to_s
6   var += 1
7 end

1.Escribe un programa (p016bisiesto.rb) que pregunte al usuario un año cualquiera y determine si es bisiesto o no. 2.Escribe un método llamado bisiesto que acepte un año, determine si es bisiesto y calcule el número total de minutos para ese año. (p017metodobisiesto)

Para determinar si un año es bisiesto: 1.Si el año es divisible ente 4, ve al paso 2. Si no, ve al paso 5. 2.Si el año es divisible ente 100, ve al paso 4. Si no, ve al paso 5. 3.Si el año es divisible ente 400, ve al paso 4. Si no, ve al paso 5. 4.El año es bisiesto. (Tiene 366 días). 5.El año no es bisiesto. (Tiene 365 días).

Expresiones case Esta estructura funciona de manera muy similar a una serie de expresiones if: te permite enumerar una serie de condiciones y ejecutar una expresión que corresponda al primer valor que sea verdadero. Por ejemplo, los años bisiestos deben ser divisibles entre 400 o entre 4 y no entre 100. Ten presente que case regresa el valor de la última expresión ejecutada.

1 year = 2000
2 
3 leap = case 
4        when year % 400 == 0: true
5        when year % 100 == 0: false
6        else year % 4 == 0
7        end
8 
9 puts leap
10 
11 #el resultado es: true