# General Translation React SDKs (gt-react, gt-next): t
URL: https://generaltranslation.com/it/docs/react/reference/functions/t-function.mdx
---

title: t
description: Traduce le stringhe in modo sincrono a livello di modulo con General Translation gt-react. Riferimento API per t.

---

La funzione `t` è una funzione sincrona di traduzione delle stringhe a livello di modulo per le app `gt-react` lato client. A differenza di [`useGT`](/docs/react/reference/hooks/use-gt) (che richiede il React context) o [`msg`](/docs/react/reference/functions/msg) (che codifica le stringhe per risolverle in un secondo momento), `t` restituisce direttamente la stringa tradotta e può essere chiamata ovunque nel codice del browser, anche al di fuori dei componenti React.

*Disponibile in `gt-react` e `gt-tanstack-start`. Gli esempi importano da `gt-react`; per TanStack Start, importa da `gt-tanstack-start`.*

*Nota: non è esportata da `gt-next` o `gt-react-native`. In `gt-next`, usa [`useGT`](/docs/react/reference/hooks/use-gt) nei componenti sincroni oppure [`getGT`](/docs/react/nextjs/reference/functions/get-gt) nei componenti async App Router.*

## Panoramica [#overview]

Importa `t` da `gt-react` e invocala con una stringa.

```tsx
import { t } from 'gt-react';

const greeting = t('Hello, world!');
```

Può anche essere usato come template taggato literal:

```tsx
import { t } from 'gt-react';

const greeting = t`Hello, ${name}!`;
```

*Nota: `t` legge le traduzioni dalla cache del client popolata da [`initializeGTSPA`](/docs/react/reference/config#initialize-spa). Assicurati che l'inizializzazione venga eseguita prima di qualsiasi modulo che chiami `t` a livello di modulo. Chiamare `t` a livello di modulo in un'app con rendering lato server è vietato: in sviluppo solleva un'eccezione e, in produzione, registra un errore e usa come fallback il valore dell'impostazione regionale predefinita.*

## Come funziona [#how-it-works]

* **Traduzione sincrona a livello di modulo.** Una volta caricate le traduzioni per l'impostazione regionale attiva, `t` le legge in modo sincrono senza overhead. Poiché non usa React context, funziona a livello di modulo (costanti, tabelle di routing) così come all'interno dei componenti.
* **Risolte al caricamento.** Le traduzioni vengono risolte quando i moduli vengono valutati, quindi **cambiare impostazione regionale richiede un ricaricamento completo della pagina**: il browser deve rieseguire i moduli per applicare la nuova impostazione regionale. Questo pattern funziona solo nelle app client-side.
* **Le variabili non vengono tradotte.** I valori interpolati vengono inseriti nella stringa tradotta, ma non vengono mai tradotti.
* **Comportamento sul server.** Chiamare `t` a livello di modulo è vietato quando la strategia di render è `server-render`, cioè prima che lo store delle condizioni della richiesta sia inizializzato. In sviluppo genera un errore; in produzione registra un errore nei log e usa come fallback il valore di `defaultLocale`. Per la traduzione server-side, usa hook basati sul context come [`useGT`](/docs/react/reference/hooks/use-gt).

## Template literal taggato [#tagged-template]

`t` può essere usato come template taggato per una sintassi più naturale. Questi sono equivalenti:

```tsx
import { t } from 'gt-react';

t('Hello, {name}!', { name: 'Alice' });
t`Hello, ${name}!`;
```

La forma taggata interpola le variabili direttamente dal template, quindi non ti servono segnaposto in stile ICU né un oggetto options.

### Registrazione globale [#macros]

Invece di importare `t` in ogni file, registralo globalmente importando una sola volta l'entry dei macro nel punto di ingresso della tua app:

```tsx
import 'gt-react/macros';
```

Questo imposta `globalThis.t`, rendendo disponibile ovunque il template taggato senza un'importazione esplicita:

```tsx
// Nessun import necessario
const labels = {
  save: t`Save`,
  cancel: t`Cancel`,
};
```

## Parametri [#parameters]

| Parametro             | Descrizione                                          | Tipo                   | Facoltativo | Predefinito |
| --------------------- | ---------------------------------------------------- | ---------------------- | ----------- | ----------- |
| [`message`](#message) | La stringa da tradurre.                              | `string`               | No          | —           |
| [`options`](#options) | Variabili di interpolazione e opzioni di traduzione. | `GTTranslationOptions` | Sì          | —           |

### `message` [#message]

**Tipo** `string` · **Obbligatorio**

La stringa da tradurre. Se usata come template taggato, corrisponde invece alla stringa del template.

### `options` [#options]

**Tipo** `GTTranslationOptions` · **Facoltativo**

Variabili di interpolazione e opzioni come `$context` e `$id`. Vedi [`InlineTranslationOptions`](/docs/react/reference/types/inline-translation-options).

## Restituisce [#returns]

**Tipo** `string`

La stringa tradotta per l'impostazione regionale attiva, oppure la stringa sorgente se non è disponibile alcuna traduzione.

## Esempi [#examples]

```tsx title="constants.ts"
import { t } from 'gt-react';

export const ERROR_MESSAGES = {
  notFound: t('Page not found'),
  unauthorized: t('You do not have permission to view this page'),
  serverError: t('Something went wrong. Please try again later.'),
};
```

```tsx title="routes.ts"
import { t } from 'gt-react';

export const routes = [
  { path: '/', label: t('Home') },
  { path: '/dashboard', label: t('Dashboard') },
  { path: '/settings', label: t('Settings') },
];
```

```tsx
import { t } from 'gt-react';

const message = t('Hello, {name}!', { name: 'Alice' });
// I valori delle variabili vengono inseriti, non tradotti.
```

## Note [#notes]

* `t` è sincrono e può essere chiamato a livello di modulo; non usa React context.
* Il cambio dell'impostazione regionale richiede un ricaricamento completo della pagina.
* Per tradurre le stringhe all'interno dei componenti, usa [`useGT`](/docs/react/reference/hooks/use-gt); per codificare le stringhe per una risoluzione successiva, usa [`msg`](/docs/react/reference/functions/msg).