# General Translation Knowledge Base: Alternative a i18next: General Translation vs. i18next
URL: https://generaltranslation.com/it/kb/general-translation-vs-i18next.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Scegli General Translation per mantenere i testi inline nei componenti React e generare le traduzioni sfruttando la struttura JSX e il contesto del prodotto. In alternativa, puoi continuare a usare i18next e affidarti a General Translation per tradurre i cataloghi esistenti. i18next si occupa del rendering dei messaggi e della selezione dei plurali, mentre la generazione delle traduzioni è affidata a un servizio separato.
Category: Internazionalizzazione
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16
i18next carica i file di traduzione, seleziona il messaggio nella lingua dell'utente, risolve le forme plurali, interpola i valori e formatta numeri e date con `Intl`. È disponibile su npm dal 2012 e, insieme a `react-i18next` e `next-i18next`, è una scelta diffusa per le app React e Next.js. Ciò che i18next non fa è tradurre: ogni messaggio, in ogni lingua, deve essere fornito da te, dai tuoi traduttori o da un servizio come Locize, [gestito dai creatori di i18next](https://www.i18next.com/). Le librerie di General Translation svolgono lo stesso lavoro di rendering, ma in più General Translation genera le traduzioni a partire dai testi presenti nei tuoi componenti.
## I punti di forza di i18next
* **Diffusione.** È uno dei framework i18n per JavaScript più utilizzati.
* **Ampiezza.** [I binding coprono React, Vue, Angular, Svelte e altri](https://www.i18next.com/overview/supported-frameworks), mentre i plugin caricano i file tramite HTTP, rilevano la lingua dell'utente e convertono i messaggi in ICU MessageFormat con `i18next-icu`.
* **Supporto completo per plurali e contesto.** Le chiavi includono [suffissi plurali CLDR](https://www.i18next.com/translation-function/plurals) come `_one`, `_few` e `_many`, risolti tramite `Intl.PluralRules`, e varianti di contesto come `friend_male`.
* **Strumenti.** La CLI ufficiale [`i18next-cli`](https://github.com/i18next/i18next-cli) estrae le chiavi, genera i tipi TypeScript e scrive le chiavi plurali di ogni impostazione regionale. Il suo comando `status` termina con un errore se un'impostazione regionale contiene chiavi non tradotte, così la CI può individuare eventuali lacune.
* **Componenti server.** [`next-i18next` 16](https://github.com/i18next/next-i18next) aggiunge una funzione di traduzione server-side per l'App Router di Next.js.
* **Nessun servizio obbligatorio.** I cataloghi sono semplici file JSON di tua proprietà e i18next funziona con qualsiasi servizio di traduzione, o anche senza.
## Cosa i18next lascia a carico tuo
Ecco una semplice casella di posta realizzata con react-i18next. Ogni stringa ha una chiave e ogni forma plurale ha una chiave dedicata:
```json title="locales/en/translation.json"
{
"inbox": {
"title": "Inbox",
"unread_one": "You have {{count}} unread message.",
"unread_other": "You have {{count}} unread messages."
}
}
```
```tsx title="Inbox.tsx"
import { useTranslation } from 'react-i18next';
export function Inbox({ count }: { count: number }) {
const { t } = useTranslation();
return (
{t('inbox.title')}
{t('inbox.unread', { count })}
);
}
```
Tutte le altre lingue richiedono le stesse chiavi dei messaggi, con le forme plurali previste da ciascuna lingua: il polacco, ad esempio, richiede `unread_one`, `unread_few`, `unread_many` e `unread_other`. Se un file polacco contiene solo le forme `_one` e `_other`, ricalcate sull'inglese, e la tua [lingua di fallback](https://www.i18next.com/principles/fallback) è l'inglese, per quantità come 2 e 5 verrà usato l'inglese:
```text title="Output"
pl, count 1: Masz 1 nieprzeczytaną wiadomość.
pl, count 2: You have 2 unread messages.
pl, count 5: You have 5 unread messages.
pl, count 22: You have 22 unread messages.
```
Eseguire `i18next-cli status` in CI permette di individuare le forme mancanti. I servizi di traduzione possono generare il contenuto del catalogo, ma la tua applicazione continua a fare riferimento a chiavi come `inbox.unread`, e il flusso di lavoro di estrazione e traduzione mantiene aggiornati quei cataloghi.
## General Translation mantiene i testi inline e genera le traduzioni
Le librerie di General Translation svolgono lo stesso compito di i18next: selezionano i messaggi di ogni impostazione regionale, applicano le relative regole del plurale, interpolano le variabili e formattano numeri, valute e date con [``](/docs/react/reference/components/num), [``](/docs/react/reference/components/currency) e [``](/docs/react/reference/components/datetime). I team che preferiscono le chiavi possono continuare a usare i dizionari con [`useTranslations`](/docs/react/reference/hooks/use-translations). In più, General Translation fa ciò che i18next non fa: genera le traduzioni. Ecco la stessa casella di posta con `gt-react`:
```tsx title="Inbox.tsx"
import { T, Plural, Num } from 'gt-react';
export function Inbox({ count }: { count: number }) {
return (
Inbox
You have {count} unread message.}
plural={You have {count} unread messages.
}
/>
);
}
```
[`npx gt translate`](/docs/cli/reference/commands/translate) invia ogni blocco [``](/docs/react/reference/components/t), insieme alla sua struttura di elementi, all'API di General Translation prima della build e genera una traduzione per ogni impostazione regionale di destinazione. I rami sorgente generici `singular` e `plural` forniscono il testo per le forme richieste da ciascuna lingua di destinazione. [``](/docs/react/reference/components/plural) seleziona poi un ramo tradotto in base alle regole di quell'impostazione regionale. Un valore racchiuso in [``](/docs/react/reference/components/var) non viene mai inviato all'API.
Quando modifichi una frase all'interno di [``](/docs/react/reference/components/t), l'esecuzione di traduzione successiva la aggiorna per ogni lingua e riutilizza le traduzioni dei contenuti rimasti invariati. I revisori lavorano nell'[Editor di traduzione della Dashboard](/docs/platform/dashboard/guides/reviewing-translations), quindi per modificare le traduzioni non è necessario intervenire sui componenti.
Le librerie JavaScript sono distribuite con licenza MIT e funzionano senza account se fornisci tu le traduzioni. Un'app configurata per caricare tutte le traduzioni dal proprio bundle non effettua alcuna chiamata a General Translation a Runtime. `gt-react` e `gt-next` non si appoggiano a nessun'altra libreria i18n.
Cursor distribuisce oltre 14 impostazioni regionali tra sito web e documentazione con General Translation. (Vedi le [distribuzioni in Produzione](https://generaltranslation.com/enterprise).)
## i18next e General Translation a confronto
| Funzionalità | i18next | General Translation |
| ------------------------------ | --------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Come scrivi i testi | Chiavi in file JSON per lingua e namespace | JSX all'interno di [``](/docs/react/reference/components/t), stringhe tramite [`useGT`](/docs/react/reference/hooks/use-gt) oppure dizionari basati su chiavi |
| Traduce i tuoi contenuti | No | Sì, con [`npx gt translate`](/docs/cli/reference/commands/translate) |
| Da dove arrivano le traduzioni | Da te, dai traduttori o da un servizio come Locize | Generate a partire dal contesto del tuo codice oppure scritte dal tuo team |
| Forme plurali | Una chiave per ogni forma CLDR, scritta per ciascuna lingua | Rami di [``](/docs/react/reference/components/plural), tradotti insieme al resto del blocco |
| Contesto di traduzione | Messaggi sorgente e contesto forniti dal tuo flusso di lavoro di traduzione | La struttura dei blocchi JSX contrassegnati, le note di contesto, il Glossario e i prompt personalizzati condivisi |
| Framework | React, Next.js e binding per Vue, Angular, Svelte e altri | React, Next.js, Vue, Node.js e [altri SDK](/docs/overview/get-started) |
| Account necessario | No | Non per le librerie; la traduzione avviene tramite un progetto General Translation |
Resta su i18next se i tuoi cataloghi e il tuo processo di traduzione funzionano già, se sviluppi su un framework non supportato dalle librerie di General Translation o se preferisci chiavi che restino stabili anche quando i testi cambiano. Scegli General Translation se vuoi i testi inline nei tuoi componenti, traduzioni generate tenendo conto del contesto del codice e tutte le lingue aggiornate a ogni build.
## Mantieni i18next e lascia che sia General Translation a tradurre
Non è necessario cambiare libreria. La CLI `gt` rileva `i18next` nel tuo `package.json` e ne mantiene la sintassi di interpolazione. Ecco una configurazione per tradurre in tedesco il catalogo dell'inbox mostrato sopra:
```json title="gt.config.json"
{
"defaultLocale": "en",
"locales": ["de"],
"files": {
"json": {
"include": ["locales/[locale]/translation.json"]
}
}
}
```
L'inglese e il tedesco usano la stessa struttura di chiavi plurali `_one` e `_other`. Questa configurazione genera `locales/de/translation.json` a partire da `locales/en/translation.json`. Puoi aggiungere un contesto specifico per ogni chiave, ad esempio il punto in cui compare una stringa, con i [metadati associati alle chiavi](/docs/cli/reference/keyed-metadata). Esegui [`npx gt upload`](/docs/cli/reference/commands/upload) per importare i file sorgente e le traduzioni esistenti, poi esegui [`npx gt translate`](/docs/cli/reference/commands/translate) per tradurre i nuovi testi.
Se invece vuoi passare a [``](/docs/react/reference/components/t), segui la guida [Migrare da altre librerie i18n](/docs/react/guides/migrating-i18n-libraries). Spiega come sostituire le ricerche per chiave con testo inline, come mantenere i tuoi dizionari con [`useTranslations`](/docs/react/reference/hooks/use-translations) e come far convivere le due librerie mentre migri una route alla volta. (Per un confronto tra i18next e le altre librerie, consulta [General Translation vs. i18next, react-intl e next-intl](/kb/general-translation-vs-i18n-libraries).)
## Come gestisco il polacco e altre lingue con molte forme plurali in i18next?
Ogni lingua richiede una chiave per ciascuna forma plurale CLDR che utilizza, ad esempio `_one`, `_few`, `_many` e `_other` per il polacco. Esegui `i18next-cli status` in CI per individuare le forme mancanti. Con la scrittura inline di General Translation, basta scrivere i rami `singular` e `plural` mostrati sopra: il servizio di traduzione genera automaticamente le forme della lingua di destinazione. [``](/docs/react/reference/components/plural) seleziona quella corretta a runtime.
## Altre alternative a i18next
I team che abbandonano i18next valutano anche queste librerie:
* **react-intl:** formatta i messaggi ICU e fornisce gli strumenti di FormatJS per la gestione dei cataloghi. (Vedi [General Translation vs. react-intl](/kb/general-translation-vs-react-intl).)
* **Lingui:** mantiene i testi inline e compila i messaggi in cataloghi con un Runtime leggero. (Vedi [General Translation vs. Lingui](/kb/general-translation-vs-lingui).)
* **next-intl:** renderizza i messaggi dei cataloghi nelle app Next.js con App Router, inclusi i Componenti server. (Vedi [next-intl vs. gt-next](/kb/next-intl-vs-gt-next).)
* **Paraglide JS:** compila i cataloghi in funzioni di messaggio tipizzate e tree-shakable. (Vedi [General Translation vs. Paraglide JS](/kb/general-translation-vs-paraglide).)
* **Intlayer:** mantiene il contenuto di ogni componente in un file di dichiarazione tipizzato, con tutte le lingue affiancate. (Vedi [General Translation vs. Intlayer](/kb/general-translation-vs-intlayer).)
## Punti chiave
* i18next renderizza cataloghi basati su chiavi e gestisce la selezione delle forme plurali; le traduzioni, invece, le producono persone o un servizio collegato.
* Le librerie di General Translation renderizzano le traduzioni allo stesso modo, ma General Translation si occupa anche della traduzione, a partire dai testi scritti inline in [``](/docs/react/reference/components/t).
* Puoi continuare a usare i18next e lasciare che la CLI `gt` traduca i suoi file JSON, oppure migrare a [``](/docs/react/reference/components/t) una route alla volta.
## Related questions
- [General Translation vs. i18next, react-intl e next-intl: quale libreria i18n scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-i18n-libraries.mdx): Le librerie open source come i18next, react-intl e next-intl non traducono nulla. Si limitano a visualizzare le traduzioni che fornisci in un file di catalogo per ciascuna lingua, scritte da te, dai tuoi traduttori o da un servizio esterno. Anche le librerie di General Translation sono open source e svolgono lo stesso compito, ma General Translation si occupa anche della traduzione, usando il tuo codice come contesto.
- [Alternative a react-intl: General Translation o react-intl](https://generaltranslation.com/it/kb/general-translation-vs-react-intl.mdx): General Translation consente ai team React di mantenere la sintassi dei messaggi ICU, aggiungendo la generazione delle traduzioni, una terminologia condivisa e la revisione nella Dashboard. react-intl fornisce la formattazione e gli strumenti di FormatJS per la gestione dei cataloghi; General Translation, invece, produce anche le traduzioni.
- [General Translation o Lingui: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-lingui.mdx): Scegli General Translation per mantenere i testi inline come con Lingui e generare le traduzioni usando la struttura JSX come contesto. Lingui estrae i messaggi inline in cataloghi che i tuoi traduttori o un servizio collegato dovranno tradurre. La CLI di General Translation aggiorna le traduzioni man mano che il codice cambia e il tuo team le revisiona nella Dashboard.
- [General Translation vs. vue-i18n: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-vue-i18n.mdx): General Translation consente ai team Vue di scrivere il testo sorgente direttamente nei modelli e di generare le traduzioni con la CLI. Il suo plugin gt-vue renderizza questi contenuti con una formattazione locale-aware di plurali e numeri. Sceglilo per eliminare la manutenzione dei file sorgente basati su chiavi; vue-i18n resta una scelta valida per i team che usano il modulo i18n di Nuxt e un flusso di lavoro consolidato basato su cataloghi.
- [Come si gestiscono i plurali in React?](https://generaltranslation.com/it/kb/how-to-handle-plurals-in-react.mdx): Non inserire la logica del plurale direttamente nel codice con controlli come n === 1. Per le app solo in inglese basta un semplice helper, ma le app multilingue richiedono regole del plurale locale-aware, che un componente i18n come `` di gt-react o gt-next gestisce per ogni lingua.
## Previous and next questions
- Previous question: [Alternative a Google Translate: General Translation vs. Google Translate](https://generaltranslation.com/it/kb/general-translation-vs-google-translate.mdx)
- Next question: [Alternative a Lokalise: General Translation vs. Lokalise](https://generaltranslation.com/it/kb/general-translation-vs-lokalise.mdx)
## Sitemap
See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.