Communitygithub.com

Localisation et Internationalisation (Xcode 15-26)

Guide complet pour la localisation d'applications Apple avec les catalogues de chaînes (String Catalogs), y compris les pluriels, la prise en charge RTL, le formatage localisé et la migration depuis les fichiers .strings.

Qu'est-ce que Localisation et Internationalisation (Xcode 15-26) ?

Cette compétence fournit un guide exhaustif et à jour sur la localisation (i18n) d'applications Apple, en se concentrant sur les String Catalogs (.xcstrings) introduits dans Xcode 15. Elle est essentielle pour les développeurs qui souhaitent rendre leurs applications SwiftUI et UIKit accessibles à un public mondial, en suivant les meilleures pratiques des lauréats de l'Apple Design Award pour l'inclusivité. La compétence couvre en détail la création et la gestion des catalogues de chaînes, les API de localisation de SwiftUI (telles que `LocalizedStringResource`), la gestion correcte des formes plurielles (un, quelques, plusieurs, etc.) qui varie selon les langues, la prise en charge des langues s'écrivant de droite à gauche (RTL) comme l'arabe ou l'hébreu, et le formatage adapté à la locale pour les dates, les nombres et les devises. Elle aborde également la localisation des raccourcis Siri (App Shortcuts/Intents), les variations de texte en fonction de l'appareil (iPhone, Apple Watch) et des contraintes de largeur, ainsi que les stratégies de migration depuis les formats hérités (.strings, .stringsdict). Enfin, elle détaille les workflows de traduction avec les états (Nouveau, À réviser, Validé) et l'export XLIFF, et offre des conseils pour le débogage des traductions manquantes ou des formes plurielles incorrectes.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/IGTA-Tech/claude-skills-research/tree/HEAD/Axiom/.claude-plugin/plugins/axiom/skills/localization

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Localisation et Internationalisation

Guide complet pour la localisation d'applications à l'aide des catalogues de chaînes. Les lauréats de l'Apple Design Award en catégorie Inclusivité prennent toujours en charge plusieurs langues avec un excellent support RTL (droite à gauche).

Aperçu

Les catalogues de chaînes (.xcstrings) sont le format unifié d'Xcode 15 pour la gestion de la localisation des applications. Ils remplacent les fichiers .strings et .stringsdict hérités par un format unique basé sur JSON, plus facile à maintenir, à différencier et à intégrer dans les flux de travail de traduction.

Cette compétence couvre les catalogues de chaînes, les API de localisation SwiftUI/UIKit, la gestion des pluriels, le support RTL, le formatage adapté à la locale et les stratégies de migration des formats hérités.

Quand utiliser cette compétence

  • Mise en place de catalogues de chaînes dans Xcode 15+
  • Localisation d'applications SwiftUI et UIKit
  • Gestion correcte des formes plurielles (critique pour de nombreuses langues)
  • Prise en charge des langues RTL (arabe, hébreu)
  • Formatage des dates, nombres et devises selon la locale
  • Migration des fichiers .strings/.stringsdict hérités
  • Préparation des raccourcis d'application et des intentions d'application pour la localisation
  • Débogage des traductions manquantes ou des formes plurielles incorrectes

Configuration système requise

  • Xcode 15+ pour les catalogues de chaînes (.xcstrings)
  • Xcode 26+ pour la génération automatique de symboles, la macro #bundle et la génération de commentaires par IA
  • iOS 15+ pour LocalizedStringResource
  • iOS 16+ pour la localisation des raccourcis d'application
  • Les versions antérieures d'iOS utilisent les fichiers .strings hérités

Partie 1 : Catalogues de chaînes (WWDC 2023/10155)

Création d'un catalogue de chaînes

Méthode 1 : Navigateur Xcode

  1. Fichier → Nouveau → Fichier
  2. Choisissez « Catalogue de chaînes »
  3. Nommez-le (par exemple, Localizable.xcstrings)
  4. Ajoutez-le à la cible

