# General Translation Platform: formatListToParts
URL: https://generaltranslation.com/it/docs/platform/core/reference/utility-functions/formatting/format-list-to-parts.mdx
---

title: formatListToParts
description: Formatta un elenco in parti adattate all'impostazione regionale senza un'istanza GT. Riferimento API per formatListToParts.

---

[`formatListToParts`](/docs/platform/core/reference/gt-class-methods/formatting/format-list-to-parts) è una funzione di utilità autonoma della libreria Core di General Translation che formatta un array in parti specifiche dell&#39;impostazione regionale. Inserisce stringhe separatrici tra gli elementi mantenendo il tipo originale di ciascun elemento e restituisce un `Array<T | string>`.

## Panoramica [#overview]

Importa `formatListToParts` direttamente da `generaltranslation` e chiamalo con un array e un oggetto options. Non richiede una chiave API né un&#39;istanza di [GT](/docs/platform/core/reference/gt-class/constructor). Per una formattazione basata su un&#39;istanza che eredita l&#39;impostazione regionale dell&#39;istanza, usa invece il metodo [`formatListToParts`](/docs/platform/core/reference/gt-class-methods/formatting/format-list-to-parts) su un&#39;istanza di [`GT`](/docs/platform/core/reference/gt-class/constructor).

A differenza di [`formatList`](/docs/platform/core/reference/utility-functions/formatting/format-list), che restituisce una `stringa`, questa funzione mantiene intatti gli elementi originali e inserisce solo separatori di stringa tra di essi — utile per renderizzare array di tipi misti in framework UI come React.

```typescript
import { formatListToParts } from 'generaltranslation';

const parts = formatListToParts(['red', 'green', 'blue'], {
  locales: ['es'],
  type: 'disjunction',
});
// Restituisce: ['red', ', ', 'green', ' o ', 'blue']
```

Firma:

```typescript
formatListToParts<T>(
  array: Array<T>,
  options?: { locales?: string | string[] } & Intl.ListFormatOptions
): Array<T | string>
```

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

* **API sottostante.** Usa lo stesso [`Intl.ListFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) del metodo della classe GT.
* **Preservazione del tipo.** Tra gli elementi vengono inserite solo stringhe separatrici; ogni elemento originale mantiene il proprio tipo, quindi numeri e oggetti restano invariati.
* **Risoluzione dell&#39;impostazione regionale.** Quando `locales` non è specificato, viene usata come fallback l&#39;impostazione regionale predefinita della libreria, `en`.

## Parametri [#parameters]

| Parametro             | Descrizione                                                                            | Tipo                                                        | Facoltativo | Predefinito |
| --------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------- | ----------- | ----------- |
| [`array`](#array)     | L&#39;array degli elementi da formattare.                                              | `Array<T>`                                                  | No          | —           |
| [`options`](#options) | Configurazione di formattazione che include le impostazioni regionali di destinazione. | `{ locales?: string \| string[] } & Intl.ListFormatOptions` | Sì          | `{}`        |

### `array` [#array]

**Tipo** `Array<T>` · **Obbligatorio**

L&#39;array di elementi da formattare. Sono supportati elementi di qualsiasi tipo; gli elementi non stringa vengono restituiti invariati.

### `options` [#options]

**Tipo** `{ locales?: string | string[] } & Intl.ListFormatOptions` · **Facoltativo** · **Predefinito** `{}`

Configurazione della formattazione. La tabella elenca le opzioni comuni esposte dai tipi Core pubblicati e i relativi valori predefiniti effettivi di Core. Consulta le [opzioni del costruttore `Intl.ListFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#options) per ulteriori dettagli standard e specifici del runtime.

| Proprietà       | Descrizione                                               | Tipo                                       | Facoltativo | Predefinito     |
| --------------- | --------------------------------------------------------- | ------------------------------------------ | ----------- | --------------- |
| `locales`       | Una o più impostazioni regionali per la formattazione.    | `string \| string[]`                       | Sì          | `en`            |
| `localeMatcher` | Algoritmo di corrispondenza delle impostazioni regionali. | `'lookup' \| 'best fit'`                   | Sì          | `'best fit'`    |
| `type`          | Tipo di formattazione della lista.                        | `'conjunction' \| 'disjunction' \| 'unit'` | Sì          | `'conjunction'` |
| `style`         | Stile di formattazione della lista.                       | `'long' \| 'short' \| 'narrow'`            | Sì          | `'long'`        |

## Restituisce [#returns]

**Tipo** `Array<T | string>`

Un array contenente gli elementi originali, intervallati da stringhe separatrici specifiche dell&#39;impostazione regionale.

## Esempi [#examples]

```typescript
import { formatListToParts } from 'generaltranslation';

// Lista con congiunzione (predefinita)
console.log(formatListToParts(['A', 'B', 'C'], { locales: 'en' }));
// Output: ['A', ', ', 'B', ', and ', 'C']

// Lista con disgiunzione
console.log(formatListToParts(['A', 'B', 'C'], { locales: 'en', type: 'disjunction' }));
// Output: ['A', ', ', 'B', ', or ', 'C']
```

```typescript
// Array di tipi misti: numeri e oggetti vengono preservati
console.log(formatListToParts(['apple', 42, { type: 'fruit' }], { locales: 'en' }));
// Output: ['apple', ', ', 42, ', e ', { type: 'fruit' }]
```

```typescript
// Disgiunzione spagnola
console.log(formatListToParts(['red', 'green', 'blue'], {
  locales: 'es',
  type: 'disjunction',
}));
// Output: ['red', ', ', 'green', ' o ', 'blue']

// Stile breve
console.log(formatListToParts(['first', 'second'], {
  locales: 'en',
  style: 'short',
}));
// Output: ['first', ' & ', 'second']
```

## Note [#notes]

* I tipi originali degli elementi vengono mantenuti: tra gli elementi vengono inseriti solo i separatori di stringa.
* Questo è il principale elemento distintivo rispetto a [`formatList`](/docs/platform/core/reference/utility-functions/formatting/format-list), che restituisce una `stringa`.
* Particolarmente utile per renderizzare array con tipi misti in framework UI come React.
* Usa lo stesso `Intl.ListFormat` sottostante del metodo della classe GT.