# gt-node: General Translation Node.js SDK: getMessages
URL: https://generaltranslation.com/es/docs/node/reference/functions/get-messages.mdx
Docs index: https://generaltranslation.com/llms.txt
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`](/docs/node/reference/functions/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()`](/docs/node/reference/functions/msg). | `string \| null \| undefined` | No       | —              |
| [`options`](#options)        | Valores de variables y opciones de traducción para interpolar en el mensaje resuelto.      | `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.

## Sitemap

See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.