Méthode 2 : Extraction automatique

Xcode 15 peut extraire automatiquement les chaînes de :

  • Vues SwiftUI (littéraux de chaîne dans Text, Label, Button)
  • Code Swift (String(localized:))
  • Objective-C (NSLocalizedString)
  • C (CFCopyLocalizedString)
  • Fichiers Interface Builder (.storyboard, .xib)
  • Valeurs Info.plist
  • Phrases de raccourcis d'application

Paramètres de build requis :

  • « Utiliser le compilateur pour extraire les chaînes Swift » → Oui
  • « La localisation préfère les catalogues de chaînes » → Oui

Structure du catalogue de chaînes

Chaque entrée possède :

  • Clé : Identifiant unique (par défaut : la chaîne anglaise)
  • Valeur par défaut : Valeur de secours si la traduction est manquante
  • Commentaire : Contexte pour les traducteurs
  • Table de chaînes : Conteneur d'organisation (par défaut : « Localizable »)

Exemple de JSON .xcstrings :

{
  "sourceLanguage" : "en",
  "strings" : {
    "Merci d'avoir magasiné chez nous !" : {
      "comment" : "Étiquette au-dessus du bouton de paiement",
      "localizations" : {
        "en" : {
          "stringUnit" : {
            "state" : "translated",
            "value" : "Merci d'avoir magasiné chez nous !"
          }
        },
        "es" : {
          "stringUnit" : {
            "state" : "translated",
            "value" : "¡Gracias por comprar con nosotros!"
          }
        }
      }
    }
  },
  "version" : "1.0"
}

États de traduction

Xcode suit l'état de chaque traduction :

  • Nouveau (⚪) - La chaîne n'a pas encore été traduite
  • À réviser (🟡) - La source a changé, la traduction peut être obsolète
  • Validé (✅) - Traduction approuvée et à jour
  • Obsolète (🔴) - La chaîne n'est plus trouvée dans le code source

Flux de travail :

  1. Le développeur ajoute la chaîne → Nouveau
  2. Le traducteur ajoute la traduction → Validé
  3. Le développeur modifie la source → À réviser
  4. Le traducteur met à jour → Validé
  5. Le développeur supprime le code → Obsolète

Partie 2 : Localisation SwiftUI

LocalizedStringKey (Automatique)

Les vues SwiftUI avec des paramètres String prennent automatiquement en charge la localisation :

// ✅ Automatiquement localisable
Text("Bienvenue à la WWDC !")
Label("Merci d'avoir magasiné chez nous !", systemImage: "bag")
Button("Paiement") { }

// Xcode extrait ces chaînes vers le catalogue de chaînes

Fonctionnement : SwiftUI utilise LocalizedStringKey en interne, qui recherche les chaînes dans les catalogues de chaînes.

String(localized:) avec Commentaires

Pour une localisation explicite dans le code Swift :

// Basique
let titre = String(localized: "Bienvenue à la WWDC !")

// Avec commentaire pour les traducteurs
let titre = String(localized: "Bienvenue à la WWDC !",
                   comment: "Titre de la bannière de notification")

// Avec table personnalisée
let titre = String(localized: "Bienvenue à la WWDC !",
                   table: "NotificationsWWDC",
                   comment: "Titre de la bannière de notification")

// Avec valeur par défaut (clé ≠ texte anglais)
let titre = String(localized: "TITRE_NOTIFICATION_WWDC",
                   defaultValue: "Bienvenue à la WWDC !",
                   comment: "Titre de la bannière de notification")

Bonnes pratiques : Incluez toujours un comment pour donner le contexte aux traducteurs.

LocalizedStringResource (Localisation différée)

Pour passer des chaînes localisables à d'autres fonctions :

import Foundation

