Comment localiser une application React Native

React Native n'inclut pas de systeme de localisation integre. Vous avez besoin d'une bibliotheque tierce. La configuration la plus courante est react-native-localize pour detecter la locale de l'appareil combinee avec i18next ou react-intl pour gerer les traductions. Ce guide couvre la mise en place complete a partir de zero.

Choisir votre bibliotheque i18n

i18next

npm install i18next react-i18next
npm install react-native-localize
npm install @os-team/i18next-react-native-language-detector

Le choix le plus populaire pour React Native. Vaste ecosysteme avec des plugins pour la detection de langue, le chargement backend et le formatage. Communaute active, bonne documentation, et fonctionne avec Expo et React Native nu. Supporte les namespaces, pluriels et l'interpolation nativement.

react-intl (FormatJS)

npm install react-intl
npm install react-native-localize

Base sur le standard de format de message ICU. Bon support des pluriels, dates, nombres et temps relatif. Plus lourd que i18next. A privilegier si vous utilisez deja FormatJS sur le web et souhaitez une coherence de format entre les plateformes.

Chargeur JSON custom

// No library needed
import en from './locales/en.json';
import fr from './locales/fr.json';

const t = (key) => translations[locale][key];

Fonctionne pour les petites applications avec moins de 100 chaines et sans regles de pluriel. Aucune dependance, pas d'etape de build. Vous perdez l'interpolation, les pluriels et le decoupage par namespace. Deconseille pour les applications en production qui vont grandir.

Configurer i18next avec React Native

i18next est le choix le plus courant. Voici la configuration complete, etape par etape.

Configuration i18next de zero

1

Installer les packages

Lancez npm install i18next react-i18next react-native-localize. Si vous utilisez TypeScript, installez aussi @types/react-i18next. Pour les projets Expo, expo install react-native-localize.

2

Creer les fichiers JSON de traduction

Creez un repertoire locales avec un fichier JSON par langue : locales/en.json, locales/fr.json, locales/de.json. Chaque fichier est un objet plat ou imbrique avec les cles et valeurs de traduction.

3

Configurer i18next

Creez un fichier de configuration i18n.ts qui initialise i18next avec vos ressources, la langue par defaut et le comportement de repli. Importez ce fichier en haut de votre point d'entree App.

4

Utiliser le hook useTranslation

i18next fournit le hook useTranslation via react-i18next. Il retourne une fonction t que vous appelez avec une cle de traduction. Le hook re-rend votre composant quand la langue change.

5

Envelopper votre app avec I18nextProvider

Dans votre App.tsx, importez l'instance i18n et enveloppez votre composant racine avec I18nextProvider. Cela rend le contexte de traduction disponible pour tous les composants enfants.

package.json (dependencies)json
{
"dependencies": {
"i18next": "^24.2.0",
"react-i18next": "^15.4.0",
"react-native-localize": "^3.3.0"
}
}
locales/en.jsonjson
{
"common": {
"save": "Save",
"cancel": "Cancel",
"delete": "Delete"
},
"home": {
"title": "Welcome",
"subtitle": "Start building something great",
"itemCount_one": "{{count}} item",
"itemCount_other": "{{count}} items"
},
"settings": {
"title": "Settings",
"language": "Language",
"notifications": "Notifications"
}
}
locales/fr.jsonjson
{
"common": {
"save": "Enregistrer",
"cancel": "Annuler",
"delete": "Supprimer"
},
"home": {
"title": "Bienvenue",
"subtitle": "Commencez a construire quelque chose de genial",
"itemCount_one": "{{count}} element",
"itemCount_other": "{{count}} elements"
},
"settings": {
"title": "Parametres",
"language": "Langue",
"notifications": "Notifications"
}
}
src/i18n.tstypescript
import i18n from 'i18next';
import { initReactI18next } from 'react-i18next';
import * as RNLocalize from 'react-native-localize';

import en from '../locales/en.json';
import fr from '../locales/fr.json';

const deviceLanguage = RNLocalize.getLocales()[0]?.languageCode ?? 'en';

i18n
.use(initReactI18next)
.init({
resources: {
en: { translation: en },
fr: { translation: fr },
},
lng: deviceLanguage,
fallbackLng: 'en',
interpolation: {
escapeValue: false, // React Native already handles escaping
},
defaultNS: 'translation',
});

export default i18n;
src/HomeScreen.tsxtypescript
import React from 'react';
import { View, Text, StyleSheet } from 'react-native';
import { useTranslation } from 'react-i18next';

export function HomeScreen() {
const { t } = useTranslation();
const itemCount = 3;

return (
<View style={styles.container}>
<Text style={styles.title}>{t('home.title')}</Text>
<Text style={styles.subtitle}>{t('home.subtitle')}</Text>
<Text>{t('home.itemCount', { count: itemCount })}</Text>
</View>
);
}

