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

## Resumen

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

```js
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);
```

<Callout>
  **Contexto de la solicitud obligatorio:**
  `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 en una función de resolución de mensaje `m`:

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

| Nombre       | Tipo                          | Descripción                                                                                                                  |
| ------------ | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `encodedMsg` | `string \| null \| undefined` | Una cadena codificada del mensaje devuelta por `msg()`. Devuelve `null`/`undefined` si se le proporciona `null`/`undefined`. |
| `options?`   | `InlineResolveOptions`        | Valores opcionales de variables para interpolar 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 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 y mensajes de error) que deben traducirse para cada solicitud.
* Si se pasa `null` o `undefined` a `m`, devuelve `null` o `undefined`, respectivamente.

## Próximos pasos

* Consulta [`getGT`](/docs/node/api/get-gt) para traducir cadenas en línea directamente.
* Consulta [`withGT`](/docs/node/api/with-gt) para establecer el contexto de configuración regional.