Scala for Backend Engineering & Functional Programming · Aula

Indentação significativa

Chaves opcionais.

Indentação significativa é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Chaves opcionais

Scala 3 introduz a indentação significativa, também chamada de sintaxe de chaves opcionais. Em vez de envolver blocos em { }, você pode usar a indentação para delimitá-los.

As chaves continuam funcionando e são totalmente válidas.
O código baseado em indentação é mais limpo e semelhante ao Python.

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

Corpos de métodos indentados

O corpo de um método que vem depois de = pode ser um bloco indentado. Cada instrução no mesmo nível de indentação pertence a esse corpo.

A última expressão é o valor retornado.

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

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

Expressões if indentadas

As estruturas de controle usam a nova sintaxe simplificada. Depois de if cond then, você indenta o ramo, e else fica alinhado com if.

then é obrigatório no estilo sem chaves.
Não são necessários parênteses em torno da condição.

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

Laços for indentados

O laço for usa do para efeitos colaterais ou yield para criar coleções, ambos com indentação.

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)

Laços while indentados

O laço while usa do seguido de um bloco indentado no estilo de chaves opcionais.

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

Expressões match indentadas

A correspondência de padrões se adapta naturalmente à indentação. As cláusulas case ficam indentadas sob 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))

Corpos de classes e traits

Classes, traits e objetos também podem omitir as chaves. Dois-pontos : depois do cabeçalho abre o corpo 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)

O marcador end

Para blocos indentados longos, você pode adicionar um marcador end para deixar claro onde uma definição termina. Isso melhora a legibilidade de métodos ou classes grandes.

Formato: end <name> ou end if, end while etc.
É opcional e verificado pelo compilador.

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

Combinando chaves e indentação

Você pode combinar livremente os dois estilos. Algumas equipes mantêm as chaves para facilitar a leitura em casos aninhados. As regras de indentação só são aplicadas onde não há chaves.

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)
  }

Armadilhas comuns da indentação

A indentação é significativa, portanto seja consistente.

Use espaços; não misture tabulações com espaços.
Uma linha desalinhada pode ficar silenciosamente fora de um bloco.
Os dois-pontos : são necessários para corpos de modelos (classes/objetos), mas não para corpos de métodos depois de =.

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

Sintaxe de argumentos com menos chaves

Scala 3 também permite passar um argumento em bloco depois de dois-pontos. items.foreach: x => abre o corpo indentado de uma lambda, evitando parênteses e chaves aninhados.

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)

Verificação rápida

Teste sua compreensão da indentação significativa.

Recapitulação

Você aprendeu a indentação significativa do Scala 3.

Os blocos podem usar indentação em vez de { }.
As estruturas de controle usam then, do e yield.
Os corpos de classes, objetos e traits começam com dois-pontos :.
Os marcadores end esclarecem blocos longos.
Os dois estilos podem ser combinados; mantenha a consistência dos espaços.

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

Perguntas Frequentes

A aula “Indentação significativa” é grátis?

Sim — o texto completo de “Indentação significativa” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Indentação significativa”?

Chaves opcionais. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Indentação significativa”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming