# General Translation Platform: formatCutoff
URL: https://generaltranslation.com/es/docs/platform/core/reference/gt-class-methods/formatting/format-cutoff.mdx
---

title: formatCutoff
description: Trunca texto con caracteres de corte y terminadores según la configuración regional. Referencia de la API para formatCutoff.

---

Trunca una cadena en una instancia de [GT](/docs/platform/core/reference/gt-class/constructor) con terminadores adaptados a la configuración regional, aplicando los caracteres de puntos suspensivos y el espaciado adecuados para la configuración regional de destino. General Translation lo usa para truncar texto de la interfaz de usuario respetando las convenciones de los distintos idiomas para indicar texto recortado.

## Descripción general [#overview]

Llama a `formatCutoff` en una instancia de [`GT`](/docs/platform/core/reference/gt-class/constructor) con la cadena que quieres truncar y un objeto de opciones que especifique `maxChars`. Devuelve la cadena truncada con el terminador aplicado.

```typescript
const gt = new GT({ sourceLocale: 'en', targetLocale: 'fr-FR' });

const formatted = gt.formatCutoff('Hello, world!', {
  maxChars: 8,
});
// "Hello,\u202F…" (espacio fino de no separación antes de los puntos suspensivos en francés)
```

Firma:

```typescript
formatCutoff(
  value: string,
  options?: { locales?: string | string[] } & CutoffFormatOptions
): string
```

*Nota: `formatCutoff` se ejecuta localmente y no requiere una clave de API. De forma predeterminada, usa la configuración regional de destino de la instancia; si no está disponible, recurre a la configuración regional de origen y luego al valor predeterminado de la biblioteca (`en`); pasa `locales` para sobrescribirlo. Para dar formato sin una instancia de `GT`, consulta [`formatCutoff`](/docs/platform/core/reference/utility-functions/formatting/format-cutoff) independiente.*

*Nota: el terminador y el separador cuentan para `maxChars`. Los resultados de ejemplo a continuación reflejan el comportamiento actual de la biblioteca y corrigen varios ejemplos de la documentación original que omitían el terminador del conteo (por ejemplo, `maxChars: 8` produce `"Hello, …"`, no `"Hello, w…"`).*

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

### Resolución de la configuración regional

* Usa de forma predeterminada la configuración regional de destino de la instancia; en su defecto, recurre a la configuración regional de origen y luego al valor predeterminado de la biblioteca (`en`).
* Se puede anular con una opción `locales` explícita.

### Procesamiento del límite de caracteres

* **`maxChars` positivo:** trunca desde el principio y añade el terminador.
* **`maxChars` negativo:** recorta desde el final (siguiendo el comportamiento de `.slice()`) y antepone el terminador.
* **`maxChars` cero:** devuelve una cadena vacía.
* **`maxChars` indefinido:** no se aplica ningún truncamiento; devuelve la cadena original.
* Si el corte da como resultado una cadena vacía, no se añade ningún terminador.

### Comportamiento específico según la configuración regional

El método selecciona automáticamente los terminadores adecuados según el idioma:

* **Francés (`fr`):** `…` con un espacio estrecho de no separación (`\u202F`).
* **Chino (`zh`):** puntos suspensivos dobles `……` sin separador.
* **Japonés (`ja`):** puntos suspensivos dobles `……` sin separador.
* **Predeterminado:** puntos suspensivos simples `…` sin separador.

## Parámetros [#parameters]

