Internationalisation (i18n) en Kotlin : guide complet

Voici la traduction en français du contenu HTML fourni, en respectant toutes les consignes : ```html

Internationalisation (i18n) en Kotlin : des bases aux techniques avancées

L'internationalisation (abrégée i18n — de l'anglais « internationalization », où 18 est le nombre de lettres entre le premier « i » et le dernier « n ») est le processus de conception de logiciels de manière à pouvoir les adapter facilement à différentes langues et normes régionales sans modifier le code. Pour Kotlin, en tant que langage multiplateforme moderne, le support de l'i18n est particulièrement important, car les applications qui l'utilisent fonctionnent sur Android, le backend (JVM), le web (Kotlin/JS) et les plateformes natives (Kotlin/Native).

Dans cet article, nous verrons comment organiser efficacement l'internationalisation dans les projets Kotlin : des approches de base utilisant des fichiers de ressources aux solutions avancées avec des bibliothèques d'assistance.

1. Approche de base : fichiers de ressources (ResourceBundle)

La méthode la plus simple et la plus courante consiste à utiliser les mécanismes standard de Java ResourceBundle et les fichiers de propriétés (.properties). Cette méthode fonctionne parfaitement pour les projets JVM (Android, Spring Boot, applications console).

Étape 1. Créer des fichiers de localisation

Créez dans les ressources du projet des fichiers nommés messages.properties (par défaut) et messages_ru.properties (pour le russe) :

# messages.properties (anglais, langue par défaut)greeting=Hello, {0}!farewell=Goodbye, {0}!app.title=My Application

# messages_ru.properties (russe)greeting=Привет, {0}!farewell=До свидания, {0}!app.title=Моё приложение

Étape 2. Charger et utiliser en Kotlin

Créez un objet utilitaire pour travailler avec la localisation :

import java.text.MessageFormatimport java.util.*

object I18n {    private var bundle: ResourceBundle = ResourceBundle.getBundle("messages", Locale.getDefault())

    fun setLocale(locale: Locale) {        bundle = ResourceBundle.getBundle("messages", locale)    }

    fun get(key: String, vararg args: Any?): String {        val pattern = bundle.getString(key)        return MessageFormat.format(pattern, *args)    }}

fun main() {    // Utilisation de l'anglais par défaut    println(I18n.get("greeting", "Alice")) // Hello, Alice!

    // Passage au russe    I18n.setLocale(Locale("ru"))    println(I18n.get("greeting", "Алиса")) // Привет, Алиса!}

2. Bibliothèque kotlin-i18n (de JetBrains)

Pour Kotlin Multiplatform, il existe une bibliothèque officielle kotlin-i18n qui permet de travailler avec les traductions de manière uniforme sur toutes les plateformes. Elle utilise le format Gettext PO (Portable Object), pratique pour les traducteurs.

Installation (Gradle)

repositories {    mavenCentral()}dependencies {    implementation("org.jetbrains.kotlinx:kotlin-i18n:0.1.0")}

Exemple d'utilisation

import org.jetbrains.kotlinx.i18n.*

fun main() {    // Création d'un traducteur avec chargement depuis des fichiers PO    val translator = Translator(        bundleName = "messages",        locale = Locale("ru")    )

    // Utilisation avec substitution de paramètres    val message = translator.translate(        "greeting",        "Мир"    )    println(message) // Привет, Мир!}

Avantages : prise en charge du pluriel (plural forms), des contextes de traduction, fonctionnement sur toutes les plateformes Kotlin.

3. Approche avancée : bibliothèque ok-i18n

Pour les projets nécessitant flexibilité et intégration avec des conteneurs DI (par exemple, Koin ou Dagger), la bibliothèque ok-i18n est idéale. Elle prend en charge le format JSON pour les traductions, pratique pour travailler avec des API REST ou des fichiers de configuration.

Exemple de fichier de traduction JSON (ru.json)

{  "app": {    "title": "Мо
```