# node: getMessages
URL: https://generaltranslation.com/fr/docs/node/api/get-messages.mdx
---
title: getMessages
description: Référence API de la fonction getMessages
---

## Aperçu

La fonction `getMessages` est une fonction asynchrone qui renvoie un résolveur pour des messages préenregistrés.
Utilisez-la avec [`msg`](/docs/node/api/strings/msg) (importé depuis `gt-node`) pour enregistrer des chaînes au moment du build et résoudre leurs traductions à l’exécution.

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

// Enregistrer au build (ou dans la portée du module)
const greeting = msg('Hello, world!');

// Résoudre à l'exécution
const m = await getMessages();
const translated = m(greeting);
```

<Callout>
  **Contexte de requête requis :**
  `getMessages` doit être appelé dans un callback [`withGT`](/docs/node/api/with-gt) pour savoir quel paramètre régional utiliser.
</Callout>


## Référence

### Paramètres

Aucun.

### Renvoie

Une promesse qui se résout avec une fonction `m` de résolution de message :

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

| Nom          | Type                          | Description                                                                                                          |
| ------------ | ----------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `encodedMsg` | `string \| null \| undefined` | Une chaîne de message encodée renvoyée par `msg()`. Renvoie `null`/`undefined` si l’argument est `null`/`undefined`. |
| `options?`   | `InlineResolveOptions`        | Valeurs de variables facultatives à interpoler dans le message résolu.                                               |

***


## Exemples

### Utilisation de base

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

// Enregistrer les messages au niveau du module
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' }),
    };
  });
}
```


### Avec des variables

Passez les variables en deuxième argument pour interpoler les valeurs :

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

***


## Remarques

* `msg` enregistre une chaîne pour la traduction au build. `getMessages` la résout à l’exécution.
* Ce schéma est utile pour les chaînes définies au niveau du module (constantes, énumérations, messages d’erreur) qui doivent être traduites per-request.
* Si `null` ou `undefined` est passé à `m`, il renvoie respectivement `null` ou `undefined`.

## Étapes suivantes

* Consultez [`getGT`](/docs/node/api/get-gt) pour traduire directement des chaînes en ligne.
* Consultez [`withGT`](/docs/node/api/with-gt) pour configurer le contexte du paramètre régional.