| Parámetro             | Descripción                 | Tipo     | Opcional | Predeterminado |
| --------------------- | --------------------------- | -------- | -------- | -------------- |
| [`value`](#value)     | La cadena que se truncará.  | `string` | No       | —              |
| [`options`](#options) | Configuración del truncado. | `object` | Sí       | —              |

### `value` [#value]

**Tipo** `string` · **Obligatorio**

La cadena que se va a truncar.

### `options` [#options]

**Tipo** `{ locales?: string | string[] } & CutoffFormatOptions` · **Opcional**

Configuración del truncamiento:

| Nombre       | Descripción                                                                                                                                                                | Tipo                   | Opcional | Predeterminado                         |
| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | -------- | -------------------------------------- |
| `locales`    | Una o varias configuraciones regionales que se usarán para seleccionar el terminador (anula los valores predeterminados de la instancia).                                  | `string \| string[]`   | Sí       | locales de renderizado de la instancia |
| `maxChars`   | Número máximo de caracteres que se mostrarán. `Undefined` significa que no hay truncamiento; los valores negativos recortan desde el final; `0` devuelve una cadena vacía. | `number`               | Sí       | —                                      |
| `style`      | Estilo del terminador.                                                                                                                                                     | `'ellipsis' \| 'none'` | Sí       | `'ellipsis'`                           |
| `terminator` | Terminador personalizado para anular los valores predeterminados de la configuración regional.                                                                             | `string`               | Sí       | —                                      |
| `separator`  | Separador personalizado entre el terminador y el texto. Se ignora si no se proporciona ningún terminador.                                                                  | `string`               | Sí       | —                                      |

El tipo `CutoffFormatOptions`:

```typescript
interface CutoffFormatOptions {
  maxChars?: number;
  style?: 'ellipsis' | 'none';
  terminator?: string;
  separator?: string;
}
```

## Valor devuelto [#returns]

**Tipo** `string`

La cadena truncada a la que se le aplicó el terminador adecuado según las convenciones de la configuración regional.

## Ejemplos [#examples]

```typescript
// Uso básico con las configuraciones regionales de la instancia
const gt = new GT({ targetLocale: 'en-US' });

const truncated = gt.formatCutoff('Hello, world!', {
  maxChars: 8,
});
console.log(truncated); // "Hello, …"
```

```typescript
// Anulación de configuración regional
const gt = new GT({ targetLocale: 'en-US' });

const french = gt.formatCutoff('Bonjour le monde', {
  locales: 'fr-FR',
  maxChars: 10,
});
console.log(french); // "Bonjour \u202F…"
```

```typescript
// Límites de caracteres negativos
const gt = new GT({ targetLocale: 'en-US' });

// Recorte desde el final
const fromEnd = gt.formatCutoff('JavaScript Framework', {
  maxChars: -9,
});
console.log(fromEnd); // "…ramework"

// Recorte negativo mayor
const moreFromEnd = gt.formatCutoff('Hello, world!', {
  maxChars: -3,
});
console.log(moreFromEnd); // "…d!"
```

```typescript
// Opciones de estilo personalizadas
const gt = new GT({ targetLocale: 'en-US' });

// Terminador personalizado
const custom = gt.formatCutoff('Long description text', {
  maxChars: 12,
  terminator: '...',
});
console.log(custom); // "Long desc..."

// Terminador personalizado con separador
const customSep = gt.formatCutoff('Another example', {
  maxChars: 10,
  terminator: '[...]',
  separator: ' ',
});
console.log(customSep); // "Anot [...]"

// Sin terminador
const none = gt.formatCutoff('Clean cut text', {
  maxChars: 5,
  style: 'none',
});
console.log(none); // "Clean"
```

```typescript
// Aplicación multilingüe
class UserInterface {
  private gt: GT;

  constructor(locale: string) {
    this.gt = new GT({ targetLocale: locale });
  }

  truncateTitle(title: string, maxLength = 20): string {
    return this.gt.formatCutoff(title, { maxChars: maxLength });
  }

  truncateDescription(description: string): string {
    return this.gt.formatCutoff(description, { maxChars: 100 });
  }
}

const englishUI = new UserInterface('en-US');
const chineseUI = new UserInterface('zh-CN');

console.log(englishUI.truncateTitle('Very Long English Title Here', 15));
// Salida: "Very Long Engl…"

console.log(chineseUI.truncateTitle('很长的中文标题在这里', 8));
// Salida: "很长的中文标……"
```

```typescript
// Manejo dinámico de configuración regional
const gt = new GT({ sourceLocale: 'en', targetLocale: 'en' });

function adaptiveText(text: string, userLocale: string, context: 'title' | 'body') {
  const limits = {
    title: { en: 50, fr: 45, de: 40, zh: 25 },
    body: { en: 200, fr: 180, de: 160, zh: 100 },
  };

  const maxChars = limits[context][userLocale] || limits[context]['en'];

  return gt.formatCutoff(text, {
    locales: userLocale,
    maxChars,
  });
}

const userPrefs = [
  { locale: 'fr-FR', text: 'Une très longue description française' },
  { locale: 'zh-CN', text: '这是一个非常长的中文描述文本' },
  { locale: 'de-DE', text: 'Eine sehr lange deutsche Beschreibung' },
];

userPrefs.forEach(({ locale, text }) => {
  console.log(`${locale}: ${adaptiveText(text, locale, 'title')}`);
});
```

## Notas [#notes]

* El método usa la configuración regional de destino de la instancia de GT para detectar automáticamente la configuración regional; si no, recurre a la configuración regional de origen y después al valor predeterminado de la biblioteca (`en`).
* La longitud del terminador y del separador se tiene en cuenta al calcular el límite de caracteres.
* Si la longitud combinada del terminador y el separador supera `maxChars`, el método devuelve una cadena vacía.
* Los terminadores personalizados reemplazan por completo los valores predeterminados dependientes de la configuración regional.
* El rendimiento se optimiza mediante el almacenamiento en caché interno de instancias de formateador.