Wie man Internationalisierung in einer Next.js-Anwendung implementiert, die den App Router verwendet

Da die Welt immer globalisierter wird, ist es für Webentwickler zunehmend wichtig, Anwendungen zu erstellen, die Nutzern aus verschiedenen Ländern und Kulturen gerecht werden können. Eine der wichtigsten Möglichkeiten, dies zu erreichen, ist die Internationalisierung (i18n), die es Ihnen ermöglicht, Ihre Anwendung an verschiedene Sprachen, Währungen und Datumsformate anzupassen.

In diesem Artikel zeigen wir, wie Sie Internationalisierung zu Ihrer React Next.js-Anwendung mit serverseitigem Rendering hinzufügen können. TL;DR: Siehe hier das vollständige Beispiel.

Diese Anleitung richtet sich an Next.js-Anwendungen, die den App Router verwenden.
Wenn Sie den Pages Router verwenden, sehen Sie stattdessen diese Anleitung.

Schritt 1: Installieren Sie eine i18n-Bibliothek

Um Internationalisierung in Ihrer Next.js-Anwendung zu implementieren, wählen wir zunächst eine i18n-Bibliothek aus. Es gibt mehrere beliebte Bibliotheken, darunter next-intl. In diesem Beispiel verwenden wir jedoch TacoTranslate.

TacoTranslate übersetzt Ihre Strings automatisch mit modernster KI in jede Sprache und befreit Sie von der mühsamen Verwaltung von JSON-Dateien.

Lassen Sie es uns mit npm in Ihrem Terminal installieren:

npm install tacotranslate

Schritt 2: Erstellen Sie ein kostenloses TacoTranslate-Konto

Jetzt, wo Sie das Modul installiert haben, ist es Zeit, Ihr TacoTranslate-Konto, ein Übersetzungsprojekt und die zugehörigen API-Schlüssel zu erstellen. Erstellen Sie hier ein Konto. Es ist kostenlos und erfordert keine Kreditkarte.

Erstellen Sie innerhalb der TacoTranslate-Anwendungsoberfläche ein Projekt und navigieren Sie zum Tab für API-Schlüssel. Erstellen Sie einen read Schlüssel und einen read/write Schlüssel. Wir werden diese als Umgebungsvariablen speichern. Der read Schlüssel wird als public bezeichnet und der read/write Schlüssel als secret. Zum Beispiel könnten Sie sie in einer .env Datei im Stammverzeichnis Ihres Projekts hinzufügen.

TACOTRANSLATE_PUBLIC_API_KEY=123456
TACOTRANSLATE_SECRET_API_KEY=789010

Stellen Sie sicher, dass der geheime read/write API-Schlüssel niemals an Client-seitige Produktionsumgebungen weitergegeben wird.

Wir werden außerdem zwei weitere Umgebungsvariablen hinzufügen: TACOTRANSLATE_DEFAULT_LOCALE und TACOTRANSLATE_ORIGIN.

• TACOTRANSLATE_DEFAULT_LOCALE: Der standardmäßige Fallback-Lokalisierungscode. In diesem Beispiel setzen wir ihn auf en für Englisch.
• TACOTRANSLATE_ORIGIN: Der „Ordner“, in dem Ihre Strings gespeichert werden, wie z. B. die URL Ihrer Webseite. Mehr über Origins erfahren Sie hier.

TACOTRANSLATE_DEFAULT_LOCALE=en
TACOTRANSLATE_ORIGIN=your-website-url.com

Schritt 3: TacoTranslate einrichten

Um TacoTranslate in Ihre Anwendung zu integrieren, müssen Sie einen Client mithilfe der zuvor genannten API-Schlüssel erstellen. Erstellen Sie beispielsweise eine Datei namens /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;

Wir werden in Kürze automatisch TACOTRANSLATE_API_KEY und TACOTRANSLATE_PROJECT_LOCALE definieren.

