# General Translation Platform: formatCutoff
URL: https://generaltranslation.com/it/docs/platform/core/reference/gt-class-methods/formatting/format-cutoff.mdx
---
title: formatCutoff
description: Tronca il testo con caratteri e terminatori di troncamento in base all'impostazione regionale. Riferimento API per formatCutoff.

---

Tronca una stringa su un'istanza di [GT](/docs/platform/core/reference/gt-class/constructor) usando terminatori in base all'impostazione regionale, applicando i caratteri di puntini di sospensione e la spaziatura appropriati per l'impostazione regionale di destinazione. General Translation lo usa per troncare il testo dell'interfaccia utente nel rispetto delle convenzioni delle diverse lingue per indicare il testo troncato.

## Panoramica [#overview]

Chiama `formatCutoff` su un'istanza di [`GT`](/docs/platform/core/reference/gt-class/constructor), passando la stringa da troncare e un oggetto options che specifica `maxChars`. Restituisce la stringa troncata con il terminatore applicato.

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

const formatted = gt.formatCutoff('Hello, world!', {
  maxChars: 8,
});
// "Hello,\u202F…" (spazio unificatore stretto prima dei puntini di sospensione in francese)
```

Firma:

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

*Nota: `formatCutoff` viene eseguito localmente e non richiede una chiave API. Per impostazione predefinita usa l'impostazione regionale di destinazione dell'istanza, con fallback prima all'impostazione regionale sorgente e poi al valore predefinito della libreria (`en`); passa `locales` per sovrascriverla. Per la formattazione senza un'istanza `GT`, vedi la versione autonoma di [`formatCutoff`](/docs/platform/core/reference/utility-functions/formatting/format-cutoff).*

*Nota: il terminatore e il separatore vengono conteggiati in `maxChars`. Gli output di esempio qui sotto riflettono il comportamento attuale della libreria e correggono diversi esempi della documentazione sorgente che omettevano il terminatore dal conteggio (ad esempio, `maxChars: 8` produce `"Hello, …"`, non `"Hello, w…"`).*

## Come funziona [#how-it-works]

### Risoluzione dell'impostazione regionale

* Per impostazione predefinita usa l'impostazione regionale di destinazione dell'istanza, con fallback prima a quella sorgente e poi al valore predefinito della libreria (`en`).
* Può essere ignorata specificando esplicitamente l'opzione `locales`.

### Gestione del limite di caratteri

* **`maxChars` positivo:** tronca a partire dall'inizio e aggiunge il terminatore.
* **`maxChars` negativo:** esegue il taglio dalla fine (seguendo il comportamento di `.slice()`) e antepone il terminatore.
* **`maxChars` zero:** restituisce una stringa vuota.
* **`maxChars` non definito:** non viene applicato alcun troncamento; restituisce la stringa originale.
* Se il troncamento produce una stringa vuota, non viene aggiunto alcun terminatore.

### Comportamento dipendente dall'impostazione regionale

Il metodo seleziona automaticamente i terminatori appropriati in base alla lingua:

* **Francese (`fr`):** `…` con uno spazio stretto unificatore (`\u202F`).
* **Cinese (`zh`):** doppi puntini di sospensione `……` senza separatore.
* **Giapponese (`ja`):** doppi puntini di sospensione `……` senza separatore.
* **Predefinito:** puntini di sospensione singoli `…` senza separatore.

## Parametri [#parameters]

| Parametro             | Descrizione                        | Tipo     | Facoltativo | Predefinito |
| --------------------- | ---------------------------------- | -------- | ----------- | ----------- |
| [`value`](#value)     | La stringa da troncare.            | `string` | No          | —           |
| [`options`](#options) | Configurazione per il troncamento. | `object` | Sì          | —           |

### `value` [#value]

**Tipo** `stringa` · **Obbligatorio**

La stringa da troncare.

### `options` [#options]

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

Configurazione del troncamento:

| Nome         | Descrizione                                                                                                                                                   | Tipo                   | Facoltativo | Predefinito                                          |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | ----------- | ---------------------------------------------------- |
| `locales`    | Impostazioni regionali da usare per la selezione del terminatore (sovrascrivono i valori predefiniti dell'istanza).                                       | `string \| string[]`   | Sì          | impostazioni regionali di rendering dell'istanza |
| `maxChars`   | Numero massimo di caratteri da visualizzare. `Undefined` indica nessun troncamento; i valori negativi tagliano dalla fine; `0` restituisce una stringa vuota. | `number`               | Sì          | —                                                    |
| `style`      | Stile del terminatore.                                                                                                                                        | `'ellipsis' \| 'none'` | Sì          | `'ellipsis'`                                         |
| `terminator` | Terminatore personalizzato per sovrascrivere i valori predefiniti dell'impostazione regionale.                                                            | `string`               | Sì          | —                                                    |
| `separator`  | Separatore personalizzato tra il terminatore e il testo. Ignorato se non viene fornito alcun terminatore.                                                     | `string`               | Sì          | —                                                    |

Il tipo `CutoffFormatOptions`:

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

## Valore restituito [#returns]

**Tipo** `string`

La stringa troncata con il terminatore appropriato, applicato in base alle convenzioni dell'impostazione regionale.

## Esempi [#examples]

```typescript
// Utilizzo di base con le impostazioni regionali dell'istanza
const gt = new GT({ targetLocale: 'en-US' });

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

```typescript
// Override dell'impostazione regionale
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
// Limiti di caratteri negativi
const gt = new GT({ targetLocale: 'en-US' });

// Taglia dalla fine
const fromEnd = gt.formatCutoff('JavaScript Framework', {
  maxChars: -9,
});
console.log(fromEnd); // "…ramework"

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

```typescript
// Opzioni di stile personalizzate
const gt = new GT({ targetLocale: 'en-US' });

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

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

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

```typescript
// Applicazione 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));
// Output: "Very Long Engl…"

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

```typescript
// Gestione dinamica dell'impostazione regionale
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')}`);
});
```

## Note [#notes]

* Il metodo usa l'impostazione regionale di destinazione dell'istanza GT per il rilevamento automatico dell'impostazione regionale, con fallback prima sull'impostazione regionale sorgente e poi sul valore predefinito della libreria (`en`).
* La lunghezza del terminatore e del separatore viene considerata nel calcolo del limite di caratteri.
* Se la lunghezza complessiva di terminatore e separatore supera `maxChars`, il metodo restituisce una stringa vuota.
* I terminatori personalizzati sostituiscono completamente quelli predefiniti specifici dell'impostazione regionale.
* Le prestazioni sono ottimizzate grazie alla memorizzazione nella cache interna delle istanze del formattatore.