---
title: "Tradurre file JSON i18n in arabo con un LLM: i plurali"
description: "Traduci in arabo i file JSON i18n con un’API LLM: blocca i placeholder, genera le sei forme plurali, valida la sintassi ICU in CI e isola i nomi inseriti."
url: https://broadrouter.com/it/blog/translate-app-strings-to-arabic-llm/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/translate-app-strings-to-arabic-llm/) (aggiornato il 2026-11-15).

# Stringhe di un’app in arabo con un LLM: placeholder e plurali

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato 2026-11-15

Invia le stringhe come JSON con ogni placeholder sostituito da un marcatore, chiedi tutte e sei le forme plurali arabe (zero, one, two, few, many, other) e costruisci il plurale ICU nel codice, non nel modello. Valida in CI: stesse chiavi, stessi argomenti e tag, tutte e sei le forme presenti. Racchiudi i nomi inseriti in isolati Unicode, così il testo da destra a sinistra si visualizza correttamente.

## Punti chiave

-   In CLDR l’arabo ha sei categorie plurali cardinali. I file sorgente in inglese ne hanno due, quindi il modello deve scrivere quattro forme che nella fonte non esistono.
-   Una forma araba mancante fallisce in silenzio. Nel nostro test, un messaggio ICU con solo one e other ha reso 2 file come «2 ملف» invece del duale ملفان, senza alcun errore.
-   Prima della richiesta sostituisci placeholder e tag con marcatori come ⟦0⟧ e ripristinali dopo. Il modello non può tradurre ciò che non vede.
-   Lascia che sia il codice a comporre la sintassi del plurale ICU a partire da sei stringhe semplici. Poi analizza ogni messaggio con il parser di FormatJS in CI e fai fallire la build a ogni lacuna.
-   I nomi interpolati e i nomi di prodotto in caratteri latini dentro l’arabo vanno isolati per il bidi: bdi o dir="auto" in HTML, U+2068 e U+2069 nel testo semplice.

**In questa pagina**

1.  Perché i plurali arabi rompono i file di stringhe tradotti in automatico?
2.  Come conviene inviare le stringhe al modello?
3.  Lo script di traduzione
4.  Come si valida il file arabo in CI?
5.  E la visualizzazione da destra a sinistra?
6.  Chi deve rivedere l’output?
7.  Quanto costa?
8.  Dove si colloca BroadNet Inference

Tradurre i file di stringhe di un’app è un lavoro diverso dal tradurre testo discorsivo. Ogni valore è breve, spesso senza contesto, e contiene sintassi che il modello non deve toccare: placeholder, tag HTML e regole del plurale. Con l’arabo l’ultima diventa difficile. I file inglesi hanno due forme plurali; l’arabo ne richiede sei. Questo articolo costruisce una piccola pipeline su un LLM compatibile con OpenAI: blocca i placeholder, chiede sei stringhe plurali semplici, compone la sintassi ICU nel codice e poi valida tutto in CI.

