TacoTranslate
/
DocumentazionePrezzi
 
Tutorial
04 mag

Come implementare l'internazionalizzazione in un'applicazione Next.js che utilizza App Router

Rendi la tua applicazione React più accessibile e raggiungi nuovi mercati con l'internazionalizzazione (i18n).

Man mano che il mondo diventa sempre più globalizzato, è sempre più importante per gli sviluppatori web creare applicazioni in grado di soddisfare utenti provenienti da diversi paesi e culture. Uno dei modi principali per raggiungere questo obiettivo è attraverso l'internazionalizzazione (i18n), che ti consente di adattare la tua applicazione a diverse lingue, valute e formati di data.

In questo articolo, esploreremo come aggiungere l'internazionalizzazione alla tua applicazione React Next.js, con il rendering lato server. TL;DR: Vedi l'esempio completo qui.

Questa guida è per applicazioni Next.js che utilizzano il App Router.
Se stai usando il Pages Router, consulta invece questa guida.

Passo 1: Installare una libreria i18n

Per implementare l'internazionalizzazione nella tua applicazione Next.js, prima sceglieremo una libreria i18n. Ci sono diverse librerie popolari, incluso next-intl. In questo esempio, tuttavia, useremo TacoTranslate.

TacoTranslate traduce automaticamente le tue stringhe in qualsiasi lingua utilizzando un'IA all'avanguardia, liberandoti dalla gestione tediosa dei file JSON.

Installiamolo usando npm nel tuo terminale:

npm install tacotranslate

Passo 2: Crea un account TacoTranslate gratuito

Ora che hai installato il modulo, è il momento di creare il tuo account TacoTranslate, un progetto di traduzione e le relative chiavi API. Crea un account qui. È gratuito e non richiede l’inserimento di una carta di credito.

All'interno dell'interfaccia utente dell'applicazione TacoTranslate, crea un progetto e vai alla scheda delle chiavi API. Crea una chiave read e una chiave read/write. Le salveremo come variabili d'ambiente. La chiave read è quella che chiamiamo public e la chiave read/write è secret. Ad esempio, potresti aggiungerle a un file .env nella radice del tuo progetto.

.env
TACOTRANSLATE_PUBLIC_API_KEY=123456
TACOTRANSLATE_SECRET_API_KEY=789010

Assicurati di non divulgare mai la chiave API segreta read/write negli ambienti di produzione lato client.

Aggiungeremo anche altre due variabili d'ambiente: TACOTRANSLATE_DEFAULT_LOCALE e TACOTRANSLATE_ORIGIN.

  • TACOTRANSLATE_DEFAULT_LOCALE: Il codice della lingua predefinita di riserva. In questo esempio, lo imposteremo su en per l'inglese.
  • TACOTRANSLATE_ORIGIN: La “cartella” dove saranno memorizzate le tue stringhe, come l'URL del tuo sito web. Leggi di più sulle origini qui.
.env
TACOTRANSLATE_DEFAULT_LOCALE=en
TACOTRANSLATE_ORIGIN=your-website-url.com

Passo 3: Configurare TacoTranslate

Per integrare TacoTranslate con la tua applicazione, dovrai creare un client utilizzando le chiavi API menzionate in precedenza. Per esempio, crea un file chiamato /tacotranslate-client.js.

/tacotranslate-client.js
const {default: createTacoTranslateClient} = require('tacotranslate');

const tacoTranslate = createTacoTranslateClient({
	apiKey:
		process.env.TACOTRANSLATE_SECRET_API_KEY ??
		process.env.TACOTRANSLATE_PUBLIC_API_KEY ??
		process.env.TACOTRANSLATE_API_KEY,
	projectLocale:
		process.env.TACOTRANSLATE_IS_PRODUCTION === 'true'
			? process.env.TACOTRANSLATE_PROJECT_LOCALE
			: undefined,
});

module.exports = tacoTranslate;

Definiremo automaticamente tra poco TACOTRANSLATE_API_KEY e TACOTRANSLATE_PROJECT_LOCALE.

Creare il client in un file separato rende facile riutilizzarlo in seguito. getLocales è solo una funzione di utilità con alcune gestione degli errori integrata. Ora, crea un file chiamato /app/[locale]/tacotranslate.tsx, dove implementeremo il provider TacoTranslate.

/app/[locale]/tacotranslate.tsx
'use client';

import React, {type ReactNode} from 'react';
import {
	type TranslationContextProperties,
	TacoTranslate as ImportedTacoTranslate,
} from 'tacotranslate/react';
import tacoTranslateClient from '@/tacotranslate-client';

export default function TacoTranslate({
	locale,
	origin,
	localizations,
	children,
}: TranslationContextProperties & {
	readonly children: ReactNode;
}) {
	return (
		<ImportedTacoTranslate
			client={tacoTranslateClient}
			locale={locale}
			origin={origin}
			localizations={localizations}
		>
			{children}
		</ImportedTacoTranslate>
	);
}

Nota 'use client'; che indica che questo è un componente client.

Ora che il context provider è pronto, crea un file chiamato /app/[locale]/layout.tsx, il layout principale della nostra applicazione. Nota che questo percorso contiene una cartella che utilizza Dynamic Routes, dove [locale] è il parametro dinamico.

