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

title: msg
description: Contrassegna e codifica una stringa nell'ambito del modulo per la traduzione con General Translation. Riferimento API per msg.

---

Registra una stringa (o un array di stringhe) per la traduzione. Abbina `msg` a [`getMessages`](/docs/node/reference/functions/get-messages) per registrare le stringhe — in genere nell'ambito del modulo — e risolverne le traduzioni in fase di Runtime.

## Panoramica [#overview]

Chiama `msg` con una stringa. Se non passi opzioni, restituisce la stringa invariata. Se invece passi opzioni (variabili di interpolazione o metadati), restituisce una stringa codificata che include tali opzioni. Passa il risultato a [`getMessages`](/docs/node/reference/functions/get-messages) per ottenere la traduzione.

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

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

Firma:

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

*Nota: `msg` restituisce il messaggio invariato se viene chiamato senza opzioni. Produce una stringa codificata solo quando gli vengono passate delle opzioni. Per recuperare il testo originale da una stringa codificata, decodificala con [`decodeMsg`](/docs/node/reference/functions/decode-msg).*

## Come funziona [#how-it-works]

* **Registrazione.** `msg` contrassegna il contenuto in modo che la [`gt` CLI](/docs/cli/quickstart) possa rilevarlo e tradurlo. La traduzione vera e propria viene poi risolta da [`getMessages`](/docs/node/reference/functions/get-messages).
* **Produzione.** Il contenuto all&#39;interno di una chiamata a `msg` viene tradotto prima della distribuzione. Le traduzioni vengono archiviate sulla CDN o nell&#39;output di build della tua app, in base alla configurazione, e servite da lì. Se una traduzione non viene trovata, viene usato il contenuto originale come fallback.
* **Sviluppo.** Con un `projectId` e una `devApiKey`, il contenuto di `msg` viene tradotto on demand, il che è utile per l&#39;anteprima in lingue diverse. Tieni presente che potrebbe esserci un ritardo che non si verifica nelle build di produzione.
* **Codifica.** Quando vengono fornite opzioni, il valore restituito è `interpolatedContent:encodedOptions` — il contenuto interpolato, i due punti e le opzioni codificate in base64. Risolvilo con [`getMessages`](/docs/node/reference/functions/get-messages) oppure decodificalo con [`decodeMsg`](/docs/node/reference/functions/decode-msg).
* **Array.** Passando una `string[]`, viene registrato ogni elemento. Con `$id`, ogni elemento riceve un id univoco nel formato `${$id}.${index}`.

## Parametri [#parameters]

| Parametro             | Descrizione                                                 | Tipo                   | Facoltativo | Predefinito |
| --------------------- | ----------------------------------------------------------- | ---------------------- | ----------- | ----------- |
| [`message`](#message) | La stringa o l&#39;array di stringhe da registrare.         | `string \| string[]`   | No          | —           |
| [`options`](#options) | Opzioni di traduzione e variabili per l&#39;interpolazione. | `GTTranslationOptions` | Sì          | —           |

### `message` [#message]

**Tipo** `string | string[]` · **Obbligatorio**

Il contenuto testuale da registrare per la traduzione, oppure un array di stringhe per registrarne più di una alla volta.

### `options` [#options]

**Tipo** `GTTranslationOptions` · **Facoltativo**

Opzioni di traduzione e variabili di interpolazione:

* `$context?: string` — contesto aggiuntivo per aiutare a chiarire il significato delle traduzioni.
* `$id?: string` — un ID personalizzato per la translation entry (gli array producono `${$id}.${index}`).
* `$format?: string` — il formato del messaggio. Il valore predefinito è `'ICU'`.
* `$maxChars?: number` — numero massimo di caratteri per la traduzione.
* `$requiresReview?: boolean` — indica se la traduzione richiede approvazione prima dell&#39;uso.
* Qualsiasi altra key viene trattata come un valore da interpolare nella stringa usando la sintassi `{key}`.

## Restituisce [#returns]

**Tipo** `string | string[]`

Il messaggio rimane invariato quando non viene passata alcuna opzione, oppure viene restituita una stringa codificata (con le variabili interpolate già applicate) quando vengono passate opzioni. Per gli array, viene restituito un array con la stessa struttura.

## Decodifica [#decoding]

Per recuperare la stringa interpolata originale da un messaggio codificato, decodificalo con [`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"
```

## Esempi [#examples]

```ts
// Utilizzo di base — contrassegna una stringa per la traduzione
import { msg, getMessages } from 'gt-node';

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

const m = await getMessages();
const translated = m(greeting);
console.log(translated); // "Hello, world!" (tradotto nella lingua preferita dell'utente)
```

```ts
// Utilizzo delle variabili — "Alice" è una variabile e non viene tradotta
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!" (tradotto)
```

```ts
// Utilizzo del formato ICU message format per formattare le variabili
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);
```

*Nota: [ICU message format](https://unicode-org.github.io/icu/userguide/format_parse/messages/) è un potente strumento per formattare le variabili.*

## Note [#notes]

* `msg` contrassegna le stringhe da tradurre; la traduzione avviene prima del runtime, durante il processo di build (tranne che in fase di sviluppo).
* Senza opzioni, `msg` restituisce l&#39;input invariato; con opzioni restituisce una stringa codificata.
* Risolvi le stringhe codificate con [`getMessages`](/docs/node/reference/functions/get-messages), oppure recupera il testo originale con [`decodeMsg`](/docs/node/reference/functions/decode-msg).