TacoTranslate
/
DokumentacjaCennik
 
Samouczek
04 maj

Jak zaimplementować internacjonalizację w aplikacji Next.js korzystającej z App Router

Uczyń swoją aplikację React bardziej dostępną i zdobądź nowe rynki dzięki internacjonalizacji (i18n).

W miarę jak świat staje się coraz bardziej zglobalizowany, dla twórców stron internetowych staje się coraz ważniejsze tworzenie aplikacji, które mogą obsługiwać użytkowników z różnych krajów i kultur. Jednym z kluczowych sposobów osiągnięcia tego jest internacjonalizacja (i18n), która pozwala dostosować aplikację do różnych języków, walut i formatów dat.

W tym artykule omówimy, jak dodać internacjonalizację do Twojej aplikacji React Next.js, z renderowaniem po stronie serwera. TL;DR: Zobacz pełny przykład tutaj.

Ten przewodnik jest przeznaczony dla aplikacji Next.js korzystających z App Router.
Jeśli używasz Pages Router, zobacz zamiast tego ten przewodnik.

Krok 1: Zainstaluj bibliotekę i18n

Aby zaimplementować internacjonalizację w swojej aplikacji Next.js, najpierw wybierzemy bibliotekę i18n. Istnieje kilka popularnych bibliotek, w tym next-intl. W tym przykładzie jednak użyjemy TacoTranslate.

TacoTranslate automatycznie tłumaczy Twoje ciągi znaków na dowolny język, wykorzystując najnowocześniejszą sztuczną inteligencję, i uwalnia Cię od żmudnego zarządzania plikami JSON.

Zainstalujmy ją za pomocą npm w Twoim terminalu:

npm install tacotranslate

Krok 2: Utwórz darmowe konto TacoTranslate

Teraz, gdy masz już zainstalowany moduł, czas założyć konto TacoTranslate, stworzyć projekt tłumaczeniowy oraz powiązane klucze API. Załóż konto tutaj. To bezpłatne i nie wymaga podawania karty kredytowej.

W interfejsie użytkownika aplikacji TacoTranslate utwórz projekt i przejdź do zakładki z kluczami API. Utwórz jeden klucz read, oraz jeden klucz read/write. Zapiszemy je jako zmienne środowiskowe. Klucz read nazywamy public, a klucz read/write to secret. Na przykład możesz dodać je do pliku .env w katalogu głównym swojego projektu.

.env
TACOTRANSLATE_PUBLIC_API_KEY=123456
TACOTRANSLATE_SECRET_API_KEY=789010

Upewnij się, że nigdy nie ujawnisz sekretnego klucza API read/write w produkcyjnych środowiskach po stronie klienta.

Dodamy także dwie kolejne zmienne środowiskowe: TACOTRANSLATE_DEFAULT_LOCALE oraz TACOTRANSLATE_ORIGIN.

  • TACOTRANSLATE_DEFAULT_LOCALE: Domyślny kod języka zapasowego. W tym przykładzie ustawimy go na en dla angielskiego.
  • TACOTRANSLATE_ORIGIN: „Folder”, w którym będą przechowywane Twoje ciągi znaków, na przykład adres URL Twojej strony internetowej. Przeczytaj więcej o pochodzeniach tutaj.
.env
TACOTRANSLATE_DEFAULT_LOCALE=en
TACOTRANSLATE_ORIGIN=your-website-url.com

Krok 3: Konfiguracja TacoTranslate

Aby zintegrować TacoTranslate z Twoją aplikacją, musisz utworzyć klienta, korzystając z wcześniejszych kluczy API. Na przykład, stwórz plik o nazwie /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;

Wkrótce automatycznie zdefiniujemy TACOTRANSLATE_API_KEY oraz TACOTRANSLATE_PROJECT_LOCALE.

Utworzenie klienta w osobnym pliku ułatwia jego ponowne użycie w przyszłości. getLocales to po prostu funkcja pomocnicza z wbudowaną obsługą błędów. Teraz utwórz plik o nazwie /app/[locale]/tacotranslate.tsx, w którym zaimplementujemy dostawcę 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>
	);
}