/app/[locale]/layout.tsx
import React, {type ReactNode} from 'react';
import {type Locale, isRightToLeftLocaleCode} from 'tacotranslate';
import './global.css';
import tacoTranslateClient from '@/tacotranslate-client';
import TacoTranslate from './tacotranslate';

export async function generateStaticParams() {
	const locales = await tacoTranslateClient.getLocales();
	return locales.map((locale) => ({locale}));
}

type RootLayoutParameters = {
	readonly params: Promise<{locale: Locale}>;
	readonly children: ReactNode;
};

export default async function RootLayout({params, children}: RootLayoutParameters) {
	const {locale} = await params;
	const origin = process.env.TACOTRANSLATE_ORIGIN;
	const localizations = await tacoTranslateClient.getLocalizations({
		locale,
		origins: [origin /* , other origins to fetch */],
	});

	return (
		<html lang={locale} dir={isRightToLeftLocaleCode(locale) ? 'rtl' : 'ltr'}>
			<body>
				<TacoTranslate
					locale={locale}
					origin={origin}
					localizations={localizations}
				>
					{children}
				</TacoTranslate>
			</body>
		</html>
	);
}

La prima cosa da notare qui è che stiamo usando il nostro parametro Dynamic Route [locale] per recuperare le traduzioni per quella lingua. Inoltre, generateStaticParams si assicura che tutti i codici di localizzazione che hai attivato per il tuo progetto siano pre-renderizzati.

Ora, costruiamo la nostra prima pagina! Crea un file chiamato /app/[locale]/page.tsx.

/app/[locale]/page.tsx
import React from 'react';
import {Translate} from 'tacotranslate/react';

export const revalidate = 60;
export default async function Page() {
	return (
		<Translate string="Hello, world!" />
	);
}

Nota la variabile revalidate che indica a Next.js di ricostruire la pagina dopo 60 secondi, mantenendo le tue traduzioni aggiornate.

Passo 4: Implementazione del rendering lato server

TacoTranslate supporta il rendering lato server. Questo migliora notevolmente l'esperienza utente mostrando immediatamente i contenuti tradotti, invece di un breve flash di contenuti non tradotti. Inoltre, possiamo evitare le richieste di rete sul client, poiché abbiamo già le traduzioni necessarie per la pagina che l'utente sta visualizzando.

Per configurare il rendering lato server, crea o modifica /next.config.js:

/next.config.js
const withTacoTranslate = require('tacotranslate/next/config').default;
const tacoTranslateClient = require('./tacotranslate-client');

module.exports = async () => {
	const config = await withTacoTranslate(
		{},
		{
			client: tacoTranslateClient,
			isProduction:
				process.env.TACOTRANSLATE_ENV === 'production' ||
				process.env.VERCEL_ENV === 'production' ||
				(!(process.env.TACOTRANSLATE_ENV || process.env.VERCEL_ENV) &&
					process.env.NODE_ENV === 'production'),
		}
	);

	// NOTE: Remove i18n from config when using the app router
	return {...config, i18n: undefined};
};

Modifica il controllo isProduction in base alla tua configurazione. Se true, TacoTranslate utilizzerà la chiave API pubblica. Se siamo in un ambiente locale, di test o di staging (isProduction is false), useremo la chiave API segreta read/write per assicurarci che le nuove stringhe vengano inviate per la traduzione.

Per garantire che il routing e il reindirizzamento funzionino come previsto, sarà necessario creare un file chiamato /middleware.ts. Utilizzando Middleware, possiamo reindirizzare gli utenti alle pagine presentate nella loro lingua preferita.

/middleware.ts
import {type NextRequest} from 'next/server';
import {middleware as tacoTranslateMiddleware} from 'tacotranslate/next';
import tacoTranslate from '@/tacotranslate-client';

export const config = {
	matcher: ['/((?!api|_next|favicon.ico).*)'],
};

export async function middleware(request: NextRequest) {
	return tacoTranslateMiddleware(tacoTranslate, request);
}

Assicurati di configurare il matcher in conformità con la documentazione di Next.js Middleware.

Sul client, puoi modificare il cookie locale per cambiare la lingua preferita dall’utente. Consulta il codice di esempio completo per idee su come farlo!

Passo 5: Distribuisci e testa!

Abbiamo finito! La tua applicazione React verrà ora tradotta automaticamente quando aggiungi delle stringhe a un componente Translate. Nota che solo gli ambienti con permessi read/write sulla chiave API saranno in grado di creare nuove stringhe da tradurre. Raccomandiamo di avere un ambiente di staging chiuso e sicuro dove poter testare la tua applicazione di produzione con una chiave API di questo tipo, aggiungendo nuove stringhe prima di andare in produzione. Questo impedirà a chiunque di rubare la tua chiave API segreta e di potenzialmente gonfiare il tuo progetto di traduzione aggiungendo nuove stringhe non correlate.

Assicurati di consultare l'esempio completo sul nostro profilo GitHub. Lì troverai anche un esempio di come fare ciò usando il Pages Router ! Se riscontri problemi, non esitare a contattarci, saremo più che felici di aiutarti.

TacoTranslate ti permette di localizzare automaticamente le tue applicazioni React rapidamente in qualsiasi lingua, e viceversa. Inizia oggi stesso!

Un prodotto di NattskiftetProdotto in Norvegia