# gt-node: General Translation Node.js SDK: getMessages
URL: https://generaltranslation.com/fr/docs/node/reference/functions/get-messages.mdx
Docs index: https://generaltranslation.com/llms.txt
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`](/docs/node/reference/functions/msg) au niveau 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()`](/docs/node/reference/functions/msg).   | `string \| null \| undefined` | Non        | —          |
| [`options`](#options)        | Les valeurs des variables et les options de traduction à insérer 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`.

## Sitemap

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