# node: Détection du paramètre régional et middleware
URL: https://generaltranslation.com/fr/docs/node/guides/middleware.mdx
---
title: Détection du paramètre régional et middleware
description: Comment détecter le paramètre régional de l’utilisateur et le définir pour chaque requête avec withGT
---

Chaque fonction de traduction de `gt-node` doit savoir quel paramètre régional cible la requête en cours. [`withGT`](/docs/node/api/with-gt) définit ce contexte à l’aide de l’async local storage : encapsulez votre handler de requête, et tous les appels de traduction en aval utiliseront automatiquement le bon paramètre régional.

## Comment `withGT` fonctionne

`withGT` prend une chaîne de paramètre régional et une fonction de rappel. Dans cette fonction de rappel, [`getGT()`](/docs/node/api/get-gt), [`getMessages()`](/docs/node/api/get-messages) et [`getLocale()`](/docs/node/api/get-locale) utilisent tous le paramètre régional que vous définissez :

```js
import { withGT, getLocale } from 'gt-node';

app.use((req, res, next) => {
  const locale = detectLocale(req);
  withGT(locale, () => next());
});
```

<Callout type="warn">
  Les fonctions de traduction appelées en dehors d’un contexte `withGT` utiliseront `defaultLocale`. Encapsulez toujours le traitement de vos requêtes avec `withGT`.
</Callout>


## Stratégies de détection du paramètre régional

### En-tête Accept-Language

Utilisez [`getRequestLocale`](/docs/node/api/get-request-locale) pour analyser l’en-tête `Accept-Language` et le comparer à vos paramètres régionaux configurés :

```js
import { getRequestLocale } from 'gt-node';

function detectLocale(req) {
  return getRequestLocale(req);
}
```

`getRequestLocale` gère automatiquement les valeurs de qualité, les entrées avec joker et la correspondance entre langue et région.

### Basé sur les cookies

Conservez la langue choisie par l’utilisateur d’une session à l’autre :

```js
import cookieParser from 'cookie-parser';
app.use(cookieParser());

function detectLocale(req) {
  return req.cookies.locale || 'en';
}

// Point de terminaison pour définir la préférence de langue
app.post('/api/set-language', (req, res) => {
  res.cookie('locale', req.body.locale, { maxAge: 365 * 24 * 60 * 60 * 1000 });
  res.json({ ok: true });
});
```


### Paramètre d’URL

Extrayez le paramètre régional à partir du chemin de l’URL (par ex. `/es/api/greeting`) :

```js
function detectLocale(req) {
  const segments = req.path.split('/').filter(Boolean);
  const supported = new Set(['es', 'fr', 'ja', 'de']);
  if (segments[0] && supported.has(segments[0])) {
    return segments[0];
  }
  return 'en';
}
```


### Paramètre de requête

Utilisez le paramètre de requête `?lang=` :

```js
function detectLocale(req) {
  return req.query.lang || 'en';
}
```


## Chaînage des stratégies

En pratique, essayez plusieurs stratégies par ordre de priorité :

```js
function detectLocale(req) {
  // 1. Paramètre de requête explicite (priorité maximale)
  if (req.query.lang) return req.query.lang;

  // 2. Cookie (préférence sauvegardée de l'utilisateur)
  if (req.cookies?.locale) return req.cookies.locale;

  // 3. En-tête Accept-Language (valeur par défaut du navigateur)
  const acceptLang = req.headers['accept-language']?.split(',')[0];
  if (acceptLang) return acceptLang;

  // 4. Par défaut
  return 'en';
}
```


## Middleware Express

Configuration complète d’un middleware Express :

```js title="middleware/locale.js"
import { withGT } from 'gt-node';

export function localeMiddleware(req, res, next) {
  const locale =
    req.query.lang ||
    req.cookies?.locale ||
    req.headers['accept-language']?.split(',')[0] ||
    'en';

  withGT(locale, () => next());
}
```

```js title="server.js"
import express from 'express';
import cookieParser from 'cookie-parser';
import { initializeGT } from 'gt-node';
import { localeMiddleware } from './middleware/locale.js';

initializeGT({
  defaultLocale: 'en',
  locales: ['en', 'es', 'fr', 'ja'],
  projectId: process.env.GT_PROJECT_ID,
});

const app = express();
app.use(cookieParser());
app.use(localeMiddleware);
```


## Middleware pour Fastify

La même approche fonctionne avec Fastify à l’aide d’un Hook `preHandler` :

```js title="server.js"
import Fastify from 'fastify';
import cookie from '@fastify/cookie';
import { initializeGT, withGT, getGT } from 'gt-node';

initializeGT({
  defaultLocale: 'en',
  locales: ['en', 'es', 'fr', 'ja'],
  projectId: process.env.GT_PROJECT_ID,
});

const app = Fastify();
await app.register(cookie);

app.addHook('preHandler', (req, reply, done) => {
  const locale =
    req.query.lang ||
    req.cookies?.locale ||
    req.headers['accept-language']?.split(',')[0] ||
    'en';

  withGT(locale, () => done());
});

app.get('/api/greeting', async (req, reply) => {
  const gt = await getGT();
  return { message: gt('Hello, world!') };
});

app.listen({ port: 3000 });
```


## Lire le paramètre régional actuel

Utilisez [`getLocale()`](/docs/node/api/get-locale) à n’importe quel endroit dans le contexte `withGT` pour récupérer le paramètre régional résolu :

```js
import { getLocale } from 'gt-node';

app.get('/api/info', async (req, res) => {
  const locale = getLocale();
  res.json({ currentLocale: locale });
});
```


## Étapes suivantes

* [Référence API `withGT`](/docs/node/api/with-gt)
* [Référence API `getLocale`](/docs/node/api/get-locale)
* [Référence API `getRequestLocale`](/docs/node/api/get-request-locale)
* [Approches de traduction de chaînes](/docs/node/guides/strings) — comment traduire du contenu
* [Stockage local des traductions](/docs/node/guides/local-tx) — incluez les traductions dans le bundle de votre application