struct VueCarte: View {
    let titre: LocalizedStringResource
    let sousTitre: LocalizedStringResource

    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 10.0)
            VStack {
                Text(titre)      // Résolu au moment du rendu
                Text(sousTitre)
            }
            .padding()
        }
    }
}

// Utilisation
VueCarte(
    titre: "Achats récents",
    sousTitre: "Articles commandés la semaine dernière."
)

Différence clé : LocalizedStringResource reporte la recherche jusqu'à son utilisation, permettant aux vues personnalisées d'être entièrement localisables.

AttributedString avec Markdown

// Le formatage Markdown est préservé selon les langues
let sousTitre = AttributedString(localized: "Texte en **gras** et en _italique_")

Partie 3 : UIKit et Foundation

Macro NSLocalizedString

// Basique
let titre = NSLocalizedString("Achats récents", comment: "Titre du bouton")

// Avec table
let titre = NSLocalizedString("Achats récents",
                             tableName: "Shopping",
                             comment: "Titre du bouton")

// Avec bundle
let titre = NSLocalizedString("Achats récents",
                             tableName: nil,
                             bundle: .main,
                             value: "",
                             comment: "Titre du bouton")

Bundle.localizedString

let bundlePersonnalise = Bundle(for: MonFramework.self)
let texte = bundlePersonnalise.localizedString(forKey: "Bienvenue",
                                        value: nil,
                                        table: "MonFramework")

Macros personnalisées

// Objective-C
#define MaChaineLocalisee(key, comment) \
    [monBundle localizedStringForKey:key value:nil table:nil]

Localisation d'Info.plist

Localisez le nom de l'application, les permissions, etc. :

  1. Sélectionnez Info.plist
  2. Éditeur → Ajouter une localisation
  3. Créez InfoPlist.strings pour chaque langue :
// InfoPlist.strings (Espagnol)
"CFBundleName" = "Mi Aplicación";
"NSCameraUsageDescription" = "La app necesita acceso a la cámara para tomar fotos.";

Partie 4 : Pluriels

Différentes langues ont des règles de pluriel différentes :

  • Anglais : 2 formes (un, autre)
  • Russe : 3 formes (un, peu, plusieurs)
  • Polonais : 3 formes (un, peu, autre)
  • Arabe : 6 formes (zéro, un, deux, peu, plusieurs, autre)

Gestion des pluriels en SwiftUI

// Xcode crée automatiquement les variations plurielles
Text("\(count) articles")

// Avec formatage personnalisé
Text("\(nombreVisiteurs) Visiteurs récents")

Dans le catalogue de chaînes :

{
  "strings" : {
    "%lld Visiteurs récents" : {
      "localizations" : {
        "en" : {
          "variations" : {
            "plural" : {
              "one" : {
                "stringUnit" : {
                  "state" : "translated",
                  "value" : "%lld Visiteur récent"
                }
              },
              "other" : {
                "stringUnit" : {
                  "state" : "translated",
                  "value" : "%lld Visiteurs récents"
                }
              }
            }
          }
        }
      }
    }
  }
}

Format d'export XLIFF

Lors de l'export pour traduction (Fichier → Exporter les localisations) :

Hérité (stringsdict) :

<trans-unit id="/%lld Visiteurs récents:dict/NSStringLocalizedFormatKey:dict/:string">
    <source>%#@visiteursRecents@</source>
</trans-unit>

<trans-unit id="/%lld Visiteurs récents:dict/visiteursRecents:dict/one:dict/:string">
    <source>%lld Visiteur récent</source>
</trans-unit>

Catalogue de chaînes (plus propre) :

<trans-unit id="%lld Visiteurs récents|==|plural.one">
    <source>%lld Visiteur récent</source>
</trans-unit>

<trans-unit id="%lld Visiteurs récents|==|plural.other">
    <source>%lld Visiteurs récents</source>
</trans-unit>

Substitutions avec variables plurielles

