# node: Rilevamento dell'impostazione regionale e middleware
URL: https://generaltranslation.com/it/docs/node/guides/middleware.mdx
---
title: Rilevamento dell'impostazione regionale e middleware
description: Come rilevare l'impostazione regionale dell'utente e impostarla per ogni richiesta con withGT
---

Ogni funzione di traduzione in `gt-node` deve sapere a quale impostazione regionale è destinata la richiesta corrente. [`withGT`](/docs/node/api/with-gt) imposta questo contesto usando l'archiviazione locale asincrona: avvolgi il tuo handler e tutte le chiamate di traduzione successive useranno automaticamente l'impostazione regionale corretta.

## Come funziona `withGT`

`withGT` accetta una stringa dell'impostazione regionale e una funzione di callback. All'interno di questa funzione, [`getGT()`](/docs/node/api/get-gt), [`getMessages()`](/docs/node/api/get-messages) e [`getLocale()`](/docs/node/api/get-locale) leggono tutti dall'impostazione regionale che hai impostato:

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

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

<Callout type="warn">
  Le funzioni di traduzione chiamate al di fuori di un contesto `withGT` useranno `defaultLocale`. Racchiudi sempre la gestione delle richieste in `withGT`.
</Callout>


## Strategie per il rilevamento dell&#39;impostazione regionale

### Header `Accept-Language`

Usa [`getRequestLocale`](/docs/node/api/get-request-locale) per analizzare l&#39;header `Accept-Language` e abbinarlo alle impostazioni regionali configurate:

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

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

`getRequestLocale` gestisce automaticamente i valori di qualità, le voci jolly e la corrispondenza tra lingua e regione.

### Basato sui cookie

Mantieni la lingua scelta dall&#39;utente tra una sessione e l&#39;altra:

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

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

// Endpoint per impostare la preferenza della lingua
app.post('/api/set-language', (req, res) => {
  res.cookie('locale', req.body.locale, { maxAge: 365 * 24 * 60 * 60 * 1000 });
  res.json({ ok: true });
});
```


### Parametro dell&#39;URL

Estrai l&#39;impostazione regionale dal percorso dell&#39;URL (ad esempio `/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';
}
```


### Parametro di query

Utilizza il parametro di query `?lang=`:

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


## Combinazione di strategie

In pratica, ti conviene provare più strategie in ordine di priorità:

```js
function detectLocale(req) {
  // 1. Parametro di query esplicito (priorità massima)
  if (req.query.lang) return req.query.lang;

  // 2. Cookie (preferenza salvata dall'utente)
  if (req.cookies?.locale) return req.cookies.locale;

  // 3. Header Accept-Language (impostazione predefinita del browser)
  const acceptLang = req.headers['accept-language']?.split(',')[0];
  if (acceptLang) return acceptLang;

  // 4. Predefinito
  return 'en';
}
```


## Middleware Express

Una configurazione completa del 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 Fastify

Lo stesso pattern funziona anche con Fastify usando 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 });
```


## Leggere l&#39;impostazione regionale attuale

Usa [`getLocale()`](/docs/node/api/get-locale) in qualsiasi punto all&#39;interno di un contesto `withGT` per ottenere l&#39;impostazione regionale effettiva:

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

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


## Passaggi successivi

* [Riferimento API per `withGT`](/docs/node/api/with-gt)
* [Riferimento API per `getLocale`](/docs/node/api/get-locale)
* [Riferimento API per `getRequestLocale`](/docs/node/api/get-request-locale)
* [Pattern di traduzione delle stringhe](/docs/node/guides/strings) — come tradurre i contenuti
* [Archiviazione locale delle traduzioni](/docs/node/guides/local-tx) — includi le traduzioni nel bundle della tua app