Scala for Backend Engineering & Functional Programming · Leçon

Indentation significative

Accolades facultatives

Leçon 1 sur 413 étapes

Indentation significative est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Scala for Backend Engineering & Functional Programming, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Accolades facultatives

Scala 3 introduit l’indentation significative, également appelée syntaxe à accolades facultatives. Au lieu d’entourer les blocs de { }, vous pouvez utiliser l’indentation pour les délimiter.

Les accolades restent utilisables et sont parfaitement valides.
Le code fondé sur l’indentation est plus clair et ressemble à celui de Python.

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

Corps de méthodes indentés

Le corps d’une méthode qui suit = peut être un bloc indenté. Toute instruction située au même niveau d’indentation appartient à ce corps.

La dernière expression est la valeur renvoyée.

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

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

Expressions if indentées

Les structures de contrôle utilisent la nouvelle syntaxe allégée. Après if cond then, indentez la branche, et alignez else sur if.

then est obligatoire dans le style sans accolades.
Aucune parenthèse autour de la condition n’est nécessaire.

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

Boucles for indentées

La boucle for utilise do pour les effets de bord ou yield pour construire des collections, dans les deux cas avec une indentation.

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)

Boucles while indentées

La boucle while utilise do, suivi d’un bloc indenté dans le style à accolades facultatives.

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

Expressions match indentées

La correspondance de motifs se prête naturellement à l’indentation. Les clauses case sont indentées sous 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))

Corps de classes et de traits

Les classes, les traits et les objets peuvent eux aussi omettre leurs accolades. Un deux-points : après l’en-tête ouvre le corps indenté.

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)

Marqueur end

Pour les longs blocs indentés, vous pouvez ajouter un marqueur de fin afin de préciser où se termine une définition. Cela améliore la lisibilité des grandes méthodes ou classes.

Forme : end <name> ou end if, end while, etc.
Il est facultatif et vérifié par le compilateur.

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

Mélanger accolades et indentation

Vous pouvez librement mélanger les deux styles. Certaines équipes conservent les accolades pour clarifier les cas imbriqués. Les règles d’indentation ne s’appliquent que là où les accolades sont absentes.

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

Pièges courants de l’indentation

L’indentation est significative : soyez donc cohérent.

Utilisez des espaces, sans les mélanger avec des tabulations.
Une ligne mal alignée peut se retrouver discrètement en dehors d’un bloc.
Le deux-points : est nécessaire pour les corps de modèles (classes/objets), mais pas pour les corps de méthodes après =.

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

Syntaxe d’arguments avec moins d’accolades

Scala 3 permet également de transmettre un bloc d’arguments après un deux-points. items.foreach: x => ouvre le corps indenté d’une lambda, ce qui évite les parenthèses et accolades imbriquées.

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)

Vérification rapide

Vérifiez votre compréhension de l’indentation significative.

Réponds-y dans la leçon interactive

Récapitulatif

Vous avez appris l’indentation significative de Scala 3.

Les blocs peuvent utiliser l’indentation plutôt que { }.
Les structures de contrôle utilisent then, do et yield.
Les corps de classes/objets/traits s’ouvrent avec un deux-points :.
Les marqueurs end clarifient les blocs longs.
Les deux styles peuvent être mélangés ; restez cohérent dans l’espacement.

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

Gratuit pour commencer

Apprends Scala avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 39
Leçons: 143

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Indentation significative » est-elle gratuite ?

Oui — le texte complet de « Indentation significative » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Scala for Backend Engineering & Functional Programming, passe à CoddyKit PRO. Le cours Scala for Backend Engineering & Functional Programming comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Indentation significative » ?

Accolades facultatives Tu pratiques Scala for Backend Engineering & Functional Programming avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Scala for Backend Engineering & Functional Programming ?

Aucune expérience préalable n'est requise. Scala for Backend Engineering & Functional Programming sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Indentation significative » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Scala for Backend Engineering & Functional Programming ?

Oui. Chaque leçon Scala for Backend Engineering & Functional Programming inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Scala for Backend Engineering & Functional Programming