---
title: "Traduire un JSON i18n en arabe par LLM : les pluriels"
description: "Traduire des fichiers JSON i18n en arabe via une API LLM : figer les variables, générer les six pluriels arabes, valider l’ICU en CI et isoler les noms insérés."
url: https://broadrouter.com/fr/blog/translate-app-strings-to-arabic-llm/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/translate-app-strings-to-arabic-llm/) (mis à jour le 2026-11-15).

# Traduire les chaînes d’app en arabe par LLM : variables et pluriels

Par l’équipe BroadNet Inference · 7 min de lecture · Publié 2026-11-15

Envoyez les chaînes en JSON en remplaçant chaque variable par un marqueur, demandez les six formes plurielles arabes (zero, one, two, few, many, other) et construisez le pluriel ICU dans le code, pas dans le modèle. Validez en CI : mêmes clés, mêmes arguments et balises, six formes présentes. Entourez les noms insérés d’isolats Unicode pour que le texte de droite à gauche s’affiche correctement.

## À retenir

-   L’arabe compte six catégories de pluriel cardinal dans CLDR. Les fichiers source anglais en ont deux : le modèle doit donc écrire quatre formes absentes de la source.
-   Une forme arabe manquante échoue en silence. Dans notre test, un message ICU avec seulement one et other affichait « 2 ملف » pour 2 fichiers au lieu du duel ملفان, sans aucune erreur.
-   Remplacez variables et balises par des marqueurs comme ⟦0⟧ avant la requête, et restaurez-les après. Le modèle ne peut pas traduire ce qu’il ne voit pas.
-   Laissez le code assembler la syntaxe de pluriel ICU à partir de six chaînes simples. Analysez ensuite chaque message avec le parser FormatJS en CI et faites échouer le build au moindre manque.
-   Les noms interpolés et les noms de produits en caractères latins dans un texte arabe doivent être isolés : bdi ou dir="auto" en HTML, U+2068 et U+2069 en texte brut.

**Sur cette page**

1.  Pourquoi les pluriels arabes cassent-ils les fichiers de chaînes traduits automatiquement ?
2.  Comment envoyer les chaînes au modèle ?
3.  Le script de traduction
4.  Comment valider le fichier arabe en CI ?
5.  Et l’affichage de droite à gauche ?
6.  Qui doit relire le résultat ?
7.  Combien ça coûte ?
8.  Où se situe BroadNet Inference

Traduire les fichiers de chaînes d’une application n’a rien à voir avec traduire de la prose. Chaque valeur est courte, souvent sans contexte, et porte une syntaxe que le modèle ne doit pas toucher : variables, balises HTML et règles de pluriel. L’arabe rend la dernière difficile. Les fichiers anglais contiennent deux formes plurielles ; l’arabe en exige six. Cet article construit une petite chaîne sur un LLM compatible OpenAI : figer les variables, demander six chaînes plurielles simples, assembler la syntaxe ICU dans le code, puis tout valider en CI.