// Plusieurs variables avec différentes formes plurielles
let message = String(localized: "\(nombreChansons) chansons sur \(nombreAlbums) albums")

Xcode crée des variations pour la forme plurielle de chaque variable :

  • nombreChansons : un, autre
  • nombreAlbums : un, autre
  • Combinaisons totales : 2 × 2 = 4 entrées de traduction

Partie 5 : Variations de périphérique et de largeur

Chaînes spécifiques à un appareil

Texte différent selon la plateforme :

// Même code, chaînes différentes selon l'appareil
Text("Boutique de nourriture pour oiseaux")

Variations dans le catalogue de chaînes :

{
  "Boutique de nourriture pour oiseaux" : {
    "localizations" : {
      "en" : {
        "variations" : {
          "device" : {
            "applewatch" : {
              "stringUnit" : {
                "value" : "Nourriture oiseaux"
              }
            },
            "other" : {
              "stringUnit" : {
                "value" : "Boutique de nourriture pour oiseaux"
              }
            }
          }
        }
      }
    }
  }
}

Résultat :

  • iPhone/iPad : « Boutique de nourriture pour oiseaux »
  • Apple Watch : « Nourriture oiseaux » (plus court pour petit écran)

Variations de largeur

Pour la police dynamique et les classes de taille :

Text("Paramètres de l'application")

Le catalogue de chaînes peut fournir un texte plus court pour les largeurs étroites.


Partie 6 : Prise en charge RTL

Mise en miroir de la disposition

SwiftUI met automatiquement en miroir les dispositions pour les langues RTL :

// ✅ Se met automatiquement en miroir pour l'arabe/hébreu
HStack {
    Image(systemName: "chevron.right")
    Text("Suivant")
}

// iPhone (Anglais) : [>] Suivant
// iPhone (Arabe) :  Suivant [<]

Leading/Trailing vs Gauche/Droite

Utilisez toujours les directions sémantiques :

// ✅ Correct - se met en miroir automatiquement
.padding(.leading, 16)
.frame(maxWidth: .infinity, alignment: .leading)

// ❌ Incorrect - ne se met pas en miroir
.padding(.left, 16)
.frame(maxWidth: .infinity, alignment: .left)

Images et icônes

Marquez les images qui doivent ou ne doivent pas être retournées :

// ✅ Directionnel - se met en miroir pour RTL
Image(systemName: "chevron.forward")

// ✅ Non directionnel - jamais mis en miroir
Image(systemName: "star.fill")

// Images personnalisées
Image("boutonRetour")
    .flipsForRightToLeftLayoutDirection(true)

Test en mode RTL

Schéma Xcode :

  1. Éditer le schéma → Exécution → Options
  2. Langue de l'application : Arabe / Hébreu
  3. OU : Langue de l'application → Pseudo-langue droite à gauche

Simulateur : Réglages → Général → Langue et région → Ordre des langues préférées

Aperçu SwiftUI :

struct AperçuVueContenu: PreviewProvider {
    static var previews: some View {
        VueContenu()
            .environment(\.layoutDirection, .rightToLeft)
            .environment(\.locale, Locale(identifier: "ar"))
    }
}

Partie 7 : Formatage adapté à la locale

DateFormatter

let formateur = DateFormatter()
formateur.locale = Locale.current  // ✅ Utilisez la locale actuelle
formateur.dateStyle = .long
formateur.timeStyle = .short

let chaîneDate = formateur.string(from: Date())

// États-Unis : "January 15, 2024 at 3:30 PM"
// France : "15 janvier 2024 à 15:30"
// Japon : "2024年1月15日 15:30"

Ne codez jamais en dur les formats de date :

// ❌ Incorrect - ne fonctionne pas dans d'autres langues
formateur.dateFormat = "MM/dd/yyyy"

// ✅ Correct - s'adapte à la locale
formateur.dateStyle = .short

NumberFormatter pour la devise

