# node: getMessages
URL: https://generaltranslation.com/es/docs/node/api/get-messages.mdx
---
title: getMessages
description: Referencia de la API para la función getMessages
---

## Resumen

La función `getMessages` es una función asíncrona que devuelve un resolvedor de mensajes prerregistrados.
Úsala junto con [`msg`](/docs/node/api/strings/msg) (importado de `gt-node`) para registrar cadenas en tiempo de construcción y resolver sus traducciones en runtime.

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

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

// Resolver en runtime
const m = await getMessages();
const translated = m(greeting);
```

<Callout>
  **Se requiere el contexto de la solicitud:**
  `getMessages` debe llamarse dentro de un callback de [`withGT`](/docs/node/api/with-gt) para que sepa qué configuración regional debe usar.
</Callout>


## Referencia

### Parámetros

Ninguno.

### Devuelve

Una promesa que se resuelve con una función de resolución de mensajes `m`:

```ts
Promise<(encodedMsg: string | null | undefined, options?: InlineResolveOptions) => string | null | undefined>
```

| Nombre       | Tipo                          | Descripción                                                                                                          |
| ------------ | ----------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `encodedMsg` | `string \| null \| undefined` | Una cadena de mensaje codificada devuelta por `msg()`. Devuelve `null`/`undefined` si se le pasa `null`/`undefined`. |
| `options?`   | `InlineResolveOptions`        | Valores opcionales de variables para interpolarlos en el mensaje resuelto.                                           |

***


## Ejemplos

### Uso básico

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

// Registrar mensajes en el ámbito del módulo
export const GREETING = msg('Hello, world!');
export const WELCOME = msg('Welcome, {name}!');
```

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

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


### Con variables

Pasa las variables como segundo argumento para interpolar valores:

```js title="handler.js"
import { msg, getMessages, withGT } from 'gt-node';

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

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

***


## Notas

* `msg` registra una cadena para su traducción en tiempo de construcción. `getMessages` la resuelve en runtime.
* Este patrón es útil para cadenas definidas en el ámbito del módulo (constantes, enumeraciones, mensajes de error) que deben traducirse por solicitud.
* Si se pasa `null` o `undefined` a `m`, devuelve `null` o `undefined`, respectivamente.

## Siguientes pasos

* Consulta [`getGT`](/docs/node/api/get-gt) para traducir directamente cadenas inline.
* Consulta [`withGT`](/docs/node/api/with-gt) para configurar el contexto de la configuración regional.