Per tradurre documenti, ticket e contratti, vedi [traduzione arabo–inglese con gli LLM](https://broadrouter.com/it/blog/arabic-english-translation-llm/), che tratta tono, glossari e valutazione per il testo discorsivo.

## Perché i plurali arabi rompono i file di stringhe tradotti in automatico?

Unicode CLDR, che `Intl.PluralRules`, ICU e i18next seguono tutti, dà all’arabo sei categorie cardinali:

| Categoria | Regola CLDR | Numeri di esempio | Esempio: «file» |
| --- | --- | --- | --- |
| zero | n = 0 | 0 | لا توجد ملفات |
| one | n = 1 | 1 | ملف واحد |
| two | n = 2 | 2 | ملفان (duale) |
| few | n % 100 = 3..10 | 3–10, 103–110 | 5 ملفات (plurale) |
| many | n % 100 = 11..99 | 11–99, 111 | 11 ملفًا (singolare, accusativo) |
| other | tutto il resto | 100–102, 1000, 0,5 | 100 ملف (singolare) |

Due dettagli traggono in inganno. Primo, le categorie non sono i numeri: 103 è few e 111 è many. Secondo, una fonte inglese dà al modello solo `one` e `other`, quindi deve inventare quattro forme partendo dalla sola grammatica. La maggior parte degli errori nasce dal modello che copia la coppia inglese.

L’errore è silenzioso. Abbiamo reso con intl-messageformat 12.1.5 un messaggio arabo che aveva solo `one` e `other`: 0, 2 e 11 file uscivano tutti come «N ملف». i18next 27.1.2 si è comportato allo stesso modo quando mancava la chiave `_many`: 11 file mostravano il testo di `_other`. Nessun errore, nessun avviso, solo arabo sbagliato.

## Come conviene inviare le stringhe al modello?

A lotti. Una richiesta per stringa spreca token sul system prompt e perde il contesto tra stringhe collegate. Invia da 50 a 200 chiavi alla volta come oggetto JSON, raggruppate per schermata o funzionalità, così «Save» accanto a «Cancel» si legge come un pulsante.

Tre regole rendono verificabile la risposta:

1.  **Blocca i placeholder.** Sostituisci `{name}`, i placeholder di i18next con doppie graffe, `%s`, `%1$s` e tag come `<b>` con marcatori come ⟦0⟧. Il modello vede «Welcome back, ⟦0⟧!» e non può tradurre `name` in اسم.
2.  **Chiedi le forme plurali come stringhe semplici.** Invia i testi inglesi `one` e `other` e chiedi sei stringhe arabe. La sintassi ICU la costruisce il codice. Il modello non scrive mai una graffa.
3.  **Fornisci un glossario e un elenco di termini da non tradurre.** Nomi di prodotto, nomi dei piani e termini che usa il tuo team di supporto. La [sezione sul glossario dell’articolo sulla traduzione](https://broadrouter.com/it/blog/arabic-english-translation-llm/) spiega perché questo conta più della scelta del modello.

## Lo script di traduzione

Il file sorgente usa ICU MessageFormat, la sintassi documentata da FormatJS. Lo stesso blocco dei placeholder funziona con il formato JSON di i18next, le cui chiavi plurali finiscono in `_zero`, `_one`, `_two`, `_few`, `_many` e `_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)
```

L’abbiamo eseguito con l’SDK Python di OpenAI contro un server mock locale, non contro l’API reale, con una risposta araba preimpostata. La richiesta che il modello avrebbe visto conteneva «Welcome back, ⟦0⟧!» e «⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace», e lo script ha scritto questo `ar.json`:

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

Note sul codice:

-   **I marcatori si spostano, non spariscono.** L’arabo mette spesso il verbo all’inizio, quindi ⟦0⟧ può cambiare posizione. Il controllo più sotto conta i marcatori; non gli importa dove stanno.
-   **L’ICU annidato va a una persona.** Un `select` dentro un `plural` è raro e facile da rompere. Lo script lo rifiuta invece di tirare a indovinare.
-   **`max_tokens=4000` lascia spazio al ragionamento.** Secondo la documentazione di BroadNet, DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B ragionano prima di rispondere, e il ragionamento conta in [max\_tokens](https://broadrouter.com/it/glossary/max-tokens/). Vedi [risposte vuote dai modelli di ragionamento](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).
-   **`json.loads` può fallire.** Racchiudilo in un try e rimanda la richiesta una volta con l’errore; [correggere il JSON non valido di un LLM](https://broadrouter.com/it/blog/fix-invalid-json-from-llm/) ha una funzione di riparazione testata. Su GLM 5.3 e Qwen3.8 27B, i due modelli BroadNet documentati con [output strutturato](https://broadrouter.com/it/glossary/structured-output/), aggiungi anche uno schema `response_format`. Il controllo qui sotto resta in ogni caso.

## Come si valida il file arabo in CI?

Analizza ogni messaggio con lo stesso parser che la tua app usa a runtime e confrontalo con la fonte. Questo script Node usa `@formatjs/icu-messageformat-parser` (versione 3.5.23 nel nostro 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);
```

Sul file qui sopra ha stampato `ok`. Poi abbiamo fatto in modo che la risposta del mock perdesse la forma `many` e il marcatore `{workspace}`. Lo script è uscito con codice 1 e ha stampato:

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

La regola «no Arabic letters» segnala le stringhe che il modello ha lasciato in inglese. Segnala anche i valori composti solo da un nome di prodotto o da un numero, quindi tieni una allow-list per quelli. Per il formato proprio di i18next, applica gli stessi controlli chiave per chiave: ogni coppia `_one`/`_other` in inglese richiede in arabo tutte e sei le chiavi con suffisso, ciascuna con gli stessi placeholder, salvo che `_zero`, `_one` e `_two` possono omettere il conteggio.

Infine, fai passare qualche numero dal tuo formattatore reale. Con intl-messageformat 12.1.5, il messaggio `files` qui sopra ha dato 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف e 111 → 111 ملفًا. Questo controllo a campione intercetta una forma che supera il parser ma usa il sostantivo sbagliato.

## E la visualizzazione da destra a sinistra?

La traduzione mette a posto le parole; il browser deve ancora ordinarle. Quando un nome in caratteri latini o un numero viene inserito in una frase araba, l’algoritmo bidirezionale Unicode può spostare la punteggiatura o scambiare segmenti vicini. Il consiglio del W3C è isolare il testo inserito: racchiuderlo in `<bdi>` o in un elemento con `dir="auto"` in HTML, oppure circondarlo con U+2068 FIRST STRONG ISOLATE e U+2069 POP DIRECTIONAL ISOLATE nel testo semplice, come nelle notifiche push.

Fallo nel punto in cui interpoli, non nella traduzione. Nel nostro test, formattare il messaggio di benvenuto con il nome racchiuso tra U+2068 e U+2069 ha mantenuto entrambi i caratteri nell’output e lasciato intatto l’arabo. Imposta anche `dir="rtl"` e `lang="ar"` sulla pagina o sul contenitore. [Prompt engineering in arabo](https://broadrouter.com/it/blog/arabic-prompt-engineering/) ha una breve checklist per i bug di visualizzazione RTL.

Le cifre sono una scelta del formattatore, non della traduzione. Tieni `#` o l’argomento nella stringa. In Node 24 (ICU 78.3), `Intl.NumberFormat` ha scritto 1234 come 1,234 per `ar` e come ١٬٢٣٤ per `ar-EG` e `ar-SA`. Scegli il tag di locale adatto al tuo mercato. Per le questioni di prodotto più ampie (lingua dell’interfaccia contro lingua del modello, fumetti di chat con direzioni miste, rilevamento della lingua e costo per lingua), vedi [progettare un’esperienza AI in più lingue](https://broadrouter.com/it/blog/multilingual-product-design/).

## Chi deve rivedere l’output?

Una pipeline LLM con questi controlli garantisce che il file sia ben formato. Non garantisce che l’arabo sia giusto. Fai rivedere a un madrelingua arabo:

-   **Solo le stringhe nuove e modificate.** Fai il diff di `en.json` rispetto all’ultimo rilascio e traduci solo ciò che è cambiato. Le revisioni restano piccole e le stringhe approvate non si muovono più.
-   **Le forme plurali, parola per parola.** La concordanza con i numeri è il punto in cui il modello sbaglia più spesso, soprattutto l’accusativo dopo i numeri da 11 a 99.
-   **Il genere.** In arabo «tu» e i verbi cambiano con il genere di chi legge. Se la tua interfaccia si rivolge direttamente agli utenti, decidi una convenzione, come una forma fissa o una riformulazione neutra, e mettila nel system prompt.
-   **La lunghezza.** Le stringhe arabe possono essere più lunghe o più corte di quelle inglesi. Controlla pulsanti e schede nel layout reale, a larghezza mobile.

Tieni nel repository un file di glossario revisionato e invialo a ogni richiesta, così i termini approvati restano fissi.

## Quanto costa?

I file di stringhe sono piccoli. L’output è lungo più o meno quanto l’input, e l’arabo di solito richiede più token per parola dell’inglese; [token per parola in arabo e in inglese](https://broadrouter.com/it/blog/tokens-per-word-arabic-english/) riporta rapporti misurati. Incolla un lotto nel [contatore di token per l’arabo](https://broadrouter.com/tools/arabic-token-counter/), moltiplica per il numero di lotti e aggiungi il system prompt a ciascuno. I modelli di ragionamento spendono token anche per pensare; BroadNet li riporta in `usage` come `completion_tokens_details.reasoning_tokens`, quindi leggi `usage` da una richiesta reale prima di estrapolare.

| Modello | Note per questo lavoro | Input / output per 1M di token |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/it/models/qwen3.8-27b/) | Output strutturato documentato | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) | Output strutturato documentato; contesto di 1.048.576 token | $0.78 / $3.46 |
| [Gemma 4 VL 26B](https://broadrouter.com/it/models/gemma-4-vl-26b/) | Funziona con il credito iniziale di $5; JSON solo tramite prompt, quindi il validatore conta di più | $0.10 / $0.22 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/) | Disponibile anche con piani a prezzo fisso, come $15 a settimana per sessione, una richiesta alla volta per sessione | $0.175 / $0.52 |

I prezzi vengono dal feed prezzi di BroadNet, sincronizzati 2026-11-14. Traduci le stesse 100 stringhe con due modelli e fai confrontare i risultati al tuo revisore prima di sceglierne uno; il prezzo per token conta meno del numero di correzioni. Per migliaia di chiavi in molte lingue, [elaborazione in batch senza una Batch API](https://broadrouter.com/it/blog/llm-batch-processing-without-batch-api/) tratta concorrenza e nuovi tentativi.

## Dove si colloca BroadNet Inference

BroadRouter è il sito di BroadNet. BroadNet Inference dà accesso compatibile con OpenAI ai modelli qui sopra, quindi lo script funziona con l’[SDK Python di OpenAI](https://broadrouter.com/it/guides/openai-python-sdk/) cambiando base URL e ID del modello; controlla nel [riferimento API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-translate-app-strings-to-arabic-llm&utm_content=body) i parametri supportati da ciascun modello. Non ha un endpoint di traduzione e non pubblica un benchmark di localizzazione, quindi il validatore e un revisore umano restano il tuo controllo di qualità. Le piattaforme di localizzazione dedicate aggiungono memoria di traduzione, flussi di revisione e screenshot nel contesto; se ti servono, usane una e tieni il controllo in CI qui sopra come seconda linea.

Strumenti gratuiti sul tema (in inglese)

-   [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.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

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

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Output strutturato (structured output)](https://broadrouter.com/it/glossary/structured-output/)

L’output strutturato è una funzionalità delle API LLM che vincola la risposta di un modello a un formato indicato dallo sviluppatore, di solito un JSON Schema, così il codice può interpretarla in modo affidabile. È più rigoroso della JSON mode, che garantisce un JSON valido ma non una struttura precisa.

[System prompt (prompt di sistema)](https://broadrouter.com/it/glossary/system-prompt/)

Il system prompt è il testo di istruzioni che un’applicazione invia a un modello linguistico prima della conversazione, di solito come messaggio con ruolo system o developer. Stabilisce ruolo, regole, tono e formato di output del modello, che dovrebbe seguirlo anche quando i messaggi dell’utente lo contraddicono.

[Base URL (URL di base)](https://broadrouter.com/it/glossary/base-url/)

La base URL è l’indirizzo radice fisso di un’API, come https://api.example.com/v1, che un client antepone a ogni percorso di endpoint, come /chat/completions. Negli SDK compatibili con OpenAI, cambiare la base URL, insieme alla chiave API e all’ID del modello, punta lo stesso codice verso un altro provider.

[Prompt engineering (ingegneria dei prompt)](https://broadrouter.com/it/glossary/prompt-engineering/)

Il prompt engineering è il processo con cui si scrivono, strutturano e testano le istruzioni date a un modello linguistico, perché produca in modo costante un output che rispetta i tuoi requisiti. Comprende messaggi di ruolo, istruzioni chiare, esempi, formattazione e la misura dei risultati su casi di test.

[Testo da destra a sinistra (RTL, right-to-left)](https://broadrouter.com/it/glossary/rtl-text/)

Il testo da destra a sinistra (RTL) è una scrittura, come l’arabo o l’ebraico, visualizzata da destra verso sinistra. I computer lo memorizzano in ordine logico di lettura, e l’algoritmo bidirezionale Unicode decide l’ordine di visualizzazione quando si mescola con testo da sinistra a destra, cifre, nomi di modelli o codice.

[Batch API](https://broadrouter.com/it/glossary/batch-api/)

Una batch API è un endpoint LLM asincrono che accetta molte richieste insieme, di solito come file, le elabora entro una finestra prestabilita invece che subito, e restituisce i risultati tutti insieme. Provider come OpenAI e Anthropic applicano alle richieste batch uno sconto rispetto alle loro API standard.

[Concorrenza (concurrency)](https://broadrouter.com/it/glossary/concurrency/)

La concorrenza è il numero di richieste che un client ha in corso nello stesso momento. Le API LLM spesso la limitano per chiave o per piano, separatamente dalle richieste al minuto, perché ogni richiesta aperta occupa capacità GPU finché la sua risposta non è terminata.

## Domande frequenti

### Quante forme plurali ha l’arabo?

Sei categorie cardinali in Unicode CLDR: zero (0), one (1), two (2), few (numeri che finiscono da 03 a 10, come da 3 a 10 e 103), many (che finiscono da 11 a 99) e other (da 100 a 102, 1000 e i decimali come 0,5). Un file inglese ha solo one e other.

### ChatGPT o un altro LLM possono tradurre in arabo il mio file JSON i18n?

Sì, se controlli tu il formato. Invia solo i valori, sostituisci i placeholder con marcatori, chiedi sei forme plurali e verifica il risultato nel codice: chiavi, argomenti, tag e categorie plurali. Fai rivedere le stringhe nuove a un madrelingua arabo prima del rilascio.

### Cosa succede se a una traduzione araba manca una forma plurale?

Di solito non si rompe nulla di visibile. i18next e intl-messageformat ripiegano sulla forma other, quindi 2 file diventano «2 ملف» invece del duale ملفان. Solo un validatore che richiede tutte e sei le forme se ne accorge prima degli utenti.

### Conviene far scrivere all’LLM la sintassi ICU MessageFormat?

Meglio di no. Chiedi sei stringhe semplici per ogni messaggio plurale e componi la sintassi ICU nel codice. Ogni tanto i modelli perdono una parentesi graffa o traducono il nome dell’argomento, e a quel punto un errore del parser rompe l’intero bundle a runtime.

### Quali cifre devono usare le stringhe dell’interfaccia in arabo?

Decide il formattatore dei numeri, non la traduzione. Tieni # o l’argomento nella stringa. Nel nostro test con Node 24, Intl.NumberFormat ha formattato 1234 come 1,234 per ar e come ١٬٢٣٤ per ar-EG e ar-SA: è il tag di locale a stabilire le cifre.

## Continua a leggere

-   [Traduzione arabo–inglese con gli LLM: prompt, glossari, valutazione](https://broadrouter.com/it/blog/arabic-english-translation-llm/)
-   [Prompt engineering in arabo: registro, RTL, cifre e testo misto](https://broadrouter.com/it/blog/arabic-prompt-engineering/)
-   [JSON mode o json\_schema: output strutturato che regge in produzione](https://broadrouter.com/it/blog/structured-output-json-schema/)
-   [JSON non valido da un LLM: cause, riparazione e retry](https://broadrouter.com/it/blog/fix-invalid-json-from-llm/)
-   [Token per parola in arabo e in inglese: perché l’arabo costa di più](https://broadrouter.com/it/blog/tokens-per-word-arabic-english/)
-   [Elaborazione batch con LLM senza Batch API: un runner riprendibile](https://broadrouter.com/it/blog/llm-batch-processing-without-batch-api/)
-   [Progettare un’esperienza AI in più lingue](https://broadrouter.com/it/blog/multilingual-product-design/)
-   [Aggiungere i diacritici all’arabo con un LLM: prompt, controlli, DER](https://broadrouter.com/it/blog/arabic-diacritization-llm/)
-   [Correzione grammaticale e ortografica dell’arabo con un LLM: guida](https://broadrouter.com/it/blog/arabic-grammar-spelling-correction-llm/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Guida: Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Unicode CLDR, tabella Language Plural Rules: categorie cardinali arabe zero, one, two, few (n % 100 = 3..10), many (n % 100 = 11..99), other (consultata il 2026-11-15)](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
-   [MDN, Intl.PluralRules.prototype.select(): l’arabo ha 6 forme per i numeri cardinali (consultato il 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select)
-   [FormatJS, sintassi dei messaggi: categorie plurali, corrispondenze esatte =valore, il simbolo #, other obbligatorio, escape con l’apostrofo (consultato il 2026-11-15)](https://formatjs.github.io/docs/core-concepts/icu-syntax)
-   [Documentazione di i18next, Plurals: suffissi \_zero, \_one, \_two, \_few, \_many, \_other, esempio in arabo, Intl.PluralRules, variabile count (consultata il 2026-11-15)](https://www.i18next.com/translation-function/plurals)
-   [Documentazione di i18next, formato JSON: chiavi plurali v4 e interpolazione (consultata il 2026-11-15)](https://www.i18next.com/misc/json-format)
-   [W3C Internationalization, markup inline e testo bidirezionale in HTML: dir, bdi, FSI U+2068 e PDI U+2069 (consultato il 2026-11-15)](https://www.w3.org/International/articles/inline-bidi-markup/)
-   [Riferimento API di BroadNet Inference: ID dei modelli, output strutturato per GLM 5.3 e Qwen3.8 27B, il ragionamento conta in max\_tokens (consultato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-translate-app-strings-to-arabic-llm&utm_content=sources)
