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

title: formatCutoff
description: Обрезает текст с учетом зависящих от локали символов отсечения и терминаторов. Справочник API для formatCutoff.

---

Обрезает строку в экземпляре [GT](/docs/platform/core/reference/gt-class/constructor), используя зависящие от локали терминаторы, а также подходящие для целевой локали символы многоточия и интервалы. General Translation использует это для обрезки текста в интерфейсе с учетом языковых особенностей обозначения сокращенного текста.

## Обзор [#overview]

Вызовите `formatCutoff` для экземпляра [`GT`](/docs/platform/core/reference/gt-class/constructor), передав строку, которую нужно усечь, и объект параметров с указанием `maxChars`. Метод возвращает усечённую строку с добавленным терминатором.

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

const formatted = gt.formatCutoff('Hello, world!', {
  maxChars: 8,
});
// "Hello,\u202F…" (узкий неразрывный пробел перед многоточием во французском языке)
```

Сигнатура:

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

*Примечание: `formatCutoff` выполняется локально и не требует API-ключа. По умолчанию он использует целевую локаль экземпляра, затем, если она недоступна, исходную локаль, а после этого локаль библиотеки по умолчанию (`en`); чтобы переопределить это поведение, передайте `locales`. О форматировании без экземпляра `GT` см. отдельную функцию [`formatCutoff`](/docs/platform/core/reference/utility-functions/formatting/format-cutoff).*

*Примечание: терминатор и разделитель учитываются в `maxChars`. Примеры результатов ниже отражают текущее поведение библиотеки и исправляют несколько примеров в исходной документации, где терминатор не включался в подсчёт (например, `maxChars: 8` даёт `"Hello, …"`, а не `"Hello, w…"`).*

## Как это работает [#how-it-works]

### Определение локали

* По умолчанию используется целевая локаль экземпляра; если она недоступна, используется исходная локаль, а затем локаль библиотеки по умолчанию (`en`).
* Это можно переопределить, явно указав параметр `locales`.

### Обработка ограничения по числу символов

* **Положительный `maxChars`:** обрезает строку с начала и добавляет в конец терминатор.
* **Отрицательный `maxChars`:** обрезает строку с конца (в соответствии с поведением `.slice()`) и добавляет в начало терминатор.
* **Нулевой `maxChars`:** возвращает пустую строку.
* **Неопределённый `maxChars`:** обрезка не применяется; возвращается исходная строка.
* Если в результате обрезки получается пустая строка, терминатор не добавляется.

### Поведение, зависящее от локали

Метод автоматически выбирает подходящие терминаторы в зависимости от языка:

* **Французский (`fr`):** `…` с узким неразрывным пробелом (`\u202F`).
* **Китайский (`zh`):** двойное многоточие `……` без разделителя.
* **Японский (`ja`):** двойное многоточие `……` без разделителя.
* **По умолчанию:** одинарное многоточие `…` без разделителя.

## Параметры [#parameters]

| Параметр              | Описание                        | Тип      | Необязательный | По умолчанию |
| --------------------- | ------------------------------- | -------- | -------------- | ------------ |
| [`value`](#value)     | Строка, которую нужно обрезать. | `string` | Нет            | —            |
| [`options`](#options) | Параметры обрезки.              | `object` | Да             | —            |

### `value` [#value]

**Тип** `string` · **Обязательно**

Строка, которую нужно обрезать.

### `options` [#options]

**Тип** `{ locales?: string | string[] } & CutoffFormatOptions` · **Необязательно**

Конфигурация усечения:

| Имя          | Описание                                                                                                                                                        | Тип                    | Необязательно | По умолчанию                 |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | ------------- | ---------------------------- |
| `locales`    | Локаль или локали, используемые для выбора терминатора (переопределяют локали рендеринга экземпляра по умолчанию).                                              | `string \| string[]`   | Да            | локали рендеринга экземпляра |
| `maxChars`   | Максимальное количество отображаемых символов. `undefined` означает отсутствие усечения; отрицательные значения обрезают с конца; `0` возвращает пустую строку. | `number`               | Да            | —                            |
| `style`      | Стиль терминатора.                                                                                                                                              | `'ellipsis' \| 'none'` | Да            | `'ellipsis'`                 |
| `terminator` | Пользовательский терминатор, переопределяющий значения локали по умолчанию.                                                                                     | `string`               | Да            | —                            |
| `separator`  | Пользовательский разделитель между терминатором и текстом. Игнорируется, если терминатор не указан.                                                             | `string`               | Да            | —                            |

Тип `CutoffFormatOptions`:

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

## Возвращает [#returns]

**Тип** `string`

Усечённая строка с подходящим терминатором, применённым в соответствии с правилами локали.

## Примеры [#examples]

```typescript
// Базовое использование с локалями экземпляра
const gt = new GT({ targetLocale: 'en-US' });

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

```typescript
// Переопределение локали
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
// Отрицательные ограничения символов
const gt = new GT({ targetLocale: 'en-US' });

// Срез с конца
const fromEnd = gt.formatCutoff('JavaScript Framework', {
  maxChars: -9,
});
console.log(fromEnd); // "…ramework"

// Больший отрицательный срез
const moreFromEnd = gt.formatCutoff('Hello, world!', {
  maxChars: -3,
});
console.log(moreFromEnd); // "…d!"
```

```typescript
// Пользовательские параметры стилизации
const gt = new GT({ targetLocale: 'en-US' });

// Пользовательский терминатор
const custom = gt.formatCutoff('Long description text', {
  maxChars: 12,
  terminator: '...',
});
console.log(custom); // "Long desc..."

// Пользовательский терминатор с разделителем
const customSep = gt.formatCutoff('Another example', {
  maxChars: 10,
  terminator: '[...]',
  separator: ' ',
});
console.log(customSep); // "Anot [...]"

// Без терминатора
const none = gt.formatCutoff('Clean cut text', {
  maxChars: 5,
  style: 'none',
});
console.log(none); // "Clean"
```

```typescript
// Многоязычное приложение
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));
// Вывод: "Very Long Engl…"

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

```typescript
// Динамическая обработка локали
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')}`);
});
```

## Примечания [#notes]

* Метод использует целевую локаль экземпляра GT для автоматического определения локали, при отсутствии совпадения переходя к исходной локали, а затем к локали библиотеки по умолчанию (`en`).
* Длина терминатора и разделителя учитывается при вычислении ограничения на количество символов.
* Если суммарная длина терминатора и разделителя превышает `maxChars`, метод возвращает пустую строку.
* Пользовательские терминаторы полностью переопределяют значения по умолчанию для конкретной локали.
* Производительность оптимизирована за счёт внутреннего кэширования экземпляров форматтера.