# gt-node: General Translation Node.js SDK: msg
URL: https://generaltranslation.com/es/docs/node/reference/functions/msg.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Marca y codifica una cadena en el ámbito del módulo para traducirla con General Translation. Referencia de la API de msg.

Registra una cadena (o una lista de cadenas) para su traducción. Usa `msg` con [`getMessages`](/docs/node/reference/functions/get-messages) para registrar cadenas — normalmente en el ámbito del módulo — y obtener sus traducciones en tiempo de ejecución.

## Resumen [#overview]

Llama a `msg` con una cadena. Si no pasas opciones, devuelve la cadena sin cambios. Si pasas opciones (variables de interpolación o metadatos), devuelve una cadena codificada que incluye esas opciones. Pasa el resultado a [`getMessages`](/docs/node/reference/functions/get-messages) para obtener la traducción.

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

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

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` devuelve el mensaje sin cambios cuando se llama sin options. Solo al pasar options produce una cadena codificada. Para recuperar el texto original de una cadena codificada, decodifícala con [`decodeMsg`](/docs/node/reference/functions/decode-msg).*

## Cómo funciona [#how-it-works]

* **Registro.** `msg` marca el contenido para que la [`gt` CLI](/docs/cli/quickstart) lo detecte y lo traduzca. La traducción en sí se resuelve más tarde mediante [`getMessages`](/docs/node/reference/functions/get-messages).
* **Producción.** El contenido dentro de una llamada a `msg` se traduce antes del despliegue. Las traducciones se almacenan en la CDN o en la salida de compilación de tu aplicación, según tu configuración, y se sirven desde allí. Si no se encuentra una traducción, se usa el contenido original.
* **Desarrollo.** Con un `projectId` y una `devApiKey`, el contenido de `msg` se traduce bajo demanda, lo que resulta útil para previsualizarlo en distintos idiomas. Ten en cuenta que habrá una demora que no se produce en las compilaciones de producción.
* **Codificación.** Cuando se proporcionan opciones, el valor de retorno es `interpolatedContent:encodedOptions`: el contenido interpolado, dos puntos y las opciones codificadas en base64. Resuélvelo con [`getMessages`](/docs/node/reference/functions/get-messages) o decodifícalo con [`decodeMsg`](/docs/node/reference/functions/decode-msg).
* **Listas.** Pasar un `string[]` registra cada elemento. Con `$id`, cada elemento recibe un id único de `${$id}.${index}`.

## Parámetros [#parameters]

| Parámetro             | Descripción                                          | Tipo                   | Opcional | Predeterminado |
| --------------------- | ---------------------------------------------------- | ---------------------- | -------- | -------------- |
| [`message`](#message) | La cadena o lista de cadenas que se deben registrar. | `string \| string[]`   | No       | —              |
| [`options`](#options) | Opciones de traducción y variables de interpolación. | `GTTranslationOptions` | Sí       | —              |

### `message` [#message]

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

El texto que se registrará para su traducción, o una lista de cadenas para registrar varias a la vez.

### `options` [#options]

**Tipo** `GTTranslationOptions` · **Opcional**

Opciones de traducción y variables de interpolación:

* `$context?: string` — contexto adicional para ayudar a desambiguar las traducciones.
* `$id?: string` — un ID personalizado para la entrada de traducción (las listas producen `${$id}.${index}`).
* `$format?: string` — el formato del mensaje. El valor predeterminado es `'ICU'`.
* `$maxChars?: number` — máximo de enteros positivos solicitado a las herramientas de traducción. La cadena resuelta se corta a esta longitud si es necesario.
* `$requiresReview?: boolean` — si la traducción requiere aprobación antes de usarse.
* Cualquier otra clave se trata como un valor que se interpolará en la cadena usando la sintaxis `{key}`.

## Devuelve [#returns]

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

El mensaje no cambia cuando no se pasan opciones, o una cadena codificada (con las variables interpoladas aplicadas) cuando se pasan opciones. Si se pasa una lista, se devuelve una lista con la misma estructura.

## Decodificación [#decoding]

Para recuperar la cadena interpolada original de un mensaje codificado, decodifícala 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"
```

## Ejemplos [#examples]

```ts
// Uso básico — marcar un string para traducción
import { msg, getMessages } from 'gt-node';

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

const m = await getMessages();
const translated = m(greeting);
console.log(translated); // "Hello, world!" (traducido al idioma preferido del usuario)
```

```ts
// Uso de variables — "Alice" es una variable y no se traduce
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!" (traducido)
```

```ts
// Uso del formato de mensajes ICU para formatear 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);
```

*Nota: El [formato de mensajes ICU](https://unicode-org.github.io/icu/userguide/format_parse/messages/) es una forma muy útil de dar formato a tus variables.*

## Notas [#notes]

* `msg` marca cadenas para traducción; la traducción se realiza antes del tiempo de ejecución, durante el proceso de compilación (excepto en desarrollo).
* Sin opciones, `msg` devuelve la entrada sin cambios; con opciones devuelve una cadena codificada.
* Resuelve las cadenas codificadas con [`getMessages`](/docs/node/reference/functions/get-messages) o recupera el texto original con [`decodeMsg`](/docs/node/reference/functions/decode-msg).

## Sitemap

See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.