Pour traduire des documents, des tickets et des contrats, voir [Traduction arabe–anglais avec des LLM](https://broadrouter.com/fr/blog/arabic-english-translation-llm/), qui traite du ton, des glossaires et de l’évaluation pour la prose.

## Pourquoi les pluriels arabes cassent-ils les fichiers de chaînes traduits automatiquement ?

Unicode CLDR, que suivent `Intl.PluralRules`, ICU et i18next, donne à l’arabe six catégories cardinales :

| Catégorie | Règle CLDR | Exemples de nombres | Exemple : « fichier » |
| --- | --- | --- | --- |
| zero | n = 0 | 0 | لا توجد ملفات |
| one | n = 1 | 1 | ملف واحد |
| two | n = 2 | 2 | ملفان (duel) |
| few | n % 100 = 3..10 | 3–10, 103–110 | 5 ملفات (pluriel) |
| many | n % 100 = 11..99 | 11–99, 111 | 11 ملفًا (singulier, accusatif) |
| other | tout le reste | 100–102, 1000, 0.5 | 100 ملف (singulier) |

Deux détails piègent les gens. D’abord, les catégories ne sont pas les nombres : 103 est few et 111 est many. Ensuite, une source anglaise ne donne au modèle que `one` et `other` ; il doit donc inventer quatre formes à partir de la seule grammaire. La plupart des échecs viennent d’un modèle qui recopie la paire anglaise.

L’échec est silencieux. Nous avons rendu avec intl-messageformat 12.1.5 un message arabe qui n’avait que `one` et `other` : 0, 2 et 11 fichiers sortaient tous en « N ملف ». i18next 27.1.2 s’est comporté de même quand la clé `_many` manquait : 11 fichiers affichaient le texte de `_other`. Pas d’erreur, pas d’avertissement, juste un arabe faux.

## Comment envoyer les chaînes au modèle ?

Regroupez-les. Une requête par chaîne gaspille des tokens sur le prompt système et perd le contexte entre chaînes liées. Envoyez 50 à 200 clés à la fois sous forme d’objet JSON, groupées par écran ou par fonction, pour que « Save » à côté de « Cancel » se lise comme un bouton.

Trois règles rendent la réponse vérifiable :

1.  **Figer les variables.** Remplacez `{name}`, les variables i18next à doubles accolades, `%s`, `%1$s` et les balises comme `<b>` par des marqueurs comme ⟦0⟧. Le modèle voit « Welcome back, ⟦0⟧! » et ne peut pas traduire `name` en اسم.
2.  **Demander les formes plurielles en chaînes simples.** Envoyez les textes anglais `one` et `other` et demandez six chaînes arabes. Le code construit la syntaxe ICU. Le modèle n’écrit jamais d’accolade.
3.  **Fournir un glossaire et une liste de termes à ne pas traduire.** Noms de produits, noms de forfaits et termes qu’utilise votre support. La [section glossaire de l’article sur la traduction](https://broadrouter.com/fr/blog/arabic-english-translation-llm/) explique pourquoi cela compte plus que le choix du modèle.

## Le script de traduction

Le fichier source utilise ICU MessageFormat, la syntaxe que documente FormatJS. Le même gel fonctionne pour le format JSON propre à i18next, dont les clés de pluriel se terminent par `_zero`, `_one`, `_two`, `_few`, `_many` et `_other`.

```json
{
  "save": "Save",
  "welcome": "Welcome back, {name}!",
  "invite": "<b>{inviter}</b> invited you to the {workspace} workspace",
  "billing": "Pay with AcmePay",
  "files": "{count, plural, one {# file} other {# files}}"
}
```

```python
import json, os, re
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

FORMS = ["zero", "one", "two", "few", "many", "other"]
# ICU arguments, double-brace and printf placeholders, HTML-style tags
PH = re.compile(r"\{\{\s*\w+\s*\}\}|\{\w+\}|%(?:\d+\$)?[sdif@]|</?\w+[^>]*>")
PLURAL = re.compile(r"^\{(\w+), plural,(.*)\}$", re.S)

def freeze(text):
    """Replace each placeholder with ⟦n⟧ so the model cannot translate or break it."""
    found = PH.findall(text)
    for i, p in enumerate(found):
        text = text.replace(p, f"⟦{i}⟧", 1)
    return text, found

def thaw(text, found):
    for i, p in enumerate(found):
        text = text.replace(f"⟦{i}⟧", p)
    return text

def branches(body):
    """'one {# file} other {# files}' -> {'one': '# file', 'other': '# files'}."""
    out, i = {}, 0
    while i < len(body):
        m = re.compile(r"\s*([=\w]+)\s*\{").match(body, i)
        if not m:
            break
        depth, j = 1, m.end()
        while depth:
            depth += {"{": 1, "}": -1}.get(body[j], 0)
            j += 1
        out[m.group(1)] = body[m.end():j - 1]
        i = j
    return out

SYSTEM = """You translate app interface strings from English to Modern Standard Arabic.
Reply with one JSON object only: {"STRINGS": {key: Arabic}, "PLURALS": {key: {six forms}}}.
Rules:
- ⟦0⟧, ⟦1⟧ ... are placeholders. Keep every one exactly once and unchanged; move it if Arabic word order needs it.
- # stands for the number. Keep it where the number should appear.
- Interface style: short, no full stops on buttons or labels.
- Never translate terms in DO_NOT_TRANSLATE. Use GLOSSARY translations exactly.
- For each PLURALS key, return all six Arabic forms: zero, one, two, few, many, other.
  zero = none; one = singular without a number; two = dual without a number;
  few = 3-10: # + plural noun; many = 11-99: # + singular noun in the accusative;
  other = 100, 1000 and also 0.5 and 1.5: # + singular noun."""

def translate(src, glossary=None, dnt=(), model="broadnet/qwen3.8-27b"):
    strings, plurals, frozen = {}, {}, {}
    for key, text in src.items():
        m = PLURAL.match(text)
        if m:
            b = branches(m.group(2))
            fone, ph = freeze(b.get("one", b["other"]))
            fother, _ = freeze(b["other"])
            plurals[key] = {"one": fone, "other": fother}
            frozen[key] = (m.group(1), ph)
        elif "{" in PH.sub("", text):
            raise ValueError(f"{key}: nested ICU, send to a human")
        else:
            strings[key], ph = freeze(text)
            frozen[key] = (None, ph)
    payload = {"STRINGS": strings, "PLURALS": plurals,
               "GLOSSARY": glossary or {}, "DO_NOT_TRANSLATE": list(dnt)}
    r = client.chat.completions.create(
        model=model, max_tokens=4000, temperature=0.2,
        messages=[{"role": "system", "content": SYSTEM},
                  {"role": "user", "content": json.dumps(payload, ensure_ascii=False)}])
    out = json.loads(r.choices[0].message.content)
    ar = {k: thaw(v, frozen[k][1]) for k, v in out.get("STRINGS", {}).items() if k in frozen}
    for k, forms in out.get("PLURALS", {}).items():
        if k not in frozen:
            continue
        arg, ph = frozen[k]
        ar[k] = "{%s, plural, %s}" % (arg, " ".join(
            f + " {" + thaw(forms[f], ph) + "}" for f in FORMS if f in forms))
    return ar

en = json.load(open("en.json"))
ar = translate(en, glossary={"workspace": "مساحة العمل"}, dnt=["AcmePay"])
json.dump(ar, open("ar.json", "w"), ensure_ascii=False, indent=2)
```

Nous l’avons exécuté avec le SDK Python d’OpenAI contre un serveur fictif local, pas contre l’API réelle, avec une réponse arabe préenregistrée. La requête que verrait le modèle contenait « Welcome back, ⟦0⟧! » et « ⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace », et le script a écrit ce `ar.json` :

```json
{
  "save": "حفظ",
  "welcome": "مرحبًا بعودتك يا {name}!",
  "invite": "دعاك <b>{inviter}</b> إلى مساحة العمل {workspace}",
  "billing": "ادفع عبر AcmePay",
  "files": "{count, plural, zero {لا توجد ملفات} one {ملف واحد} two {ملفان} few {# ملفات} many {# ملفًا} other {# ملف}}"
}
```

Remarques sur le code :

-   **Les marqueurs se déplacent, ils ne disparaissent pas.** L’arabe place souvent le verbe en tête, donc ⟦0⟧ peut bouger. Le contrôle ci-dessous compte les marqueurs ; leur position lui est indifférente.
-   **L’ICU imbriqué part chez un humain.** Un `select` dans un `plural` est rare et facile à casser. Le script le refuse plutôt que de deviner.
-   **`max_tokens=4000` laisse de la place au raisonnement.** D’après la documentation de BroadNet, DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et ce raisonnement compte dans [max\_tokens](https://broadrouter.com/fr/glossary/max-tokens/). Voir [réponses vides des modèles de raisonnement](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **`json.loads` peut échouer.** Encadrez-le et renvoyez une fois avec l’erreur ; [réparer un JSON invalide produit par un LLM](https://broadrouter.com/fr/blog/fix-invalid-json-from-llm/) propose une fonction de réparation testée. Sur GLM 5.3 et Qwen3.8 27B, les deux modèles BroadNet documentés avec [sortie structurée](https://broadrouter.com/fr/glossary/structured-output/), ajoutez aussi un schéma `response_format`. Le contrôle ci-dessous reste nécessaire dans tous les cas.

## Comment valider le fichier arabe en CI ?

Analysez chaque message avec le parser qu’utilise votre application à l’exécution, et comparez-le à la source. Ce script Node utilise `@formatjs/icu-messageformat-parser` (version 3.5.23 dans notre test) :

```js
// node check-ar.mjs en.json ar.json  -> exits 1 on any problem
import { readFileSync } from "node:fs";
import { parse, TYPE } from "@formatjs/icu-messageformat-parser";

const AR_FORMS = ["zero", "one", "two", "few", "many", "other"];
const [en, ar] = process.argv.slice(2).map((p) => JSON.parse(readFileSync(p, "utf8")));
const errors = [];

// Collect argument and tag names; return the plural elements too.
function walk(nodes, names = [], plurals = []) {
  for (const n of nodes) {
    if (n.type === TYPE.literal || n.type === TYPE.pound) continue;
    names.push(n.type === TYPE.tag ? `<${n.value}>` : `{${n.value}}`);
    if (n.type === TYPE.tag) walk(n.children, names, plurals);
    if (n.type === TYPE.plural) plurals.push(n);
    if (n.options) for (const o of Object.values(n.options)) walk(o.value, [], plurals);
  }
  return { names: names.sort().join(" "), plurals };
}

for (const key of Object.keys(en)) {
  if (!(key in ar)) { errors.push(`${key}: missing`); continue; }
  let src, dst;
  try { src = walk(parse(en[key])); dst = walk(parse(ar[key], { requiresOtherClause: true })); }
  catch (e) { errors.push(`${key}: ICU syntax error ${e.message}`); continue; }
  if (src.names !== dst.names) errors.push(`${key}: arguments differ: [${src.names}] vs [${dst.names}]`);
  for (const p of dst.plurals) {
    const missing = AR_FORMS.filter((f) => !(f in p.options));
    if (missing.length) errors.push(`${key}: plural {${p.value}} lacks ${missing.join(", ")}`);
  }
  if (!/[؀-ۿ]/.test(ar[key])) errors.push(`${key}: no Arabic letters`);
  if (/⟦\d+⟧/.test(ar[key])) errors.push(`${key}: placeholder marker left in text`);
}
for (const key of Object.keys(ar)) if (!(key in en)) errors.push(`${key}: not in source`);
console.log(errors.join("\n") || "ok");
process.exit(errors.length ? 1 : 0);
```

Sur le fichier ci-dessus, il a affiché `ok`. Nous avons ensuite fait omettre au serveur fictif la forme `many` et le marqueur `{workspace}`. Le script s’est terminé avec le code 1 et a affiché :

```text
invite: arguments differ: [<b> {inviter} {workspace}] vs [<b> {inviter}]
files: plural {count} lacks many
```

La règle « no Arabic letters » signale les chaînes que le modèle a laissées en anglais. Elle signale aussi les valeurs qui ne sont qu’un nom de produit ou un nombre ; tenez une liste d’exceptions pour celles-ci. Pour le format propre à i18next, appliquez les mêmes contrôles clé par clé : chaque paire `_one`/`_other` en anglais exige les six clés suffixées en arabe, chacune avec les mêmes variables, sauf que `_zero`, `_one` et `_two` peuvent omettre le count.

Enfin, rendez quelques nombres avec votre vrai formateur. Avec intl-messageformat 12.1.5, le message `files` ci-dessus a donné 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف et 111 → 111 ملفًا. Ce contrôle ponctuel attrape une forme qui passe l’analyse mais utilise le mauvais nom.

## Et l’affichage de droite à gauche ?

La traduction fournit les bons mots ; le navigateur doit encore les ordonner. Quand un nom latin ou un nombre est inséré dans une phrase arabe, l’algorithme bidirectionnel Unicode peut déplacer la ponctuation ou intervertir des segments voisins. Le W3C conseille d’isoler le texte inséré : l’entourer de `<bdi>` ou d’un élément avec `dir="auto"` en HTML, ou de U+2068 FIRST STRONG ISOLATE et U+2069 POP DIRECTIONAL ISOLATE en texte brut, par exemple dans les notifications push.

Faites-le là où vous interpolez, pas dans la traduction. Dans notre test, formater le message de bienvenue avec le nom entouré de U+2068 et U+2069 a conservé les deux caractères dans la sortie sans toucher à l’arabe. Placez aussi `dir="rtl"` et `lang="ar"` sur la page ou le conteneur. [Prompt engineering en arabe](https://broadrouter.com/fr/blog/arabic-prompt-engineering/) propose une courte check-list des bugs d’affichage RTL.

Les chiffres relèvent du formateur, pas de la traduction. Gardez `#` ou l’argument dans la chaîne. Sous Node 24 (ICU 78.3), `Intl.NumberFormat` a écrit 1234 en 1,234 pour `ar` et en ١٬٢٣٤ pour `ar-EG` et `ar-SA`. Choisissez la balise de locale qui correspond à votre marché. Pour les questions produit plus larges (langue de l’interface ou langue du modèle, bulles de chat aux sens mélangés, détection de langue et coût par langue), voir [concevoir une expérience IA multilingue](https://broadrouter.com/fr/blog/multilingual-product-design/).

## Qui doit relire le résultat ?

Une chaîne LLM dotée de ces contrôles garantit un fichier bien formé. Elle ne garantit pas que l’arabe soit juste. Faites relire par un arabophone :

-   **Uniquement les chaînes nouvelles ou modifiées.** Comparez `en.json` à la dernière version publiée et ne traduisez que ce qui a changé. Les relectures restent légères, et les chaînes validées ne bougent plus.
-   **Les formes plurielles, mot à mot.** L’accord avec les nombres est là où le modèle trébuche le plus, surtout l’accusatif après 11 à 99.
-   **Le genre.** En arabe, « tu/vous » et les verbes changent selon le genre du lecteur. Si votre interface s’adresse directement aux utilisateurs, fixez une convention, comme une forme fixe ou une reformulation neutre, et inscrivez-la dans le prompt système.
-   **La longueur.** Les chaînes arabes peuvent être plus longues ou plus courtes que l’anglais. Vérifiez boutons et onglets dans la vraie mise en page, en largeur mobile.

Conservez un fichier de glossaire relu dans le dépôt et envoyez-le avec chaque requête, pour que les termes validés restent fixes.

## Combien ça coûte ?

Les fichiers de chaînes sont petits. La sortie est à peu près aussi longue que l’entrée, et l’arabe demande en général plus de tokens par mot que l’anglais ; [tokens par mot en arabe et en anglais](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/) donne des rapports mesurés. Collez un lot dans le [compteur de tokens arabe](https://broadrouter.com/tools/arabic-token-counter/), multipliez par le nombre de lots et ajoutez le prompt système à chacun. Les modèles de raisonnement dépensent aussi des tokens à réfléchir ; BroadNet les indique dans `usage` sous `completion_tokens_details.reasoning_tokens` : lisez donc `usage` sur une vraie requête avant d’extrapoler.

| Modèle | Remarques pour ce travail | Entrée / sortie par million de tokens |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) | Sortie structurée documentée | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) | Sortie structurée documentée ; contexte de 1 048 576 tokens | $0.78 / $3.46 |
| [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/) | Fonctionne avec le crédit de départ de $5 ; JSON par prompt seulement, le validateur compte donc davantage | $0.10 / $0.22 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/) | Aussi en forfaits, comme $15 la semaine par session, une requête à la fois par session | $0.175 / $0.52 |

Les prix proviennent du flux tarifaire de BroadNet, mis à jour le 2026-11-14. Traduisez les mêmes 100 chaînes avec deux modèles et faites-les comparer par votre relecteur avant de choisir ; le prix au token compte moins que le nombre de corrections. Pour des milliers de clés dans de nombreuses langues, [traitement par lots sans Batch API](https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/) traite de la concurrence et des relances.

## Où se situe BroadNet Inference

BroadRouter est le site de BroadNet. BroadNet Inference donne un accès compatible OpenAI aux modèles ci-dessus ; le script tourne donc avec le [SDK Python d’OpenAI](https://broadrouter.com/fr/guides/openai-python-sdk/) après changement de l’URL de base et de l’identifiant de modèle ; consultez la [référence de l’API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-translate-app-strings-to-arabic-llm&utm_content=body) pour les paramètres pris en charge par chaque modèle. Il n’a pas d’endpoint de traduction et ne publie aucun benchmark de localisation : le validateur et un relecteur humain restent votre contrôle qualité. Les plateformes de localisation spécialisées ajoutent mémoire de traduction, circuits de relecture et captures d’écran en contexte ; si vous en avez besoin, utilisez-en une et gardez le contrôle CI ci-dessus comme seconde ligne de défense.

Outils gratuits sur ce sujet (en anglais)

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[API batch (traitement par lots)](https://broadrouter.com/fr/glossary/batch-api/)

Une API batch est un endpoint LLM asynchrone qui accepte de nombreuses requêtes d’un coup, généralement sous forme de fichier, les traite dans une fenêtre définie plutôt qu’immédiatement et renvoie les résultats ensemble. Des fournisseurs comme OpenAI et Anthropic facturent les requêtes batch avec une remise par rapport à leurs API standard.

[Prompt système (system prompt)](https://broadrouter.com/fr/glossary/system-prompt/)

Le prompt système est le texte d’instructions qu’une application envoie à un modèle de langage avant la conversation, généralement sous forme de message au rôle system ou developer. Il fixe le rôle, les règles, le ton et le format de sortie du modèle, qui est censé le suivre même face à des messages contradictoires de l’utilisateur.

[Sortie structurée (structured output)](https://broadrouter.com/fr/glossary/structured-output/)

La sortie structurée est une fonction des API LLM qui contraint la réponse d’un modèle à un format défini par le développeur, en général un JSON Schema, pour que le code puisse l’analyser de façon fiable. Elle est plus stricte que le mode JSON, qui garantit un JSON valide mais pas une structure précise.

[API compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/)

Une API compatible OpenAI est une API HTTP qui accepte les mêmes formats de requête et de réponse que l’API OpenAI, comme POST /v1/chat/completions. Les SDK et outils OpenAI peuvent donc l’utiliser en changeant seulement l’URL de base, la clé d’API et le nom du modèle.

[Prompt engineering (ingénierie de prompt)](https://broadrouter.com/fr/glossary/prompt-engineering/)

Le prompt engineering est le travail qui consiste à écrire, structurer et tester les instructions données à un modèle de langage pour qu’il produise de façon constante une sortie conforme à vos exigences. Il couvre les messages de rôle, des instructions claires, des exemples, la mise en forme et la mesure des résultats sur des cas de test.

[Texte de droite à gauche (RTL)](https://broadrouter.com/fr/glossary/rtl-text/)

Le texte de droite à gauche (RTL) est une écriture, comme l’arabe ou l’hébreu, affichée de droite à gauche. Les ordinateurs la stockent dans l’ordre logique de lecture, et l’algorithme bidirectionnel Unicode décide de l’ordre d’affichage quand le texte RTL se mêle à du texte de gauche à droite, des chiffres, des noms de modèles ou du code.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

## Questions fréquentes

### Combien de formes de pluriel l’arabe possède-t-il ?

Six catégories cardinales dans Unicode CLDR : zero (0), one (1), two (2), few (nombres finissant par 03 à 10, comme 3 à 10 et 103), many (finissant par 11 à 99) et other (100 à 102, 1000, et les décimaux comme 0,5). Un fichier anglais n’a que one et other.

### ChatGPT ou un autre LLM peut-il traduire mon fichier JSON i18n en arabe ?

Oui, si vous maîtrisez le format. N’envoyez que les valeurs, remplacez les variables par des marqueurs, demandez six formes plurielles et contrôlez le résultat dans le code : clés, arguments, balises et catégories de pluriel. Faites relire les nouvelles chaînes par un arabophone avant la mise en production.

### Que se passe-t-il si une forme plurielle manque dans une traduction arabe ?

En général, rien ne casse visiblement. i18next et intl-messageformat se rabattent sur la forme other, si bien que 2 fichiers s’affichent « 2 ملف » au lieu du duel ملفان. Seul un validateur qui exige les six formes le détecte avant vos utilisateurs.

### Le LLM doit-il écrire lui-même la syntaxe ICU MessageFormat ?

Mieux vaut pas. Demandez six chaînes simples par message pluriel et assemblez la syntaxe ICU dans le code. Les modèles oublient parfois une accolade ou traduisent le nom de l’argument, et une erreur du parser casse alors tout le bundle à l’exécution.

### Quels chiffres utiliser dans les chaînes d’interface arabes ?

Laissez le formateur de nombres décider, pas la traduction. Gardez # ou l’argument dans la chaîne. Dans notre test sous Node 24, Intl.NumberFormat formatait 1234 en 1,234 pour ar et en ١٬٢٣٤ pour ar-EG et ar-SA : c’est la balise de locale qui fixe les chiffres.

## À lire ensuite

-   [Traduction arabe–anglais par LLM : prompts, glossaires, évaluation](https://broadrouter.com/fr/blog/arabic-english-translation-llm/)
-   [Prompt engineering en arabe : registre, RTL, chiffres et texte mixte](https://broadrouter.com/fr/blog/arabic-prompt-engineering/)
-   [Mode JSON ou json\_schema : une sortie structurée qui tient](https://broadrouter.com/fr/blog/structured-output-json-schema/)
-   [Corriger le JSON invalide d’un LLM : causes, réparation, relance](https://broadrouter.com/fr/blog/fix-invalid-json-from-llm/)
-   [Tokens par mot, arabe ou anglais : pourquoi l’arabe coûte plus cher](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/)
-   [Traitement par lots LLM sans Batch API : un exécuteur reprenable](https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/)
-   [Concevoir une expérience IA multilingue : arabe, anglais, espagnol](https://broadrouter.com/fr/blog/multilingual-product-design/)
-   [Vocaliser un texte arabe avec un LLM : prompt, contrôles, DER](https://broadrouter.com/fr/blog/arabic-diacritization-llm/)
-   [Correction grammaticale et orthographique de l’arabe par LLM : guide](https://broadrouter.com/fr/blog/arabic-grammar-spelling-correction-llm/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-translate-app-strings-to-arabic-llm&utm_content=page-cta) ·

**Sources**

-   [Unicode CLDR, tableau Language Plural Rules : catégories cardinales arabes zero, one, two, few (n % 100 = 3..10), many (n % 100 = 11..99), other (vérifié le 2026-11-15)](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
-   [MDN, Intl.PluralRules.prototype.select() : l’arabe a 6 formes pour les nombres cardinaux (vérifié le 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select)
-   [FormatJS, Message syntax : catégories de pluriel, correspondances exactes =value, le symbole #, other obligatoire, échappement par apostrophe (vérifié le 2026-11-15)](https://formatjs.github.io/docs/core-concepts/icu-syntax)
-   [Documentation i18next, Plurals : suffixes \_zero, \_one, \_two, \_few, \_many, \_other, exemple arabe, Intl.PluralRules, variable count (vérifiée le 2026-11-15)](https://www.i18next.com/translation-function/plurals)
-   [Documentation i18next, format JSON : clés de pluriel v4 et interpolation (vérifiée le 2026-11-15)](https://www.i18next.com/misc/json-format)
-   [W3C Internationalization, Inline markup and bidirectional text in HTML : dir, bdi, FSI U+2068 et PDI U+2069 (vérifié le 2026-11-15)](https://www.w3.org/International/articles/inline-bidi-markup/)
-   [Référence de l’API de BroadNet Inference : identifiants de modèles, sortie structurée pour GLM 5.3 et Qwen3.8 27B, le raisonnement compte dans max\_tokens (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-translate-app-strings-to-arabic-llm&utm_content=sources)
