# node: Pattern per la traduzione delle stringhe
URL: https://generaltranslation.com/it/docs/node/guides/strings.mdx
---
title: Pattern per la traduzione delle stringhe
description: Due approcci alla traduzione delle stringhe in Node.js — inline e pre-registrate in precedenza
---

Esistono tre modi per tradurre le stringhe in `gt-node`:

1. **Inline con `getGT()`** — traduci le stringhe direttamente negli handler (fase di build)
2. **Pre-registrate con `msg()` / `getMessages()`** — definisci le stringhe nell'ambito del modulo e le risolvi a runtime (fase di build)
3. **On-demand con `tx()`** — traduci le stringhe a runtime, incluso il contenuto non noto in fase di build

## Traduzione inline con `getGT()`

Usa [`getGT()`](/docs/node/api/get-gt) quando la stringa viene usata in un solo punto, oppure quando il contenuto dipende da dati specifici della richiesta:

```js title="routes/greeting.js"
import { getGT } from 'gt-node';

app.get('/api/greeting', async (req, res) => {
  const gt = await getGT();
  res.json({
    message: gt('Hello, world!'),
  });
});
```


### Interpolazione delle variabili

Passa le variabili come secondo argomento utilizzando i segnaposto `{name}`:

```js
const gt = await getGT();

gt('Welcome, {name}!', { name: user.displayName });
gt('You have {count} new messages.', { count: unreadCount });
gt('{city} weather: {temp}°F', { city: 'Tokyo', temp: 72 });
```


## Stringhe pre-registrate previamente con `msg()` / `getMessages()`

Usa [`msg()`](/docs/node/api/get-messages) per registrare le stringhe nell'ambito del modulo — al di fuori di qualsiasi handler. Poi usa [`getMessages()`](/docs/node/api/get-messages) all'interno degli handler per risolverle nell'impostazione regionale corrente:

```js title="messages.js"
import { msg } from 'gt-node';

export const GREETING = msg('Hello, world!');
export const WELCOME = msg('Welcome, {name}!');
export const NOT_FOUND = msg('Resource not found.');
export const UNAUTHORIZED = msg('You must be logged in.');
```

```js title="routes/api.js"
import { getMessages } from 'gt-node';
import { GREETING, WELCOME, NOT_FOUND } from './messages.js';

app.get('/api/greeting', async (req, res) => {
  const m = await getMessages();
  res.json({
    greeting: m(GREETING),
    welcome: m(WELCOME, { name: 'Alice' }),
  });
});

app.use(async (req, res) => {
  const m = await getMessages();
  res.status(404).json({ error: m(NOT_FOUND) });
});
```

Questo approccio è ideale quando:

* La stessa stringa viene utilizzata in più handler
* Le stringhe sono costanti condivise (messaggi di errore, etichette, enum)
* Vuoi raccogliere tutte le stringhe traducibili in un unico file per semplificarne la revisione


## Traduzione su richiesta con `tx()`

Usa [`tx()`](/docs/node/api/strings/tx) quando il contenuto non è noto in fase di build — ad esempio, contenuti generati dagli utenti o dati dinamici che non possono essere pre-tradotti:

```js title="routes/translate.js"
import { tx } from 'gt-node';

app.post('/api/translate', async (req, res) => {
  const translated = await tx(req.body.text);
  res.json({ translated });
});
```

`tx` è asincrono ed esegue la traduzione on demand tramite una richiesta di rete, quindi è più lento degli approcci in fase di build. Usalo solo quando `getGT()` o `msg()` non possono coprire questo caso d'uso.

## Quando usare l’uno o l’altro

| Pattern                   | Ideale per                                                                                          |
| ------------------------- | --------------------------------------------------------------------------------------------------- |
| `getGT()`                 | Stringhe una tantum, contenuto specifico della richiesta, stringhe che compaiono in un solo handler |
| `msg()` / `getMessages()` | Costanti condivise, messaggi di errore, etichette di enum, gestione centralizzata delle stringhe    |
| `tx()`                    | Contenuto dinamico o generato dagli utenti non noto in fase di build                                |

<Callout>
  Entrambi gli approcci producono traduzioni identiche. La differenza sta solo nell&#39;organizzazione del codice: scegli quello più adatto alla struttura del tuo progetto.
</Callout>

## Uso di `$context` per la disambiguazione

Le stringhe ambigue possono generare traduzioni imprecise. Aggiungi `$context` per guidare il traduttore:

```js
// Inline
const gt = await getGT();
gt('Apple', { $context: 'l\'azienda tecnologica' });
gt('Spring', { $context: 'la stagione, non una molla' });

// Pre-registrato
const APPLE = msg('Apple', { $context: 'il frutto' });
const SPRING = msg('Spring', { $context: 'una molla metallica' });
```


## Esempio completo

```js title="server.js"
import express from 'express';
import { initializeGT, withGT, getGT, msg, getMessages } from 'gt-node';

initializeGT({
  defaultLocale: 'en',
  locales: ['en', 'es', 'fr', 'ja'],
  projectId: process.env.GT_PROJECT_ID,
});

// Pre-registra le stringhe condivise
const ERRORS = {
  notFound: msg('Resource not found.'),
  unauthorized: msg('You must be logged in.'),
  forbidden: msg('You do not have permission to access this resource.'),
};

const app = express();

app.use((req, res, next) => {
  const locale = req.headers['accept-language']?.split(',')[0] || 'en';
  withGT(locale, () => next());
});

// Traduzione inline
app.get('/api/dashboard', async (req, res) => {
  const gt = await getGT();
  res.json({
    title: gt('Dashboard'),
    subtitle: gt('Welcome back, {name}!', { name: req.user.name }),
  });
});

// Messaggi pre-registrati
app.use(async (req, res) => {
  const m = await getMessages();
  res.status(404).json({ error: m(ERRORS.notFound) });
});

app.listen(3000);
```


## Passaggi successivi

* [`getGT` riferimento API](/docs/node/api/get-gt)
* [`msg` e `getMessages` riferimento API](/docs/node/api/get-messages)
* [`tx` riferimento API](/docs/node/api/strings/tx) — traduzione runtime
* [Rilevamento dell&#39;impostazione regionale e middleware](/docs/node/guides/middleware) — come funziona il contesto legato all&#39;impostazione regionale