let formateur = NumberFormatter()
formateur.locale = Locale.current
formateur.numberStyle = .currency

let chaînePrix = formateur.string(from: 29.99)

// États-Unis : "$29.99"
// Royaume-Uni : "£29.99"
// Japon : "¥30" (arrondi à l'entier)
// France : "29,99 €" (virgule décimale, espace avant le symbole)

MeasurementFormatter

let distance = Measurement(value: 100, unit: UnitLength.meters)

let formateur = MeasurementFormatter()
formateur.locale = Locale.current

let chaîneDistance = formateur.string(from: distance)

// États-Unis : "328 ft" (convertit en unités impériales)
// Pays utilisant le système métrique : "100 m"

Tri spécifique à la locale

let noms = ["Ångström", "Zèbre", "Pomme"]

// ✅ Tri adapté à la locale
let triés = noms.sorted { (lhs, rhs) in
    lhs.localizedStandardCompare(rhs) == .orderedAscending
}

// Suède : ["Ångström", "Pomme", "Zèbre"]  (Å vient en premier en suédois)
// France : ["Pomme", "Zèbre", "Ångström"]  (Å traité comme A)

Partie 8 : Localisation des raccourcis d'application

Phrases avec paramètres

import AppIntents

struct IntentionAfficherMeilleursDonuts: AppIntent {
    static var title: LocalizedStringResource = "Afficher les meilleurs donuts"

    @Parameter(title: "Période")
    var période: Période

    static var parameterSummary: some ParameterSummary {
        Summary("\(.applicationName) Tendances pour \($période)") {
            \$période
        }
    }
}

Le catalogue de chaînes capture les phrases suivantes :

  • « Afficher les meilleurs donuts »
  • « MonApplication Tendances pour cette semaine »
  • « MonApplication Tendances pour ce mois »

Localisation du nom de l'application

// Dans l'intention
Summary("\(.applicationName) Tendances pour \($période)")

Le nom de l'application est automatiquement développé à partir d'Info.plist (localisé).


Partie 9 : Fonctionnalités Xcode 26+

Génération automatique de symboles

Xcode 26+ génère automatiquement des symboles typés pour toutes les clés du catalogue de chaînes :

// Avant (Xcode 15-25)
let titre = String(localized: "Bienvenue à la WWDC !")

// Après (Xcode 26+)
let titre = String(localized: .localizable.bienvenueALaWWDC)

Avantages :

  • Vérification à la compilation des clés manquantes
  • Complétion automatique
  • Pas de fautes de frappe
  • Renommage rapide
  • Meilleure prise en charge des refactorisations

Macro #bundle

Xcode 26+ introduit la macro #bundle pour lier explicitement les ressources :

// À l'intérieur d'un package ou d'un framework
struct MonFramework {
    static let bundle = #bundle
}

// Utilisation avec les catalogues de chaînes
extension String.LocalizationValue {
    static let framework = String.LocalizationValue.Table(
        "MonFramework",
        bundle: MonFramework.bundle
    )
}

Génération de commentaires par IA

Xcode 26+ peut générer automatiquement des commentaires de traduction à l'aide de l'IA sur l'appareil :

  1. Ouvrez le catalogue de chaînes
  2. Sélectionnez une entrée (ou plusieurs)
  3. Éditeur → Générer des commentaires de traduction avec l'IA
  4. Examinez et approuvez les commentaires générés

Partie 10 : Xcode 26 – Migration depuis les fichiers hérités

Plan de migration : .strings → .xcstrings

Étape 1 : Créer un catalogue de chaînes

  • Dans Xcode 26, utilisez Fichier → Nouveau → Catalogue de chaînes
  • Plus facile : sélectionnez un fichier .strings existant → Éditeur → Convertir en catalogue de chaînes

Étape 2 : Activer l'extraction automatique

  • Construire les paramètres
  • « La localisation préfère les catalogues de chaînes » → Oui

