# node: Patrones de traducción de cadenas
URL: https://generaltranslation.com/es/docs/node/guides/strings.mdx
---
title: Patrones de traducción de cadenas
description: Dos enfoques para traducir cadenas en Node.js — en línea y registradas previamente
---

Hay tres formas de traducir cadenas en `gt-node`:

1. **En línea con `getGT()`** — traduce las cadenas directamente dentro de los manejadores de solicitud (tiempo de construcción)
2. **Registradas previamente con `msg()` / `getMessages()`** — define las cadenas en el ámbito del módulo y resuélvelas en tiempo de ejecución (tiempo de construcción)
3. **On-demand con `tx()`** — traduce cadenas en tiempo de ejecución, incluido contenido que no se conoce en tiempo de construcción

## Traducción en línea con `getGT()`

Usa [`getGT()`](/docs/node/api/get-gt) cuando la cadena solo se utiliza en un lugar o cuando el contenido depende de datos específicos de la solicitud:

```js title="routes/greeting.js"
import { getGT } from 'gt-node';

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


### Interpolación de variables

Pasa las variables como segundo argumento con marcadores de posición `{name}`:

```js
const gt = await getGT();

gt('Welcome, {name}!', { name: user.displayName });
gt('You have {count} new messages.', { count: unreadCount });
gt('{city} weather: {temp}°F', { city: 'Tokyo', temp: 72 });
```


## Cadenas registradas previamente con `msg()` / `getMessages()`

Usa [`msg()`](/docs/node/api/get-messages) para registrar cadenas en el ámbito del módulo —fuera de cualquier manejador de solicitud—. Luego usa [`getMessages()`](/docs/node/api/get-messages) dentro de los manejadores para resolverlas según la configuración regional actual:

```js title="messages.js"
import { msg } from 'gt-node';

export const GREETING = msg('Hello, world!');
export const WELCOME = msg('Welcome, {name}!');
export const NOT_FOUND = msg('Resource not found.');
export const UNAUTHORIZED = msg('You must be logged in.');
```

```js title="routes/api.js"
import { getMessages } from 'gt-node';
import { GREETING, WELCOME, NOT_FOUND } from './messages.js';

app.get('/api/greeting', async (req, res) => {
  const m = await getMessages();
  res.json({
    greeting: m(GREETING),
    welcome: m(WELCOME, { name: 'Alice' }),
  });
});

app.use(async (req, res) => {
  const m = await getMessages();
  res.status(404).json({ error: m(NOT_FOUND) });
});
```

Este enfoque es el más adecuado cuando:

* La misma cadena se usa en varios manejadores de solicitud
* Las cadenas son constantes compartidas (mensajes de error, etiquetas, enums)
* Quieres tener todas las cadenas traducibles en un solo archivo para revisarlas fácilmente


## Traducción on-demand con `tx()`

Usa [`tx()`](/docs/node/api/strings/tx) cuando el contenido no se conoce en tiempo de construcción; por ejemplo, contenido generado por usuarios o datos dinámicos que no se pueden traducir de antemano:

```js title="routes/translate.js"
import { tx } from 'gt-node';

app.post('/api/translate', async (req, res) => {
  const translated = await tx(req.body.text);
  res.json({ translated });
});
```

`tx` es asíncrono y realiza la traducción bajo demanda mediante una solicitud de red, por lo que es más lento que los enfoques en tiempo de construcción. Úsalo solo cuando `getGT()` o `msg()` no sirvan para ese caso de uso.

## Cuándo usar cada uno

| Patrón                    | Más adecuado para                                                                                                    |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `getGT()`                 | Cadenas de uso puntual, contenido específico de la solicitud, cadenas que solo aparecen en un manejador de solicitud |
| `msg()` / `getMessages()` | Constantes compartidas, mensajes de error, etiquetas de enum y gestión centralizada de cadenas                       |
| `tx()`                    | Contenido dinámico o generado por usuarios que no se conoce en tiempo de construcción                                |

<Callout>
  Ambos enfoques producen traducciones idénticas. La única diferencia es la organización del código: elige el que mejor se adapte a la estructura de tu proyecto.
</Callout>

## Uso de `$context` para resolver ambigüedades

Las cadenas ambiguas pueden dar lugar a traducciones imprecisas. Añade `$context` para orientar al traductor:

```js
// En línea
const gt = await getGT();
gt('Apple', { $context: 'la empresa tecnológica' });
gt('Spring', { $context: 'la estación del año, no un resorte' });

// Registrado previamente
const APPLE = msg('Apple', { $context: 'la fruta' });
const SPRING = msg('Spring', { $context: 'un resorte metálico' });
```


## Ejemplo completo

```js title="server.js"
import express from 'express';
import { initializeGT, withGT, getGT, msg, getMessages } from 'gt-node';

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

// Registrar previamente cadenas compartidas
const ERRORS = {
  notFound: msg('Resource not found.'),
  unauthorized: msg('You must be logged in.'),
  forbidden: msg('You do not have permission to access this resource.'),
};

const app = express();

app.use((req, res, next) => {
  const locale = req.headers['accept-language']?.split(',')[0] || 'en';
  withGT(locale, () => next());
});

// Traducción en línea
app.get('/api/dashboard', async (req, res) => {
  const gt = await getGT();
  res.json({
    title: gt('Dashboard'),
    subtitle: gt('Welcome back, {name}!', { name: req.user.name }),
  });
});

// Mensajes registrados previamente
app.use(async (req, res) => {
  const m = await getMessages();
  res.status(404).json({ error: m(ERRORS.notFound) });
});

app.listen(3000);
```


## Próximos pasos

* [Referencia de la API de `getGT`](/docs/node/api/get-gt)
* [Referencia de la API de `msg` y `getMessages`](/docs/node/api/get-messages)
* [Referencia de la API de `tx`](/docs/node/api/strings/tx) — traducción en tiempo de ejecución
* [Detección de la configuración regional y middleware](/docs/node/guides/middleware) — cómo funciona el contexto de la configuración regional