Scala for Backend Engineering & Functional Programming · Leçon

Utiliser le REPL

Scala interactive

Utiliser le REPL 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.

Qu'est-ce que le REPL ?

L'acronyme REPL signifie Read-Eval-Print Loop (boucle lire-évaluer-afficher). C'est un shell interactif où vous tapez des expressions Scala et voyez immédiatement leurs résultats.

Vous le lancez en exécutant scala (ou scala-cli repl) dans votre terminal. C'est le meilleur moyen d'expérimenter le langage sans écrire un programme complet.

Votre première expression

Tapez une expression quelconque et appuyez sur Entrée. Le REPL l'évalue et affiche le résultat, son type et un nom généré.

Par exemple, en tapant 1 + 1, vous voyez quelque chose comme val res0: Int = 2.

object Main {
  def main(args: Array[String]): Unit = {
    println(1 + 1)
  }
}

Variables res

Chaque résultat que vous calculez est automatiquement sauvegardé dans une variable nommée resN (res0, res1, ...).

Vous pouvez réutiliser ces noms dans les expressions suivantes, ce qui rend le REPL semblable à une calculatrice en fonctionnement.

object Main {
  def main(args: Array[String]): Unit = {
    val res0 = 2 + 3
    val res1 = res0 * 10
    println(res1)
  }
}

Information de type

L'une des fonctionnalités les plus utiles : le REPL vous indique le type de chaque résultat.

Taper "hello" affiche val res0: String = hello. Cela vous aide à apprendre ce que Scala déduit pour n'importe quelle expression.

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "hello"
    println(greeting)
  }
}

Définir des valeurs

Vous pouvez définir des valeurs nommées à l'intérieur du REPL en utilisant val. Elles persistent pour le reste de la session.

Une fois définis, vous pouvez les référencer dans n'importe quelle ligne suivante.

object Main {
  def main(args: Array[String]): Unit = {
    val pi = 3.14159
    val radius = 2.0
    println(pi * radius * radius)
  }
}

Définir des fonctions

Vous n'êtes pas limité à des commandes d'une seule ligne. Vous pouvez définir des fonctions directement dans le REPL et les appeler immédiatement.

Cela vous permet de construire de petites fonctions d'aide et de les tester instantanément.

object Main {
  def square(x: Int): Int = x * x
  def main(args: Array[String]): Unit = {
    println(square(5))
  }
}

Entrée multi-ligne

Si vous tapez quelque chose d'incomplet (comme une accolade ouverte), le REPL affiche une invite de continuation et attend le reste.

Cela signifie que vous pouvez coller ou taper des définitions multi-lignes naturellement sans que le REPL essaie d'évaluer trop tôt.

object Main {
  def main(args: Array[String]): Unit = {
    val total =
      1 +
      2 +
      3
    println(total)
  }
}

Importer dans le REPL

Vous pouvez utiliser import à l'intérieur du REPL, tout comme dans un fichier. C'est pratique pour utiliser les assistants de la bibliothèque standard.

Par exemple, import scala.math.* vous donne sqrt, abs et bien d'autres.

import scala.math.sqrt
object Main {
  def main(args: Array[String]): Unit = {
    println(sqrt(16.0))
  }
}

Commandes REPL utiles

Le REPL a des commandes spéciales commençant par un deux-points :

:help liste toutes les commandes
:reset efface votre session
:quit quitte le REPL
:type expr affiche le type d'une expression sans l'exécuter

Pourquoi utiliser le REPL ?

Le REPL est parfait pour :

Tester une API peu familière rapidement
Vérifier le type qu'une expression produit
Prototyper la logique avant de l'ajouter à un projet
Apprendre le langage de manière interactive

Combiner tout cela

Dans une seule session, vous pouvez définir des valeurs, écrire des fonctions, importer des bibliothèques et enchaîner les résultats ensemble. Le REPL garde tout cela dans le scope.

Voici un petit exemple que vous pourriez construire ligne par ligne.

object Main {
  def celsiusToF(c: Double): Double = c * 9 / 5 + 32
  def main(args: Array[String]): Unit = {
    val temps = List(0.0, 25.0, 100.0)
    println(temps.map(celsiusToF))
  }
}

Vérification rapide

Testez votre compréhension du REPL Scala.

Résumé

Vous avez appris que le REPL est une boucle interactive Read-Eval-Print pour Scala.

Il affiche la valeur, le type et un nom resN auto-généré pour chaque résultat
Vous pouvez définir des vals et des fonctions qui persistent dans la session
Vous pouvez utiliser import pour des bibliothèques et l'entrée multi-ligne
Les commandes comme :type, :reset et :quit contrôlent la session

Questions Fréquemment Posées

La leçon « Utiliser le REPL » est-elle gratuite ?

Oui — le texte complet de « Utiliser le REPL » 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 « Utiliser le REPL » ?

Scala interactive 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 « Utiliser le REPL » ?

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