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

title: formatListToParts
description: Mettre en forme une liste en parties tenant compte du paramètre régional sans instance GT. Référence de l’API pour formatListToParts.

---

[`formatListToParts`](/docs/platform/core/reference/gt-class-methods/formatting/format-list-to-parts) est une fonction utilitaire autonome de la bibliothèque Core de General Translation qui met en forme un array en parties propres au paramètre régional. Elle insère des séparateurs de chaîne entre les éléments tout en préservant le type d’origine de chaque élément, et renvoie un `Array<T | string>`.

## Vue d’ensemble [#overview]

Importez `formatListToParts` directement depuis `generaltranslation` et appelez-la avec un tableau et un objet d’options. Elle ne nécessite ni clé API ni instance de [GT](/docs/platform/core/reference/gt-class/constructor). Pour un formatage basé sur une instance qui hérite du paramètre régional de l’instance, utilisez plutôt la méthode [`formatListToParts`](/docs/platform/core/reference/gt-class-methods/formatting/format-list-to-parts) sur une instance de [`GT`](/docs/platform/core/reference/gt-class/constructor).

Contrairement à [`formatList`](/docs/platform/core/reference/utility-functions/formatting/format-list), qui renvoie une `string` unique, cette fonction conserve les éléments d’origine tels quels et insère uniquement des séparateurs de chaîne entre eux — ce qui est utile pour afficher des tableaux de types mixtes dans des frameworks d’interface utilisateur comme React.

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

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

Signature :

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

## Fonctionnement [#how-it-works]

* **API sous-jacente.** Utilise le même [`Intl.ListFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) que la méthode de classe GT.
* **Préservation du type.** Seules des chaînes de séparation sont insérées entre les éléments ; chaque élément d’origine conserve son type, de sorte que les nombres et les objets sont transmis tels quels.
* **Résolution du paramètre régional.** Lorsque `locales` est omis, le paramètre régional par défaut de la bibliothèque, `en`, est utilisé.

## Paramètres [#parameters]

| Paramètre             | Description                                                                      | Type                                                        | Facultatif | Par défaut |
| --------------------- | -------------------------------------------------------------------------------- | ----------------------------------------------------------- | ---------- | ---------- |
| [`array`](#array)     | Le tableau d’éléments à mettre en forme.                                         | `Array<T>`                                                  | Non        | —          |
| [`options`](#options) | Configuration de mise en forme, y compris le ou les paramètres régionaux cibles. | `{ locales?: string \| string[] } & Intl.ListFormatOptions` | Oui        | `{}`       |

### `array` [#array]

**Type** `Array<T>` · **Obligatoire**

Le tableau des éléments à formater. Tous les types d’éléments sont pris en charge ; les éléments qui ne sont pas des chaînes sont renvoyés tels quels.

### `options` [#options]

**Type** `{ locales?: string | string[] } & Intl.ListFormatOptions` · **facultatif** · **Par défaut** `{}`

Configuration du formatage. Le tableau répertorie les options courantes exposées par les types Core publiés et leurs valeurs par défaut Core effectives. Consultez les [options du constructeur `Intl.ListFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#options) pour obtenir des informations supplémentaires sur le standard et l’environnement d’exécution.

| Propriété       | Description                                              | Type                                       | Optionnel | Par défaut      |
| --------------- | -------------------------------------------------------- | ------------------------------------------ | --------- | --------------- |
| `locales`       | Paramètre(s) régional(aux) utilisé(s) pour le formatage. | `string \| string[]`                       | Oui       | `en`            |
| `localeMatcher` | Algorithme de correspondance des paramètres régionaux.   | `'lookup' \| 'best fit'`                   | Oui       | `'best fit'`    |
| `type`          | Type de formatage de la liste.                           | `'conjunction' \| 'disjunction' \| 'unit'` | Oui       | `'conjunction'` |
| `style`         | Style de formatage de la liste.                          | `'long' \| 'short' \| 'narrow'`            | Oui       | `'long'`        |

## Renvoie [#returns]

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

Un tableau contenant les éléments d’origine, entrecoupés de chaînes de séparation propres au paramètre régional.

## Exemples [#examples]

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

// Liste de conjonction (par défaut)
console.log(formatListToParts(['A', 'B', 'C'], { locales: 'en' }));
// Résultat : ['A', ', ', 'B', ', and ', 'C']

// Liste de disjonction
console.log(formatListToParts(['A', 'B', 'C'], { locales: 'en', type: 'disjunction' }));
// Résultat : ['A', ', ', 'B', ', or ', 'C']
```

```typescript
// Tableaux de types mixtes : les nombres et les objets sont préservés
console.log(formatListToParts(['apple', 42, { type: 'fruit' }], { locales: 'en' }));
// Résultat : ['apple', ', ', 42, ', and ', { type: 'fruit' }]
```

```typescript
// Disjonction en espagnol
console.log(formatListToParts(['red', 'green', 'blue'], {
  locales: 'es',
  type: 'disjunction',
}));
// Résultat : ['red', ', ', 'green', ' o ', 'blue']

// Style court
console.log(formatListToParts(['first', 'second'], {
  locales: 'en',
  style: 'short',
}));
// Résultat : ['first', ' & ', 'second']
```

## Remarques [#notes]

* Les types d’éléments d’origine sont conservés — seuls des séparateurs de chaînes sont insérés entre les éléments.
* C’est ce qui le distingue principalement de [`formatList`](/docs/platform/core/reference/utility-functions/formatting/format-list), qui renvoie une `string` simple.
* Particulièrement utile pour le rendu de tableaux de types mixtes dans des frameworks UI comme React.
* Utilise le même `Intl.ListFormat` sous-jacent que la méthode de la classe GT.