Das Erstellen des Clients in einer separaten Datei macht es einfach, ihn später erneut zu verwenden. getLocales ist nur eine Hilfsfunktion mit eingebauter Fehlerbehandlung. Erstelle nun eine Datei namens /app/[locale]/tacotranslate.tsx, in der wir den TacoTranslate Provider implementieren.

'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>
	);
}

Beachte 'use client';, das anzeigt, dass dies eine Client-Komponente ist.

Mit dem nun bereitstehenden Context-Provider erstellen Sie eine Datei namens /app/[locale]/layout.tsx, das Root-Layout in unserer Anwendung. Beachten Sie, dass dieser Pfad einen Ordner verwendet, der Dynamic Routes nutzt, wobei [locale] der dynamische Parameter ist.

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>
	);
}

Das erste, was hier zu beachten ist, ist, dass wir unseren Dynamic Route Parameter [locale] verwenden, um Übersetzungen für diese Sprache abzurufen. Zusätzlich sorgt generateStaticParams dafür, dass alle für Ihr Projekt aktivierten Gebietsschema-Codes vorgerendert werden.

Lass uns nun unsere erste Seite erstellen! Erstelle eine Datei mit dem Namen /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!" />
	);
}

Beachten Sie die revalidate Variable, die Next.js anweist, die Seite nach 60 Sekunden neu zu erstellen und Ihre Übersetzungen auf dem neuesten Stand zu halten.

Schritt 4: Implementierung des Server-Side Renderings

TacoTranslate unterstützt Server-Side-Rendering. Dies verbessert das Benutzererlebnis erheblich, indem sofort übersetzter Inhalt angezeigt wird, anstatt zuerst einen kurzen Augenblick nicht übersetzten Inhalts. Zusätzlich können wir Netzwerk-Anfragen auf der Client-Seite überspringen, da wir bereits die Übersetzungen haben, die wir für die Seite benötigen, die der Benutzer gerade betrachtet.

Um Server-Side-Rendering einzurichten, erstellen oder ändern Sie /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};
};

Passen Sie die isProduction Prüfung an Ihre Umgebung an. Wenn true ist, wird TacoTranslate den öffentlichen API-Schlüssel verwenden. Befinden wir uns in einer lokalen, Test- oder Staging-Umgebung (isProduction is false), verwenden wir den geheimen read/write API-Schlüssel, um sicherzustellen, dass neue Strings zur Übersetzung gesendet werden.

Um sicherzustellen, dass Routing und Weiterleitungen wie erwartet funktionieren, müssen wir eine Datei namens /middleware.ts erstellen. Mithilfe von Middleware können wir Benutzer auf Seiten in ihrer bevorzugten Sprache weiterleiten.

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);
}

Stellen Sie sicher, dass Sie den matcher gemäß der Next.js Middleware-Dokumentation einrichten.

Auf dem Client können Sie das locale Cookie ändern, um die bevorzugte Sprache des Benutzers zu ändern. Bitte sehen Sie sich den vollständigen Beispielcode an, um Ideen zu erhalten, wie das gemacht wird!

Schritt 5: Bereitstellen und testen!

Wir sind fertig! Deine React-Anwendung wird nun automatisch übersetzt, sobald du beliebige Strings zu einem Translate Komponent hinzufügst. Beachte, dass nur Umgebungen mit read/write Berechtigungen für den API-Schlüssel neue Strings zur Übersetzung anlegen können. Wir empfehlen, eine geschlossene und gesicherte Staging-Umgebung zu haben, in der du deine Produktionsanwendung mit einem solchen API-Schlüssel testen und neue Strings hinzufügen kannst, bevor du live gehst. So verhinderst du, dass jemand deinen geheimen API-Schlüssel stiehlt und dein Übersetzungsprojekt möglicherweise durch das Hinzufügen neuer, nicht zusammenhängender Strings aufgebläht wird.

Be sure to check out the complete example over at our GitHub profile. There, you’ll also find an example of how to do this using the Pages Router! If you encounter any problems, feel free to reach out, and we’ll be more than happy to help.

TacoTranslate lets you automatically localize your React applications quickly to and from over 75 languages. Get started today!