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

title: getTranslations
description: Obtenez un résolveur de dictionnaire General Translation pour le paramètre régional de la requête en cours. Référence de l’API pour getTranslations.

---

Une fonction asynchrone qui renvoie une fonction `t` permettant de résoudre des entrées de dictionnaire par id. Utilisez-la avec un dictionnaire configuré via [`initializeGT`](/docs/node/reference/functions/initialize-gt) afin de traduire, pour chaque requête, du contenu centralisé basé sur des clés.

## Vue d’ensemble [#overview]

Utilisez `await` avec `getTranslations` dans le contexte de [`withGT`](/docs/node/reference/functions/with-gt) pour obtenir une fonction synchrone `t(id, options?)`, puis recherchez les entrées du dictionnaire à l’aide de leur id.

```ts
import { getTranslations } from 'gt-node';

const t = await getTranslations();
const title = t('page.title');
```

Signature :

```ts
getTranslations(rootId?: string): Promise<TFunctionType>

type TFunctionType = ((id: string, options?: TranslationVariables) => string) & {
  obj: (id: string) => DictionaryObjectTranslation;
};
```

*Remarque : `getTranslations` doit être appelé dans un callback [`withGT`](/docs/node/reference/functions/with-gt) afin qu’il sache quel paramètre régional utiliser, et nécessite un `dictionary` (ou [`loadDictionary`](/docs/react/reference/functions/load-dictionary)) configuré dans [`initializeGT`](/docs/node/reference/functions/initialize-gt).*

## Fonctionnement [#how-it-works]

* **Recherche dans le dictionnaire.** `t(id)` résout l’entrée correspondant à `id` dans le dictionnaire et renvoie sa traduction pour le paramètre régional actif, avec repli sur l’entrée source lorsqu’une traduction est manquante.
* **Les `id` inconnus lèvent une erreur.** Si le dictionnaire source ne contient aucune entrée pour `id`, `t(id)` lève l’erreur `Dictionary entry <id> cannot be found`. C’est le seul cas de traduction dans `gt-node` qui lève une erreur au lieu de revenir à une source string.
* **Niveau racine.** Passez `rootId` pour placer toutes les recherches sous un préfixe, afin que `getTranslations('page')` vous permette d’appeler `t('title')` au lieu de `t('page.title')`.
* **Interpolation.** Passez des variables dans l’objet d’options pour les interpoler dans l’entrée à l’aide de la syntaxe `{key}`.
* **Sous-arborescences d’objet.** `t.obj(id)` renvoie une sous-arborescence imbriquée du dictionnaire sous la forme d’un objet simple de strings traduites.

## Paramètres [#parameters]

`getTranslations` accepte un `rootId` facultatif. La fonction `t` renvoyée accepte :

| Paramètre             | Description                                      | Type                   | Facultatif | Par défaut |
| --------------------- | ------------------------------------------------ | ---------------------- | ---------- | ---------- |
| [`rootId`](#root-id)  | Préfixe appliqué à chaque id de recherche.       | `string`               | Oui        | —          |
| [`id`](#id)           | L’id de l’entrée du dictionnaire à résoudre.     | `string`               | Non        | —          |
| [`options`](#options) | Valeurs de variables à interpoler dans l’entrée. | `TranslationVariables` | Oui        | `{}`       |

### `rootId` [#root-id]

**Type** `string` · **Facultatif**

Préfixe appliqué à chaque `id` transmis à `t`. Lorsqu’il est défini, `t('title')` est résolu en `rootId.title`.

### `id` [#id]

**Type** `string` · **Obligatoire**

L’id de l’entrée du dictionnaire à résoudre, avec une notation pointée pour les entrées imbriquées (par exemple, `'page.title'`).

### `options` [#options]

**Type** `TranslationVariables` · **Facultatif**

Objet contenant les valeurs des variables à interpoler dans l’entrée résolue à l’aide de la syntaxe `{key}`.

## Renvoie [#returns]

**Type** `Promise<TFunctionType>`

La promesse se résout avec la fonction `t`. L’appel à `t(id, options?)` renvoie la chaîne traduite ; `t.obj(id)` renvoie un sous-arbre d’objet traduit.

## Exemples [#examples]

```ts title="server.js"
// Configurer un dictionnaire au démarrage
import { initializeGT } from 'gt-node';

initializeGT({
  defaultLocale: 'en',
  locales: ['en', 'es', 'fr'],
  dictionary: {
    page: { title: 'Welcome', greeting: 'Hello, {name}!' },
  },
});
```

```ts title="handler.js"
// Résoudre les entrées du dictionnaire pour le paramètre régional de la requête
import { withGT, getTranslations } from 'gt-node';

function handleRequest(locale) {
  return withGT(locale, async () => {
    const t = await getTranslations();
    return {
      title: t('page.title'),
      greeting: t('page.greeting', { name: 'Alice' }),
    };
  });
}
```

```ts title="handler.js"
// Restreindre les recherches avec un rootId
const t = await getTranslations('page');
const title = t('title'); // résout 'page.title'
```

## Remarques [#notes]

* Les identifiants de dictionnaire inconnus provoquent une erreur ; veillez à garder les clés du dictionnaire synchronisées entre la source et le code.
* Pour les chaînes inline, utilisez [`getGT`](/docs/node/reference/functions/get-gt) ; pour les constantes définies au niveau du module, utilisez [`msg`](/docs/node/reference/functions/msg) avec [`getMessages`](/docs/node/reference/functions/get-messages).