Templates de chaînes (`String templates`)

Introduction : construire des chaînes dynamiquement

Une tâche extrêmement courante en programmation est de construire des chaînes de caractères qui incluent les valeurs de variables ou les résultats d'expressions. Traditionnellement, cela se fait souvent par concaténation, en utilisant l'opérateur `+` pour assembler des morceaux de texte littéral et des variables converties en chaînes.

Bien que la concaténation fonctionne, elle peut rapidement devenir verbeuse, difficile à lire et source d'erreurs (oublier des espaces, problèmes de conversion de types). Kotlin propose une solution beaucoup plus élégante et lisible : les templates de chaînes (ou string interpolation).

Les templates de chaînes vous permettent d'insérer directement des références à des variables ou des expressions complexes à l'intérieur d'une chaîne de caractères littérale, en utilisant une syntaxe spéciale. Cela rend la construction de chaînes dynamiques beaucoup plus intuitive et concise.

Syntaxe de base : insérer des variables avec `$`

La forme la plus simple d'un template de chaîne consiste à insérer la valeur d'une variable directement dans la chaîne. Pour ce faire, il suffit de préfixer le nom de la variable par le symbole dollar (`$`).

fun main() {
    val userName = "Alice"
    val userAge = 30
    val score = 95.5

    // Utilisation de $ pour insérer les valeurs des variables
    val message1 = "Utilisateur: $userName"
    val message2 = "Age de $userName: $userAge ans"
    val message3 = "Le score de $userName est $score points."

    println(message1) // Affiche: Utilisateur: Alice
    println(message2) // Affiche: Age de Alice: 30 ans
    println(message3) // Affiche: Le score de Alice est 95.5 points.
}

C'est simple, direct et beaucoup plus lisible que la concaténation équivalente (`"Utilisateur: " + userName`). Kotlin se charge automatiquement de convertir la valeur de la variable (comme `userAge` qui est un `Int`) en sa représentation textuelle pour l'insérer dans la chaîne.

Expressions complexes : utiliser `${...}`

Que faire si vous voulez insérer non pas juste la valeur d'une variable, mais le résultat d'une expression plus complexe (un calcul, un appel de fonction, l'accès à une propriété d'un objet) ?

Dans ce cas, vous utilisez la syntaxe avec des accolades : placez l'expression entière à l'intérieur d'accolades `{}` et préfixez le tout par le symbole dollar (`${expression}`).

fun calculateBonus(score: Int): Int {
    return score / 10
}

data class User(val name: String, val isAdmin: Boolean)

fun main() {
    val price = 50.0
    val quantity = 3
    val score = 85
    val currentUser = User("Bob", true)

    // Insérer le résultat d'un calcul
    val totalMessage = "Coût total: ${price * quantity} euros"
    println(totalMessage) // Affiche: Coût total: 150.0 euros

    // Insérer le résultat d'un appel de fonction
    val bonusMessage = "Bonus calculé: ${calculateBonus(score)} points"
    println(bonusMessage) // Affiche: Bonus calculé: 8 points

    // Insérer une propriété d'un objet
    val userMessage = "Nom de l'utilisateur: ${currentUser.name}"
    println(userMessage) // Affiche: Nom de l'utilisateur: Bob

    // Insérer le résultat d'une expression conditionnelle (ici, if comme expression)
    val adminStatus = "L'utilisateur ${currentUser.name} est ${if (currentUser.isAdmin) "administrateur" else "un utilisateur standard"}."
    println(adminStatus) // Affiche: L'utilisateur Bob est administrateur.

    // Même un simple appel de méthode sur une variable
    val nameLength = "Le nom '${currentUser.name}' contient ${currentUser.name.length} caractères."
    println(nameLength) // Affiche: Le nom 'Bob' contient 3 caractères.
}

La syntaxe `${...}` est extrêmement flexible et vous permet d'intégrer presque n'importe quelle expression Kotlin valide directement dans votre chaîne de caractères.

Echapper le symbole dollar `$`

Que se passe-t-il si vous voulez inclure un caractère dollar littéral (`$`) dans votre chaîne, sans qu'il soit interprété comme le début d'un template ?

Vous devez l'"échapper" en utilisant une barre oblique inverse (`\`) juste avant, mais la manière la plus simple et la plus recommandée en Kotlin est d'utiliser la syntaxe `${'$'}`.

fun main() {
    val price = 100

    // Pour afficher un prix avec le symbole dollar
    val priceMessageCorrect = "Le prix est de ${'$'}$price."
    // Alternative moins lisible avec échappement : val priceMessageAlternative = "Le prix est de \$$price."

    println(priceMessageCorrect) // Affiche: Le prix est de $100.
}

Utiliser `${'$'}` est généralement plus clair que `\$` pour représenter un dollar littéral dans un contexte de template.

Templates dans les chaînes brutes (Raw Strings)

Kotlin propose également des chaînes "brutes" (raw strings), définies avec trois guillemets doubles (`""" ... """`). Ces chaînes peuvent contenir des sauts de ligne et n'interprètent pas les séquences d'échappement comme `` ou ``. Cependant, les templates de chaînes (`$` et `${...}`) fonctionnent toujours à l'intérieur des chaînes brutes.

fun main() {
    val language = "Kotlin"
    val version = "1.9"

    val multiLineMessage = """
    Ceci est une chaîne brute.
    Elle peut contenir des sauts de ligne.
    Langage: $language
    Version: ${version}
    Prix: ${'$'}50
    """

    println(multiLineMessage)
    /*
    Affiche :

    Ceci est une chaîne brute.
    Elle peut contenir des sauts de ligne.
    Langage: Kotlin
    Version: 1.9
    Prix: $50

    */
}

Avantages des templates de chaînes

L'utilisation des templates de chaînes en Kotlin offre plusieurs avantages significatifs par rapport à la concaténation manuelle :

• Lisibilité : Le code est beaucoup plus facile à lire car la structure de la chaîne finale est immédiatement visible, avec les variables et expressions insérées à leur place logique.
• Concision : La syntaxe est plus courte et moins répétitive que l'enchaînement de `+`.
• Moins d'erreurs : Réduit les risques d'oublier des espaces ou de faire des erreurs de conversion de type, car Kotlin gère la conversion en `String` automatiquement.
• Maintenabilité : Modifier la structure de la chaîne ou les variables insérées est plus simple et moins sujet aux erreurs.

C'est une fonctionnalité idiomatique de Kotlin qu'il est fortement recommandé d'utiliser pour toute construction de chaîne impliquant des variables ou des expressions.

Récapitulatif : `$` et `${...}`

Retenez les deux syntaxes clés des templates de chaînes en Kotlin :

• `$variable` : Pour insérer la valeur d'une variable simple.
• `${expression}` : Pour insérer le résultat d'une expression plus complexe (calcul, appel de fonction, accès à une propriété, etc.).

Ces outils rendent la manipulation et la création de chaînes de caractères dynamiques en Kotlin à la fois simples, élégantes et efficaces.