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

title: formatCutoff
description: Tronque le texte avec des caractères de coupure et des terminateurs adaptés au paramètre régional. Référence d'API pour formatCutoff.

---

Tronque une `string` avec des terminateurs adaptés au paramètre régional sur une instance de [GT](/docs/platform/core/reference/gt-class/constructor), en appliquant les points de suspension et l'espacement appropriés pour le paramètre régional cible. General Translation l'utilise pour tronquer le texte de l'interface utilisateur tout en respectant les conventions des différentes langues pour signaler qu'un texte a été tronqué.

## Vue d’ensemble [#overview]

Appelez `formatCutoff` sur une instance de [`GT`](/docs/platform/core/reference/gt-class/constructor) en lui passant la chaîne à tronquer ainsi qu’un objet d’options spécifiant `maxChars`. La méthode renvoie la chaîne tronquée avec le terminateur appliqué.

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

const formatted = gt.formatCutoff('Hello, world!', {
  maxChars: 8,
});
// "Hello,\u202F…" (espace fine insécable avant le point de suspension en français)
```

Signature :

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

*Remarque : `formatCutoff` s’exécute localement et ne nécessite pas de clé API. Par défaut, il utilise le paramètre régional cible de l’instance, puis, à défaut, le paramètre régional source et enfin celui par défaut de la bibliothèque (`en`) ; passez `locales` pour surcharger ce comportement. Pour effectuer le formatage sans instance `GT`, consultez la version autonome de [`formatCutoff`](/docs/platform/core/reference/utility-functions/formatting/format-cutoff).*

*Remarque : le `terminateur` et le séparateur sont pris en compte dans `maxChars`. Les exemples de sortie ci-dessous reflètent le comportement actuel de la bibliothèque et corrigent plusieurs exemples de la documentation source qui ne tenaient pas compte du `terminateur` dans le décompte (par exemple, `maxChars: 8` produit `"Hello, …"` et non `"Hello, w…"`).*

## Fonctionnement [#how-it-works]

### Résolution du paramètre régional

* Utilise par défaut le paramètre régional cible de l’instance, avec repli sur le paramètre régional source, puis sur la valeur par défaut de la bibliothèque (`en`).
* Peut être remplacé par une option `locales` explicite.

### Traitement de la limite de caractères

* **`maxChars` positif :** tronque depuis le début et ajoute le terminateur à la fin.
* **`maxChars` négatif :** coupe depuis la fin (selon le comportement de `.slice()`) et ajoute le terminateur au début.
* **`maxChars` égal à zéro :** renvoie une chaîne vide.
* **`maxChars` non défini :** aucune troncature n’est appliquée ; renvoie la chaîne source.
* Si la coupure produit une chaîne vide, aucun terminateur n’est ajouté.

### Comportement spécifique au paramètre régional

La méthode sélectionne automatiquement les terminateurs appropriés selon la langue :

* **Français (`fr`) :** `…` avec une espace fine insécable (`\u202F`).
* **Chinois (`zh`) :** double point de suspension `……` sans séparateur.
* **Japonais (`ja`) :** double point de suspension `……` sans séparateur.
* **Par défaut :** point de suspension simple `…` sans séparateur.

## Paramètres [#parameters]

| Paramètre             | Description                 | Type     | Facultatif | Par défaut |
| --------------------- | --------------------------- | -------- | ---------- | ---------- |
| [`value`](#value)     | La chaîne à tronquer.       | `string` | Non        | —          |
| [`options`](#options) | Configuration du tronquage. | `object` | Oui        | —          |

### `value` [#value]

**Type** `string` · **Obligatoire**

Chaîne à tronquer.

### `options` [#options]

**Type** `{ locales?: string | string[] } & CutoffFormatOptions` · **Facultatif**

Configuration de la troncation :

| Name         | Description                                                                                                                                                    | Type                   | Optional | Default                                   |
| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | -------- | ----------------------------------------- |
| `locales`    | Paramètres régionaux à utiliser pour sélectionner le terminateur (remplace les valeurs par défaut de l'instance).                                          | `string \| string[]`   | Oui      | locales d'affichage de l'instance |
| `maxChars`   | Nombre maximal de caractères à afficher. `undefined` signifie aucune troncation ; les valeurs négatives tronquent depuis la fin ; `0` renvoie une chaîne vide. | `number`               | Oui      | —                                         |
| `style`      | Style du terminateur.                                                                                                                                          | `'ellipsis' \| 'none'` | Oui      | `'ellipsis'`                              |
| `terminator` | Terminateur personnalisé remplaçant les valeurs par défaut des paramètres régionaux.                                                                           | `string`               | Oui      | —                                         |
| `separator`  | Séparateur personnalisé entre le terminateur et le texte. Ignoré si aucun terminateur n'est fourni.                                                        | `string`               | Oui      | —                                         |

Le type `CutoffFormatOptions` :

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

## Renvoie [#returns]

**Type** `string`

La chaîne tronquée avec le terminateur approprié, appliqué selon les conventions du paramètre régional.

## Exemples [#examples]

```typescript
// Utilisation de base avec les paramètres régionaux de l'instance
const gt = new GT({ targetLocale: 'en-US' });

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

```typescript
// Remplacement du paramètre régional
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
// Limites de caractères négatives
const gt = new GT({ targetLocale: 'en-US' });

// Découpe depuis la fin
const fromEnd = gt.formatCutoff('JavaScript Framework', {
  maxChars: -9,
});
console.log(fromEnd); // "…ramework"

// Découpe négative plus grande
const moreFromEnd = gt.formatCutoff('Hello, world!', {
  maxChars: -3,
});
console.log(moreFromEnd); // "…d!"
```

```typescript
// Options de style personnalisées
const gt = new GT({ targetLocale: 'en-US' });

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

// Terminateur personnalisé avec séparateur
const customSep = gt.formatCutoff('Another example', {
  maxChars: 10,
  terminator: '[...]',
  separator: ' ',
});
console.log(customSep); // "Anot [...]"

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

```typescript
// Application multilingue
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));
// Sortie : "Very Long Engl…"

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

```typescript
// Gestion dynamique des paramètres régionaux
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')}`);
});
```

## Remarques [#notes]

* La méthode utilise le paramètre régional cible de l’instance GT pour la détection automatique du paramètre régional, puis se rabat sur le paramètre régional source, puis sur la valeur par défaut de la bibliothèque (`en`).
* La longueur du terminateur et du séparateur est prise en compte dans le calcul de la limite de caractères.
* Si la longueur combinée du terminateur et du séparateur dépasse `maxChars`, la méthode renvoie une chaîne vide.
* Les terminateurs personnalisés remplacent entièrement les valeurs par défaut propres au paramètre régional.
* Les performances sont optimisées grâce à la mise en cache interne des instances de formatteur.