Zwróć uwagę na 'use client';, co wskazuje, że jest to komponent klienta.

Teraz gdy dostawca kontekstu jest gotowy, utwórz plik o nazwie /app/[locale]/layout.tsx, który jest głównym układem w naszej aplikacji. Zwróć uwagę, że ta ścieżka zawiera folder wykorzystujący Dynamic Routes, gdzie [locale] jest parametrem dynamicznym.

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

Pierwszą rzeczą, którą należy tu zauważyć, jest to, że używamy naszego parametru Dynamic Route [locale] do pobierania tłumaczeń dla tego języka. Dodatkowo, generateStaticParams zapewnia, że wszystkie kody lokalizacji, które masz aktywowane dla swojego projektu, są wstępnie renderowane.

Teraz zbudujmy naszą pierwszą stronę! Utwórz plik o nazwie /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!" />
	);
}

Zwróć uwagę na zmienną revalidate, która informuje Next.js, aby przebudował stronę po 60 sekundach i utrzymał Twoje tłumaczenia na bieżąco.

Krok 4: Implementacja renderowania po stronie serwera

TacoTranslate obsługuje renderowanie po stronie serwera. Znacznie poprawia to doświadczenie użytkownika, pokazując przetłumaczoną treść od razu, zamiast najpierw migać nieprzetłumaczoną zawartością. Dodatkowo możemy pominąć żądania sieciowe po stronie klienta, ponieważ już posiadamy tłumaczenia potrzebne dla strony, którą użytkownik przegląda.

Aby skonfigurować renderowanie po stronie serwera, utwórz lub zmodyfikuj plik /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};
};

Dostosuj sprawdzenie isProduction do swojego środowiska. Jeśli true, TacoTranslate udostępni publiczny klucz API. Jeśli znajdujemy się w środowisku lokalnym, testowym lub staging (isProduction is false), użyjemy sekretnego klucza API read/write, aby upewnić się, że nowe ciągi zostaną przesłane do tłumaczenia.

Aby zapewnić prawidłowe działanie routingu i przekierowań, będziemy musieli stworzyć plik o nazwie /middleware.ts. Korzystając z Middleware, możemy przekierować użytkowników na strony prezentowane w ich preferowanym języku.

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

Upewnij się, że konfigurujesz matcher zgodnie z dokumentacją Middleware Next.js.

Po stronie klienta możesz zmienić wartość ciasteczka locale, aby zmienić preferowany język użytkownika. Zobacz kompletny przykład kodu, aby poznać pomysły, jak to zrobić!

Krok 5: Wdróż i przetestuj!

Ukończyliśmy! Twoja aplikacja React będzie teraz automatycznie tłumaczona, gdy dodasz dowolne ciągi do komponentu Translate. Zwróć uwagę, że tylko środowiska z uprawnieniami read/write na kluczu API będą mogły tworzyć nowe ciągi do przetłumaczenia. Zalecamy posiadanie zamkniętego i zabezpieczonego środowiska stagingowego, w którym możesz testować swoją aplikację produkcyjną z takim kluczem API, dodając nowe ciągi przed udostępnieniem ich na żywo. Zapobiegnie to kradzieży twojego sekretnego klucza API oraz potencjalnemu nadmiernemu rozrostowi projektu tłumaczeniowego przez dodawanie nowych, niezwiązanych ciągów.

Upewnij się, że sprawdziłeś pełny przykład na naszym profilu GitHub. Znajdziesz tam również przykład, jak to zrobić za pomocą Pages Router! Jeśli napotkasz jakiekolwiek problemy, nie wahaj się skontaktować, a z przyjemnością pomożemy.

TacoTranslate pozwala szybko automatycznie lokalizować Twoje aplikacje React na dowolny język i z powrotem. Zacznij już dziś!

Produkt od NattskiftetWyprodukowano w Norwegii