const styles = StyleSheet.create({
container: { flex: 1, padding: 16 },
title: { fontSize: 28, fontWeight: 'bold' },
subtitle: { fontSize: 16, color: '#666', marginTop: 4 },
});

Utilisez les namespaces

Utilisez les namespaces pour decouper les traductions par ecran ou fonctionnalite. Cela garde les fichiers gerable a mesure que votre application grandit.

Detecter la locale de l'appareil

react-native-localize lit les parametres de langue et de region actuels de l'appareil. Utilisez-le pour definir la langue initiale dans i18next et pour reagir aux changements de langue pendant que l'application tourne.

src/useDeviceLocale.tstypescript
import * as RNLocalize from 'react-native-localize';
import { useEffect } from 'react';
import i18n from './i18n';

export function useDeviceLocaleSync() {
useEffect(() => {
const onChange = () => {
const bestLang = RNLocalize.findBestLanguageTag(
Object.keys(i18n.options.resources ?? {})
);
if (bestLang?.languageTag) {
i18n.changeLanguage(bestLang.languageTag);
}
};

// Listen for language changes (user changes device language while app is open)
RNLocalize.addEventListener('change', onChange);
return () => {
RNLocalize.removeEventListener('change', onChange);
};
}, []);
}

Support RTL dans React Native

React Native supporte les layouts RTL via l'API I18nManager. Quand un utilisateur passe en arabe ou en hebreu, vous devez forcer le RTL et redemarrer l'application pour que les changements de layout prennent effet.

src/rtl.tstypescript
import { I18nManager } from 'react-native';
import * as RNLocalize from 'react-native-localize';
import RNRestart from 'react-native-restart'; // optional, for hot restart

const RTL_LANGUAGES = ['ar', 'he', 'fa', 'ur'];

export function configureRTL() {
const locale = RNLocalize.getLocales()[0];
const shouldBeRTL = RTL_LANGUAGES.includes(locale?.languageCode ?? '');

if (I18nManager.isRTL !== shouldBeRTL) {
I18nManager.forceRTL(shouldBeRTL);
I18nManager.allowRTL(shouldBeRTL);

// Restart required for layout direction change to take effect
// RNRestart.restart(); // Uncomment if using react-native-restart
}
}

Appelez configureRTL() tot dans le point d'entree de votre application, avant que les composants ne se rendent. Utilisez flexDirection: 'row' avec des verifications I18nManager.isRTL pour toute logique de layout personnalisee qui doit respecter la direction du texte.

💡

LocaleKit + React Native

LocaleKit supporte les fichiers de localisation JSON. Lancez localekit translate pour completer les cles manquantes dans tous vos fichiers JSON de langue.

FAQ localisation React Native

Comment gerer les pluriels dans React Native ?

i18next gere les pluriels avec des cles suffixees. Definissez key_one, key_other (et key_zero, key_few, key_many pour les langues qui en ont besoin). Passez { count: n } en appelant t(). i18next choisit la forme correcte selon le nombre et les regles de pluriel de la langue courante.

Comment tester les changements de locale pendant le developpement ?

Sur le simulateur iOS, allez dans Reglages > General > Langue et region. Sur l'emulateur Android, Parametres > Systeme > Langue. Pour iterer plus vite, ajoutez un ecran de selection de langue de debug qui appelle i18n.changeLanguage() directement sans redemarrer.

Comment charger les traductions a la demande (lazy-loading) ?

Utilisez i18next-http-backend ou i18next-resources-to-backend pour charger les fichiers de traduction a la demande. C'est utile pour les applications avec plus de 20 langues ou le bundling de toutes les traductions augmente la taille de l'application. Chargez la langue active au demarrage et recuperez les autres quand l'utilisateur change.

Est-ce que ca fonctionne avec Expo ?

Oui. expo install react-native-localize ajoute le module natif. Tout le reste (i18next, fichiers JSON, useTranslation) fonctionne pareil. Expo Go a un support de locale limite, donc testez sur un dev build ou un build standalone pour une detection de locale complete.

On a localise notre application React Native dans 8 langues en un seul sprint en utilisant i18next et LocaleKit pour le gros du travail de traduction. Le plus difficile n'etait pas la mise en place du code - c'etait de se mettre d'accord sur la structure des fichiers JSON. Commencez avec des namespaces par ecran et vous vous epargnerez un refactoring plus tard.

Nicolas Charvoz, iOS Engineer chez Betclic

Arrêtez de gérer vos fichiers de traduction manuellement

LocaleKit détecte, traduit et synchronise tous vos fichiers de localisation — iOS, Android, Flutter et plus. Tout tourne localement sur votre machine.

Respect de la vie privée. Aucun cloud requis.