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

title: getMessages
description: Obtient un résolveur General Translation pour les messages enregistrés avec msg pour le paramètre régional de la requête en cours. Référence de l’API de getMessages.

---

Une fonction asynchrone qui renvoie un résolveur pour les messages préenregistrés. Utilisez-la avec [`msg`](/docs/node/reference/functions/msg) pour enregistrer des chaînes lors du build et résoudre leurs traductions à l’exécution.

## Vue d’ensemble [#overview]

Enregistrez les chaînes avec `msg` à la portée du module, puis attendez `getMessages` dans la portée de [`withGT`](/docs/node/reference/functions/with-gt) pour obtenir un résolveur synchrone `m(encodedMsg, options?)`.

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

// Enregistrer au build (ou au niveau du module)
const greeting = msg('Hello, world!');

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

Signature :

```ts
getMessages(): Promise<MFunctionType>

type MFunctionType = <T extends string | null | undefined>(
  encodedMsg: T,
  options?: GTTranslationOptions
) => T extends string ? string : T;
```

*Remarque : `getMessages` doit être appelé dans un callback [`withGT`](/docs/node/reference/functions/with-gt) afin qu’il sache quel paramètre régional utiliser.*

## Fonctionnement [#how-it-works]

* **Modèle en deux étapes.** [`msg`](/docs/node/reference/functions/msg) enregistre une chaîne pour une traduction à la compilation ; `getMessages` la résout à l’exécution pour le paramètre régional actif.
* **Chaînes définies au niveau du module.** Ce modèle convient aux chaînes définies au niveau du module — constantes, énumération et messages d’erreur — qui doivent être traduites pour chaque requête.
* **Propagation de `null`.** Si `null` ou `undefined` est passé à `m`, il renvoie respectivement `null` ou `undefined`.

## Paramètres [#parameters]

`getMessages` ne prend aucun paramètre. Le résolveur `m` renvoyé accepte :

| Paramètre                    | Description                                                                                 | Type                          | Facultatif | Par défaut |
| ---------------------------- | ------------------------------------------------------------------------------------------- | ----------------------------- | ---------- | ---------- |
| [`encodedMsg`](#encoded-msg) | Une chaîne de message encodée renvoyée par `msg()`.                                         | `string \| null \| undefined` | Non        | —          |
| [`options`](#options)        | Les valeurs des variables et les options de traduction à interpoler dans le message résolu. | `GTTranslationOptions`        | Oui        | `{}`       |

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

**Type** `string | null | undefined` · **Obligatoire**

Chaîne de message encodée renvoyée par [`msg`](/docs/node/reference/functions/msg). Renvoie `null`/`undefined` si la valeur fournie est `null`/`undefined`.

### `options` [#options]

**Type** `GTTranslationOptions` · **Facultatif**

Valeurs de variables à insérer dans le message résolu à l’aide de la syntaxe `{key}`, ainsi que des options de traduction comme `$context`, `$id`, `$locale` et `$maxChars`. Si le message encodé contient déjà des options d’interpolation (issues de `msg('...', { ... })`), celles-ci sont utilisées et cet argument est ignoré.

## Retourne [#returns]

**Type** `Promise<MFunctionType>`

Aboutit à la fonction `m` de résolution de messages. `m(encodedMsg, options?)` retourne la traduction décodée et interpolée, en conservant les valeurs d’entrée `null`/`undefined`.

## Exemples [#examples]

```ts title="messages.js"
// Enregistrer les messages au niveau du module
import { msg } from 'gt-node';

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

```ts title="handler.js"
// Résoudre les messages pour le paramètre régional de la requête
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"
// Avec des variables — passez les valeurs en second argument
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 });
  });
}
```

## Remarques [#notes]

* [`msg`](/docs/node/reference/functions/msg) enregistre une chaîne pour une traduction à la compilation ; `getMessages` la résout à l’exécution.
* Ce modèle est utile pour les chaînes définies au niveau du module (constantes, énumérations, messages d’erreur) qui nécessitent une traduction par requête.
* Si `null` ou `undefined` est passé à `m`, il renvoie respectivement `null` ou `undefined`.