Control de Flujo

## Objetivos de Aprendizaje - Dominar expresiones if/else - Comprender expresiones match (switch de Scala) - Aprender bucles for y comprehensions - Trabajar con bucles while y do-while - Comprender control de bucles (break, continue) ## Expresiones if/else ### if/else Basico ```scala val x = 10 if (x > 0) { println("Positive") } else { println("Non-positive") } ``` ### else if ```scala def grade(score: Int): String = { if (score >= 90) { "A" } else if (score >= 80) { "B" } else if (score >= 70) { "C" } else if (score >= 60) { "D" } else { "F" } } ``` ### if como Expresion En Scala, if/else devuelve un valor: ```scala val max = if (a > b) a else b val sign = if (x > 0) 1 else if (x < 0) -1 else 0 ``` ### Asignacion vs Expresion ```scala var result = "" if (x > 0) { result = "positive" } else { result = "non-positive" } // Equivalente (ternario-like) val result2 = if (x > 0) "positive" else "non-positive" ``` ## Expresiones match ### match Basico ```scala val day = 3 val dayName = day match { case 1 => "Monday" case 2 => "Tuesday" case 3 => "Wednesday" case 4 => "Thursday" case 5 => "Friday" case 6 => "Saturday" case 7 => "Sunday" case _ => "Invalid" } println(dayName) // Wednesday ``` ### match como Expresion ```scala def describe(x: Any): String = x match { case 1 => "one" case "hello" => "greeting" case true => "truth" case List(1, 2, 3) => "list of three numbers" case _ => "something else" } ``` ### Emparejamiento de Patrones con Variables ```scala def describeList(lst: List[Int]): String = lst match { case List() => "empty list" case head :: tail => s"non-empty list starting with $head" case other => s"list with ${other.length} elements" } ``` ### Emparejamiento con Guardas ```scala def grade(score: Int): String = score match { case s if s >= 90 => "A" case s if s >= 80 => "B" case s if s >= 70 => "C" case s if s >= 60 => "D" case _ => "F" } ``` ### Emparejamiento por Tipos ```scala def describe(obj: Any): String = obj match { case i: Int if i > 0 => s"positive integer: $i" case s: String => s"string: $s" case l: List[_] => s"list of length ${l.length}" case _: BigInt => "a big integer" case null => "null" case _ => "something unknown" } ``` ## Bucles for ### Bucle for Basico ```scala for (i <- 1 to 5) { println(i) } // Imprime: 1, 2, 3, 4, 5 ``` ### until vs to ```scala for (i <- 0 until 5) { println(i) } // Imprime: 0, 1, 2, 3, 4 for (i <- 1 to 5) { println(i) } // Imprime: 1, 2, 3, 4, 5 ``` ### Iterando Colecciones ```scala val fruits = List("apple", "banana", "cherry") for (fruit <- fruits) { println(fruit) } // Con indice for (i <- fruits.indices) { println(s"$i: ${fruits(i)}") } ``` ### Multiples Generadores ```scala for (i <- 1 to 3; j <- 1 to 3) { println(s"($i, $j)") } // Con guarda for (i <- 1 to 5; j <- 1 to i) { println(s"$i >= $j") } ``` ### for con Guardas ```scala for (i <- 1 to 100 if i % 3 == 0 if i % 5 == 0) { println(s"FizzBuzz: $i") } // Igual que for (i <- 1 to 100 if i % 15 == 0) { println(s"FizzBuzz: $i") } ``` ## For Comprehensions ### yield ```scala val squares = for (i <- 1 to 5) yield i * i // List(1, 4, 9, 16, 25) val doubled = for (i <- List(1, 2, 3)) yield i * 2 // List(2, 4, 6) ``` ### Transformando Colecciones ```scala case class Person(name: String, age: Int) val people = List( Person("Alice", 30), Person("Bob", 25), Person("Charlie", 35) ) val names = for (p <- people) yield p.name // List("Alice", "Bob", "Charlie") val adults = for (p <- people if p.age >= 30) yield p // List(Person("Alice", 30), Person("Charlie", 35)) ``` ### Comprehensions Anidadas ```scala val matrix = List( List(1, 2, 3), List(4, 5, 6), List(7, 8, 9) ) val flattened = for { row <- matrix element <- row if element % 2 == 0 } yield element // List(2, 4, 6, 8) ``` ## Bucles while ### Bucle while ```scala var i = 0 while (i < 5) { println(i) i += 1 } ``` ### Bucle do-while ```scala var j = 0 do { println(j) j += 1 } while (j < 5) ``` ## Control de Bucles ### break (Scala 2.10+) ```scala import scala.util.control.Breaks._ breakable { for (i <- 1 to 100) { if (i == 10) break println(i) } } ``` ### continue Scala no tiene continue. Usa guardas en su lugar: ```scala for (i <- 1 to 10) { if (i % 2 == 0) { // Procesar numeros pares println(s"Even: $i") } // Los impares se omiten } ``` ## Valores de Retorno ### Retorno de Funciones ```scala def findFirst[T](arr: List[T], predicate: T => Boolean): Option[T] = { for (elem <- arr) { if (predicate(elem)) return Some(elem) } None } ``` ### Retornos Etiquetados ```scala def hasEvenNumber(list: List[Int]): Boolean = { list.foreach { num => if (num % 2 == 0) return true } false } ``` ## Resumen - `if/else` es una expresion que devuelve un valor - `match` es la construccion potente de emparejamiento de patrones de Scala - Los bucles `for` pueden iterar sobre rangos, colecciones y multiples generadores - `yield` transforma resultados en for comprehensions - Las guardas (`if`) filtran iteraciones - `while` y `do-while` estan disponibles para codigo imperativo - Usa `breakable` de `scala.util.control.Breaks` para la funcionalidad de break - Prefiere enfoques funcionales (comprehensions) sobre bucles imperativos cuando sea posible