# gt-node: General Translation Node.js SDK: getMessages
URL: https://generaltranslation.com/it/docs/node/reference/functions/get-messages.mdx
---

title: getMessages
description: Ottieni un resolver General Translation per i messaggi registrati con msg per l'impostazione regionale della richiesta corrente. Riferimento API per getMessages.

---

Una funzione asincrona che restituisce un resolver per i messaggi pre-registrati. Usala insieme a [`msg`](/docs/node/reference/functions/msg) per registrare le stringhe durante il build time e risolverne le traduzioni a runtime.

## Panoramica [#overview]

Registra le stringhe con `msg` a livello di modulo, poi usa `await` su `getMessages` all'interno di uno scope [`withGT`](/docs/node/reference/functions/with-gt) per ottenere un resolver sincrono `m(encodedMsg, options?)`.

```ts
import { msg, getMessages } from 'gt-node';

// Registra al build time (o nello scope del modulo)
const greeting = msg('Hello, world!');

// Risolvi a runtime
const m = await getMessages();
const translated = m(greeting);
```

Firma:

```ts
getMessages(): Promise<MFunctionType>

type MFunctionType = <T extends string | null | undefined>(
  encodedMsg: T,
  options?: GTTranslationOptions
) => T extends string ? string : T;
```

*Nota: `getMessages` deve essere chiamato all&#39;interno di una callback di [`withGT`](/docs/node/reference/functions/with-gt), così da sapere quale impostazione regionale usare.*

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

* **Pattern in due passaggi.** [`msg`](/docs/node/reference/functions/msg) registra una stringa per la traduzione in fase di build; `getMessages` la risolve a runtime per l&#39;impostazione regionale attiva.
* **Stringhe a livello di modulo.** Questo pattern è adatto alle stringhe definite a livello di modulo — costanti, enum e messaggi di errore — che devono essere tradotte per ogni richiesta.
* **Pass-through di null.** Se a `m` viene passato `null` o `undefined`, restituisce rispettivamente `null` o `undefined`.

## Parametri [#parameters]

`getMessages` non accetta parametri. Il resolver `m` restituito accetta:

| Parametro                    | Descrizione                                                                          | Type                          | Facoltativo | Predefinito |
| ---------------------------- | ------------------------------------------------------------------------------------ | ----------------------------- | ----------- | ----------- |
| [`encodedMsg`](#encoded-msg) | Una stringa di messaggio codificata restituita da `msg()`.                           | `string \| null \| undefined` | No          | —           |
| [`options`](#options)        | Valori delle variabili e opzioni di traduzione da interpolare nel messaggio risolto. | `GTTranslationOptions`        | Sì          | `{}`        |

### `encodedMsg` [#encoded-msg]

**Tipo** `string | null | undefined` · **Obbligatorio**

Una stringa di messaggio codificata restituita da [`msg`](/docs/node/reference/functions/msg). Restituisce `null`/`undefined` se viene passato `null`/`undefined`.

### `options` [#options]

**Type** `GTTranslationOptions` · **Facoltativo**

Valori delle variabili da interpolare nel messaggio risultante con la sintassi `{key}`, oltre alle opzioni di traduzione come `$context`, `$id`, `$locale` e `$maxChars`. Quando il messaggio codificato include già opzioni di interpolazione (da `msg('...', { ... })`), vengono utilizzate quelle e questo argomento viene ignorato.

## Restituisce [#returns]

**Tipo** `Promise<MFunctionType>`

Restituisce la funzione `m` per la risoluzione dei messaggi. `m(encodedMsg, options?)` restituisce la traduzione decodificata e interpolata, preservando gli input `null`/`undefined`.

## Esempi [#examples]

```ts title="messages.js"
// Registra i messaggi a livello di modulo
import { msg } from 'gt-node';

export const GREETING = msg('Hello, world!');
export const WELCOME = msg('Welcome, {name}!');
```

```ts title="handler.js"
// Risolvi i messaggi per l'impostazione regionale della richiesta
import { withGT, getMessages } from 'gt-node';
import { GREETING, WELCOME } from './messages';

function handleRequest(locale) {
  return withGT(locale, async () => {
    const m = await getMessages();
    return {
      greeting: m(GREETING),
      welcome: m(WELCOME, { name: 'Alice' }),
    };
  });
}
```

```ts title="handler.js"
// Con variabili — passa i valori come secondo argomento
import { msg, getMessages, withGT } from 'gt-node';

const ORDER_STATUS = msg('Order {orderId} is {status}.');

function getOrderMessage(locale, orderId, status) {
  return withGT(locale, async () => {
    const m = await getMessages();
    return m(ORDER_STATUS, { orderId, status });
  });
}
```

## Note [#notes]

* [`msg`](/docs/node/reference/functions/msg) registra una stringa per la traduzione in fase di build; `getMessages` la risolve a runtime.
* Questo pattern è utile per le stringhe definite a livello di modulo (costanti, enum, messaggi di errore) che devono essere tradotte per singola richiesta.
* Se a `m` si passa `null` o `undefined`, restituisce rispettivamente `null` o `undefined`.