Scala for Backend Engineering & Functional Programming · Leçon

Interpolation de chaînes

s, f et raw

Interpolation de chaînes est une leçon Scala for Backend Engineering & Functional Programming gratuite sur CoddyKit. Ceci est la leçon 4 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 l’interpolation de chaînes ?

L’interpolation de chaînes permet d’insérer directement des valeurs dans un littéral de chaîne au lieu de les concaténer avec +.

Vous préfixez la chaîne par une lettre comme s, f ou raw, puis utilisez $ pour insérer des valeurs.

L’interpolateur s

L’interpolateur s insère la valeur d’une variable à l’endroit où vous écrivez $name.

C’est l’interpolateur le plus courant ; il remplace les concaténations peu élégantes.

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Ada"
    println(s"Hello, $name!")
  }
}

Expressions entre accolades

Pour tout ce qui dépasse une simple variable, placez l’expression entre ${ ... }.

Les accolades indiquent à l’interpolateur où l’expression commence et se termine.

object Main {
  def main(args: Array[String]): Unit = {
    val a = 4
    val b = 6
    println(s"Sum is ${a + b}")
  }
}

Appeler des méthodes à l’intérieur

Vous pouvez également appeler des méthodes à l’intérieur de ${ ... }. Toute expression valide fonctionne.

object Main {
  def main(args: Array[String]): Unit = {
    val word = "scala"
    println(s"Upper: ${word.toUpperCase}")
  }
}

L’interpolateur f

L’interpolateur f ajoute un formatage de type printf. Après l’expression, vous indiquez un format comme %.2f pour deux chiffres après la virgule.

C’est idéal pour les montants, les pourcentages et les sorties alignées.

object Main {
  def main(args: Array[String]): Unit = {
    val price = 9.5
    println(f"Price: $$$price%.2f")
  }
}

Formater des nombres entiers

L’interpolateur f formate également les nombres entiers, par exemple %d pour un entier décimal ou %05d pour compléter avec des zéros.

object Main {
  def main(args: Array[String]): Unit = {
    val id = 42
    println(f"ID: $id%05d")
  }
}

L’interpolateur raw

L’interpolateur raw fonctionne comme s, mais ne traite pas les séquences d’échappement.

Ainsi, \n reste constitué des deux caractères barre oblique inverse et n, au lieu de devenir un saut de ligne.

object Main {
  def main(args: Array[String]): Unit = {
    println(raw"line1\nline2")
  }
}

Comparer s et raw

Avec s, l’échappement \n devient un véritable saut de ligne. Avec raw, il reste littéral.

Utilisez raw pour les chemins, les motifs d’expressions régulières ou tout autre cas où les barres obliques inverses doivent être conservées.

object Main {
  def main(args: Array[String]): Unit = {
    println(s"a\nb")
    println(raw"a\nb")
  }
}

Interpolation sur plusieurs lignes

L’interpolation fonctionne également avec les chaînes entre triples guillemets, qui peuvent s’étendre sur plusieurs lignes.

C’est très pratique pour construire une sortie lisible à partir de modèles.

object Main {
  def main(args: Array[String]): Unit = {
    val user = "Grace"
    val score = 95
    println(s"""User: $user
Score: $score""")
  }
}

Échapper un signe dollar

Pour afficher un signe dollar littéral dans une chaîne interpolée, écrivez $$.

L’interpolateur ne le prendra ainsi pas pour le début d’une variable.

object Main {
  def main(args: Array[String]): Unit = {
    val amount = 20
    println(s"Cost: $$$amount")
  }
}

Assembler le tout

Combinez des variables simples, une expression entre accolades et un appel de méthode dans un même message interpolé.

object Main {
  def main(args: Array[String]): Unit = {
    val item = "book"
    val qty = 3
    val each = 12.0
    println(s"$qty ${item}s cost ${qty * each}")
  }
}

Vérification rapide

Testez vos connaissances sur les interpolateurs.

Récapitulatif

Vous avez découvert les trois principaux interpolateurs de chaînes de Scala :

s insère des variables et des expressions ${expr}
f ajoute un formatage de type printf, comme %.2f et %05d
raw conserve les séquences d’échappement sous forme littérale
Utilisez $$ pour un signe dollar littéral
L’interpolation fonctionne aussi avec les chaînes multilignes entre triples guillemets

Questions Fréquemment Posées

La leçon « Interpolation de chaînes » est-elle gratuite ?

Oui — le texte complet de « Interpolation de chaînes » 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 « Interpolation de chaînes » ?

s, f et raw 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 4 sur 4.

Combien de temps prend la leçon « Interpolation de chaînes » ?

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