Étape 3 : Supprimer les fichiers hérités

  • Après la conversion, supprimez les fichiers .strings et .stringsdict
  • Le catalogue de chaînes est la source de vérité

Étape 4 : Ajouter toutes les langues

  • Le catalogue de chaînes prend en charge toutes les langues en un seul endroit
  • Plus besoin de fichiers de langue multiples

Partie 11 : Dépannage

Problèmes courants

1. Chaînes non extraites

  • Vérifiez que l'extraction automatique est activée
  • Utilisez des littéraux de chaîne (pas de variables) dans les vues SwiftUI
  • Construisez le projet pour déclencher l'extraction

2. Traductions qui ne s'affichent pas

  • Vérifiez que la chaîne est marquée comme « Validé » (✅)
  • Vérifiez l'identifiant de la table de chaînes (par défaut « Localizable »)
  • Redémarrez l'application

3. Formes plurielles incorrectes

  • Vérifiez les règles de pluriel du catalogue de chaînes
  • Utilisez %lld au lieu de %d pour des raisons de sécurité de type
  • Testez avec différentes valeurs de comptage

4. Problèmes de mise en page RTL

  • Utilisez leading/trailing au lieu de left/right
  • Testez avec une pseudo-langue
  • Vérifiez le retournement de l'image

5. Entrées obsolètes

  • Nettoyez régulièrement les chaînes dont l'état est « Obsolète » (🔴)
  • Le catalogue de chaînes garde une trace de ce qui est utilisé
  • Supprimez-les après la migration

Commandes CLI

# Exporter les localisations pour traduction
xcodebuild -exportLocalizations -localizationPath ./output

# Importer les localisations
xcodebuild -importLocalizations -localizationPath ./output

# Vérifier les chaînes manquantes
plutil -lint Localizable.xcstrings

Ressources

Dernière mise à jour : 2025

Individual skills in this repo

This repo contains 7 individual skills — each has its own dedicated page.

IGTA-Tech/claude-skills-research

Use when implementing SwiftUI animations, understanding VectorArithmetic, using @Animatable macro, choosing between spring and timing curve animations, or debugging animation behavior - comprehensive animation reference from iOS 13 through iOS 26

IGTA-Tech/claude-skills-research

Use when CAAnimation completion handler doesn't fire, spring physics look wrong on device, animation duration mismatches actual time, gesture + animation interaction causes jank, or timing differs between simulator and real hardware - systematic CAAnimation diagnosis with CATransaction patterns, frame rate awareness, and device-specific behavior

IGTA-Tech/claude-skills-research

This skill should be used when comparing two videos to analyze compression results or quality differences. Generates interactive HTML reports with quality metrics (PSNR, SSIM) and frame-by-frame visual comparisons. Triggers when users mention "compare videos", "video quality", "compression analysis", "before/after compression", or request quality assessment of compressed videos.

IGTA-Tech/claude-skills-research

Download YouTube videos and HLS streams (m3u8) from platforms like Mux, Vimeo, etc. using yt-dlp and ffmpeg. Use this skill when users request downloading videos, extracting audio, handling protected streams with authentication headers, or troubleshooting download issues like nsig extraction failures, 403 errors, or cookie extraction problems.

IGTA-Tech/claude-skills-research

Write high-converting landing page copy using proven frameworks like PAS (Problem-Agitate-Solution), AIDA, and StoryBrand. Creates headlines, value propositions, CTAs, and full page sections optimized for conversion. Use when users need landing page copy, sales page content, or marketing website text.

IGTA-Tech/claude-skills-research

Downloads videos from YouTube and other platforms for offline viewing, editing, or archival. Handles various formats and quality options.

IGTA-Tech/claude-skills-research

Download YouTube video transcripts when user provides a YouTube URL or asks to download/get/fetch a transcript from YouTube. Also use when user wants to transcribe or get captions/subtitles from a YouTube video.

Skills associés