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

title: getMessages
description: Obtén un resolvedor de General Translation para los mensajes registrados con msg para la configuración regional de la solicitud actual. Referencia de la API para getMessages.

---

Una función asíncrona que devuelve un resolvedor para mensajes prerregistrados. Úsala junto con [`msg`](/docs/node/reference/functions/msg) para registrar cadenas en tiempo de compilación y resolver sus traducciones en tiempo de ejecución.

## Descripción general [#overview]

Registra cadenas con `msg` en el ámbito del módulo y luego usa `await` con `getMessages` dentro de un ámbito de [`withGT`](/docs/node/reference/functions/with-gt) para obtener un resolvedor síncrono `m(encodedMsg, options?)`.

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

// Registrar en tiempo de compilación (o en el ámbito del módulo)
const greeting = msg('Hello, world!');

// Resolver en tiempo de ejecución
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` debe llamarse dentro de un callback de [`withGT`](/docs/node/reference/functions/with-gt) para que sepa qué configuración regional debe usar.*

## Cómo funciona [#how-it-works]

* **Patrón de dos pasos.** [`msg`](/docs/node/reference/functions/msg) registra una cadena para traducirla en tiempo de compilación; `getMessages` la recupera en tiempo de ejecución para la configuración regional activa.
* **Cadenas en el ámbito del módulo.** Este patrón es adecuado para cadenas definidas en el ámbito del módulo —constantes, enums y mensajes de error— que deben traducirse en cada solicitud.
* **Propagación de null.** Si se pasa `null` o `undefined` a `m`, devuelve `null` o `undefined`, respectivamente.

## Parámetros [#parameters]

`getMessages` no recibe parámetros. El resolvedor `m` devuelto recibe:

| Parámetro                    | Descripción                                                                             | Tipo                          | Opcional | Predeterminado |
| ---------------------------- | --------------------------------------------------------------------------------------- | ----------------------------- | -------- | -------------- |
| [`encodedMsg`](#encoded-msg) | Una cadena de mensaje codificada devuelta por `msg()`.                                  | `string \| null \| undefined` | No       | —              |
| [`options`](#options)        | Valores de variables y opciones de traducción para interpolar en el mensaje resultante. | `GTTranslationOptions`        | Sí       | `{}`           |

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

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

Una cadena de mensaje codificada devuelta por [`msg`](/docs/node/reference/functions/msg). Devuelve `null`/`undefined` si recibe `null`/`undefined`.

### `options` [#options]

**Tipo** `GTTranslationOptions` · **Opcional**

Valores de variables para interpolarlos en el mensaje resulto usando la sintaxis `{key}`, además de opciones de traducción como `$context`, `$id`, `$locale` y `$maxChars`. Cuando el mensaje codificado ya contiene opciones de interpolación (de `msg('...', { ... })`), se usan esas y se ignora este argumento.

## Devuelve [#returns]

**Tipo** `Promise<MFunctionType>`

Se resuelve como la función `m` de resolución de mensajes. `m(encodedMsg, options?)` devuelve la traducción decodificada e interpolada, preservando las entradas `null`/`undefined`.

## Ejemplos [#examples]

```ts title="messages.js"
// Registrar messages en el ámbito del módulo
import { msg } from 'gt-node';

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

```ts title="handler.js"
// Resolver los mensajes para la configuración regional de la solicitud
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 variables — pasa los valores como segundo argumento
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 });
  });
}
```

## Notas [#notes]

* [`msg`](/docs/node/reference/functions/msg) registra una cadena para traducirla en tiempo de compilación; `getMessages` la resuelve en tiempo de ejecución.
* Este patrón es útil para cadenas definidas en el ámbito del módulo (constantes, enums, mensajes de error) que necesitan traducirse en cada solicitud.
* Si se pasa `null` o `undefined` a `m`, devuelve `null` o `undefined`, respectivamente.