Scala for Backend Engineering & Functional Programming · Lección

Indentación significativa

Llaves opcionales

Indentación significativa es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

Llaves opcionales

Scala 3 introduce la indentación significativa, también denominada sintaxis de llaves opcionales. En lugar de delimitar los bloques con { }, puede usar la indentación para delimitarlos.

Las llaves siguen funcionando y son totalmente válidas.
El código basado en indentación es más limpio y similar al de Python.

object Main:
  def main(args: Array[String]): Unit =
    println("No braces needed")

Cuerpos de métodos con indentación

El cuerpo de un método que sigue a = puede ser un bloque indentado. Cada instrucción con el mismo nivel de indentación pertenece a ese cuerpo.

La última expresión es el valor devuelto.

object Main:
  def square(x: Int): Int =
    val result = x * x
    result

  def main(args: Array[String]): Unit =
    println(square(5))

Expresiones if con indentación

Las estructuras de control usan la nueva sintaxis simplificada. Después de if cond then, indente la rama; else debe quedar alineado con if.

then es obligatorio en el estilo sin llaves.
No se necesitan paréntesis alrededor de la condición.

object Main:
  def main(args: Array[String]): Unit =
    val n = 7
    val label =
      if n % 2 == 0 then "even"
      else "odd"
    println(label)

Bucles for con indentación

El bucle for usa do para realizar efectos secundarios o yield para construir colecciones; en ambos casos, se utiliza la indentación.

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 3 do
      println(s"line $i")

    val doubled =
      for i <- 1 to 3 yield i * 2
    println(doubled)

Bucles while con indentación

El bucle while usa do seguido de un bloque indentado en el estilo de llaves opcionales.

object Main:
  def main(args: Array[String]): Unit =
    var i = 0
    while i < 3 do
      println(s"i = $i")
      i += 1

Expresiones match con indentación

La coincidencia de patrones se adapta naturalmente a la indentación. Las cláusulas case se indentan bajo match.

object Main:
  def describe(n: Int): String =
    n match
      case 0 => "zero"
      case 1 => "one"
      case _ => "many"

  def main(args: Array[String]): Unit =
    println(describe(1))
    println(describe(9))

Cuerpos de clases y traits

Las clases, los traits y los objetos también pueden omitir las llaves. Los dos puntos : después de la cabecera abren el cuerpo indentado.

class Point(x: Int, y: Int):
  def show: String = s"($x, $y)"

object Main:
  def main(args: Array[String]): Unit =
    println(Point(2, 3).show)

El marcador end

En los bloques indentados largos puede añadir un marcador end para indicar con claridad dónde termina una definición. Esto mejora la legibilidad de los métodos o las clases grandes.

Forma: end <name> o end if, end while, etc.
Es opcional y el compilador lo comprueba.

object Main:
  def greet(name: String): String =
    val msg = s"Hello, $name"
    msg
  end greet

  def main(args: Array[String]): Unit =
    println(greet("Ada"))
  end main
end Main

Mezcla de llaves e indentación

Puede mezclar libremente ambos estilos. Algunos equipos mantienen las llaves para aportar claridad en casos anidados. Las reglas de indentación solo se aplican donde no hay llaves.

object Main:
  def main(args: Array[String]): Unit = {
    val xs = List(1, 2, 3)
    val total =
      xs.foldLeft(0)((acc, x) => acc + x)
    println(total)
  }

Errores comunes de indentación

La indentación es significativa, así que debe ser coherente.

Use espacios; no mezcle tabuladores con espacios.
Una línea mal alineada puede quedar fuera de un bloque sin que resulte evidente.
Los dos puntos : son necesarios para los cuerpos de plantillas (clases/objetos), pero no para los cuerpos de métodos después de =.

object Main:
  def main(args: Array[String]): Unit =
    val items = List("a", "b")
    items.foreach: item =>
      println(item.toUpperCase)

Sintaxis de argumentos con menos llaves

Scala 3 también permite pasar un argumento de bloque después de dos puntos. items.foreach: x => abre el cuerpo indentado de una lambda y evita los paréntesis y las llaves anidados.

object Main:
  def main(args: Array[String]): Unit =
    val nums = List(1, 2, 3, 4)
    val evens = nums.filter: n =>
      n % 2 == 0
    println(evens)

Comprobación rápida

Compruebe su comprensión de la indentación significativa.

Resumen

Ha aprendido la indentación significativa de Scala 3.

Los bloques pueden usar indentación en lugar de { }.
Las estructuras de control usan then, do y yield.
Los cuerpos de clases, objetos y traits se abren con dos puntos :.
Los marcadores end aclaran los bloques largos.
Ambos estilos se pueden mezclar; mantenga una separación coherente.

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 2 do
      if i == 1 then println("first")
      else println("second")
  end main
end Main

Preguntas frecuentes

¿La lección «Indentación significativa» es gratis?

Sí — el texto completo de «Indentación significativa» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.

¿Qué aprenderé en «Indentación significativa»?

Llaves opcionales Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?

No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Indentación significativa»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?

Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Scala for Backend Engineering & Functional Programming