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

title: msg
description: Marquez et encodez une chaîne à l’échelle du module pour la traduction avec General Translation. Référence d’API pour msg.

---

Enregistre une chaîne (ou un tableau de chaînes) pour la traduction. Associez `msg` à [`getMessages`](/docs/node/reference/functions/get-messages) pour enregistrer des chaînes — généralement à l’échelle du module — et résoudre leurs traductions à l’exécution.

## Vue d’ensemble [#overview]

Appelez `msg` avec une chaîne de caractères. Si vous ne passez aucune option, la chaîne est renvoyée telle quelle. Si vous passez des options (variables d’interpolation ou métadonnées), une chaîne encodée contenant ces options est renvoyée. Passez le résultat à [`getMessages`](/docs/node/reference/functions/get-messages) pour récupérer la traduction.

```ts
const registered = msg('Hello, world!');
console.log(registered); // "Hello, world!" (inchangé)

const withVars = msg('Hello, {name}!', { name: 'Brian' });
console.log(withVars); // "Hello, Brian:<encoded-options>"
```

Signature :

```ts
msg<T extends string | string[]>(message: T): T;
msg<T extends string | string[]>(message: T, options?: GTTranslationOptions): T extends string ? string : string[];
```

*Remarque : `msg` renvoie le message inchangé lorsqu’il est appelé sans options. Ce n’est que si vous lui passez des options qu’il produit une chaîne encodée. Pour retrouver le texte d’origine à partir d’une chaîne encodée, décodez-la avec [`decodeMsg`](/docs/node/reference/functions/decode-msg).*

## Fonctionnement [#how-it-works]

* **Enregistrement.** `msg` marque le contenu pour que le CLI [`gt`](/docs/cli/quickstart) le repère et le traduise. La traduction proprement dite est ensuite résolue par [`getMessages`](/docs/node/reference/functions/get-messages).
* **Production.** Le contenu passé à `msg` est traduit avant le déploiement. Les traductions sont stockées dans le CDN ou dans la sortie de build de votre application, selon votre configuration, puis servies depuis cet emplacement. Si aucune traduction n’est trouvée, le contenu d’origine est utilisé par défaut.
* **Développement.** Avec un `projectId` et une `devApiKey`, le contenu marqué par `msg` est traduit à la demande, ce qui est utile pour les aperçus dans différentes langues. Prévoyez un délai qui n’existe pas dans les builds de production.
* **Encodage.** Lorsque des options sont fournies, la valeur de retour est `interpolatedContent:encodedOptions` — le contenu interpolé, suivi de deux-points, puis des options encodées en base64. Résolvez-la avec [`getMessages`](/docs/node/reference/functions/get-messages) ou décodez-la avec [`decodeMsg`](/docs/node/reference/functions/decode-msg).
* **Tableaux.** Passer un `string[]` enregistre chaque entrée. Avec `$id`, chaque entrée reçoit un id unique de `${$id}.${index}`.

## Paramètres [#parameters]

| Paramètre             | Description                                         | Type                   | Facultatif | Par défaut |
| --------------------- | --------------------------------------------------- | ---------------------- | ---------- | ---------- |
| [`message`](#message) | La chaîne ou le tableau de chaînes à enregistrer.   | `string \| string[]`   | Non        | —          |
| [`options`](#options) | Options de traduction et variables d’interpolation. | `GTTranslationOptions` | Oui        | —          |

### `message` [#message]

**Type** `string | string[]` · **Obligatoire**

La chaîne à enregistrer pour la traduction, ou un tableau de chaînes pour en enregistrer plusieurs à la fois.

### `options` [#options]

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

Options de traduction et variables d’interpolation :

* `$context?: string` — contexte supplémentaire pour aider à désambiguïser les traductions.
* `$id?: string` — ID personnalisé pour l’entrée de traduction (les tableaux produisent `${$id}.${index}`).
* `$format?: string` — format du message. La valeur par défaut est `'ICU'`.
* `$maxChars?: number` — nombre maximal de caractères pour la traduction.
* `$requiresReview?: boolean` — indique si la traduction doit être approuvée avant utilisation.
* Toute autre clé est traitée comme une valeur à interpoler dans la chaîne à l’aide de la syntaxe `{key}`.

## Retourne [#returns]

**Type** `string | string[]`

Le message reste inchangé lorsqu’aucune option n’est passée, ou devient une chaîne encodée (avec les variables interpolées déjà appliquées) lorsque des options sont passées. Les tableaux renvoient un tableau de même structure.

## Décodage [#decoding]

Pour récupérer la chaîne interpolée d’origine à partir d’un message encodé, décodez-la avec [`decodeMsg`](/docs/node/reference/functions/decode-msg).

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

const encoded = msg('Hello, {name}!', { name: 'Brian' });
const decoded = decodeMsg(encoded);
console.log(decoded); // "Hello, Brian"
```

## Exemples [#examples]

```ts
// Utilisation de base — marquer une chaîne pour la traduction
import { msg, getMessages } from 'gt-node';

const greeting = msg('Hello, world!');

const m = await getMessages();
const translated = m(greeting);
console.log(translated); // "Hello, world!" (traduit dans la langue préférée de l'utilisateur)
```

```ts
// Utilisation de variables — "Alice" est une variable et n'est pas traduite
import { msg, getMessages } from 'gt-node';

const greeting = msg('Hello, {name}!', { name: 'Alice' });

const m = await getMessages();
const translated = m(greeting);
console.log(translated); // "Hello, Alice!" (traduit)
```

```ts
// Utilisation du format de message ICU pour formater les variables
import { msg, getMessages } from 'gt-node';

const encodedString = msg(
  'There are {count, plural, =0 {no items} =1 {one item} other {{count} items}} in the cart',
  { count: 10 }
);

const m = await getMessages();
const translated = m(encodedString);
console.log(translated);
```

*Remarque : le [ICU message format](https://unicode-org.github.io/icu/userguide/format_parse/messages/) est une méthode puissante pour formater vos variables.*

## Remarques [#notes]

* `msg` marque les chaînes à traduire ; la traduction a lieu avant l’exécution, lors du processus de build (sauf en développement).
* Sans options, `msg` renvoie l’entrée telle quelle ; avec des options, il renvoie une chaîne encodée.
* Résolvez les chaînes encodées avec [`getMessages`](/docs/node/reference/functions/get-messages), ou récupérez le texte d’origine avec [`decodeMsg`](/docs/node/reference/functions/decode-msg).