Control de Flujo

## Objetivos de Aprendizaje - Usar sentencias condicionales (if, unless, case) - Trabajar con bucles (while, until, for) - Dominar iteradores y Enumerable - Comprender control de bucles (break, next, redo) ## If-Unless ### Sentencia If ```ruby temperatura = 25 if temperatura > 30 puts "Caliente" elsif temperatura > 20 puts "Agradable" else puts "Frio" end ``` ### Sentencia Unless ```ruby # unless es lo opuesto de if (ejecuta cuando la condicion es falsa) unless temperatura > 30 puts "No hace calor" end # Equivalente a: if !(temperatura > 30) puts "No hace calor" end ``` ### Forma Modificadora ```ruby puts "Valido" if edad >= 18 puts "Menor" unless edad >= 18 # Modificadora de multiples lineas if puntaje > 90 grado = "A" end # Igual a: grado = "A" if puntaje > 90 ``` ### Operador Ternario ```ruby edad = 20 estado = edad >= 18 ? "adulto" : "menor" puts estado # "adulto" ``` ### Comparacion Combinada ```ruby # && - ambos deben ser verdaderos if edad >= 18 && tiene_licencia puts "Puede conducir" end # || - cualquiera puede ser verdadero if es_miembro || tiene_entrada puts "Entrada permitida" end ``` ## Case-When ### Sintaxis Basica ```ruby grado = case puntaje when 90..100 "A" when 80..89 "B" when 70..79 "C" when 60..69 "D" else "F" end ``` ### Forma de Una Linea ```ruby grado = case puntaje when 90..100 then "A" when 80..89 then "B" when 70..79 then "C" else "F" end ``` ### Case con Multiples Valores ```ruby dia = case dia_semana when "Sabado", "Domingo" "Fin de semana" when "Lunes", "Miercoles", "Viernes" "Clases MWF" else "Otro dia" end ``` ### Case sin Argumento ```ruby nombre = "Alicia" saludo = case when nombre.nil? "Quien eres?" when nombre.empty? "Hola, desconocido" else "Hola, #{nombre}" end ``` ## Bucles ### Bucle While ```ruby contador = 1 while contador <= 5 puts contador contador += 1 end ``` ### Bucle Until ```ruby # until ejecuta mientras la condicion sea falsa contador = 1 until contador > 5 puts contador contador += 1 end ``` ### Bucle For ```ruby # Iterar sobre un rango for i in 1..5 puts i end # Iterar sobre un array frutas = ["manzana", "banana", "cereza"] for fruta in frutas puts fruta end ``` ### Bucle como Iterador ```ruby # 5.times do 5.times { puts "Hola" } # upto 1.upto(5) { |n| puts n } # downto 5.downto(1) { |n| puts n } # step 0.step(10, 2) { |n| puts n } # 0, 2, 4, 6, 8, 10 ``` ## Iteradores ### Iterador Times ```ruby 5.times do |i| puts "Iteracion #{i}" end # Sin variable de bloque 3.times { puts "Hola" } ``` ### Iterador Each ```ruby # Array [1, 2, 3].each { |n| puts n } # Hash { a: 1, b: 2 }.each do |clave, valor| puts "#{clave}: #{valor}" end # Rango (1..5).each { |n| puts n } ``` ### Map (Collect) ```ruby # Transformar cada elemento numeros = [1, 2, 3, 4, 5] cuadrados = numeros.map { |n| n ** 2 } puts cuadrados # [1, 4, 9, 16, 25] # Con simbolo a proc nombres = ["alice", "bob", "charlie"] mayusculas = nombres.map(&:upcase) puts mayusculas # ["ALICE", "BOB", "CHARLIE"] ``` ### Select (Find All) ```ruby numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] pares = numeros.select { |n| n.even? } puts pares # [2, 4, 6, 8, 10] impares = numeros.reject { |n| n.even? } puts impares # [1, 3, 5, 7, 9] ``` ### Reduce (Inject) ```ruby numeros = [1, 2, 3, 4, 5] suma = numeros.reduce(0) { |acc, n| acc + n } puts suma # 15 producto = numeros.reduce(1) { |acc, n| acc * n } puts producto # 120 ``` ### Find (Detect) ```ruby numeros = [1, 2, 3, 4, 5] primer_par = numeros.find { |n| n.even? } puts primer_par # 2 todos_pares = numeros.all? { |n| n.even? } # false algun_par = numeros.any? { |n| n.even? } # true ninguno_negativo = numeros.none? { |n| n < 0 } # true ``` ### Otros Iteradores Utiles ```ruby numeros = [1, 2, 3] # each_with_index numeros.each_with_index do |num, indice| puts "#{indice}: #{num}" end # each_with_object numeros.each_with_object([]) { |n, arr| arr << n * 2 } # [2, 4, 6] # count numeros.count # 3 numeros.count { |n| n > 1 } # 2 # include? numeros.include?(2) # true ``` ## Control de Bucles ### Break ```ruby # Salir del bucle anticipadamente numeros = [1, 2, 3, 4, 5] numeros.each do |n| break if n == 3 puts n end # Salida: 1, 2 ``` ### Next ```ruby # Saltar a la siguiente iteracion numeros = [1, 2, 3, 4, 5] numeros.each do |n| next if n.even? puts n end # Salida: 1, 3, 5 ``` ### Redo ```ruby # Rehacer la iteracion actual contador = 0 5.times do contador += 1 if contador < 3 puts contador redo end end ``` ### Retry ```ruby # Reintentar todo el bloque (a menudo en rescue) conteo_reintentos = 0 begin # Simular fallo raise "Error" if conteo_reintentos < 2 puts "Exito" rescue conteo_reintentos += 1 retry end ``` ## Bucles Infinitos ```ruby # Ten cuidado! loop do puts "Presiona Ctrl+C para detener" # break es requerido end ``` ## Resumen - `if`/`unless`: ejecucion condicional - `case`/`when`: comparacion multiple - `while`/`until`: bucles con condicion - `for`: iterar sobre rangos/colecciones - Iteradores: `each`, `map`, `select`, `reduce`, `find` - Control de bucles: `break` (salir), `next` (saltar), `redo` (reintentar iteracion) - Forma modificadora: `puts "hola" if valido`