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

title: formatListToParts
description: Formatea una lista en partes adaptadas a la configuración regional sin necesidad de una instancia de GT. Referencia de la API para formatListToParts.

---

[`formatListToParts`](/docs/platform/core/reference/gt-class-methods/formatting/format-list-to-parts) es una función utilitaria independiente de la biblioteca Core de General Translation que formatea una lista en partes adaptadas a la configuración regional. Inserta separadores de cadena entre los elementos mientras conserva el tipo original de cada uno y devuelve un `Array<T | string>`.

## Descripción general [#overview]

Importa `formatListToParts` directamente desde `generaltranslation` y llámalo con una lista y un objeto de opciones. No requiere una clave de API ni una instancia de [GT](/docs/platform/core/reference/gt-class/constructor). Si quieres un formateo basado en instancias que herede la configuración regional de la instancia, usa en su lugar el método [`formatListToParts`](/docs/platform/core/reference/gt-class-methods/formatting/format-list-to-parts) de una instancia de [`GT`](/docs/platform/core/reference/gt-class/constructor).

A diferencia de [`formatList`](/docs/platform/core/reference/utility-functions/formatting/format-list), que devuelve un `string` simple, esta función mantiene intactos los elementos originales y solo inserta separadores de cadena entre ellos, lo que resulta útil para renderizar listas con elementos de distintos tipos en frameworks de UI como React.

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

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

Signatura:

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

## Cómo funciona [#how-it-works]

* **API subyacente.** Usa el mismo [`Intl.ListFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) que el método de la clase GT.
* **Preservación del tipo.** Solo se insertan separadores de texto entre los elementos; cada elemento original conserva su tipo, por lo que los números y los objetos pasan sin cambios.
* **Resolución de la configuración regional.** Cuando se omite `locales`, se usa la configuración regional predeterminada de la biblioteca, `en`.

## Parámetros [#parameters]

| Parámetro             | Descripción                                                                             | Tipo                                                        | Opcional | Predeterminado |
| --------------------- | --------------------------------------------------------------------------------------- | ----------------------------------------------------------- | -------- | -------------- |
| [`array`](#array)     | La lista de elementos que se van a formatear.                                           | `Array<T>`                                                  | No       | —              |
| [`options`](#options) | Configuración de formato, incluidas una o varias configuraciones regionales de destino. | `{ locales?: string \| string[] } & Intl.ListFormatOptions` | Sí       | `{}`           |

### `array` [#array]

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

La lista de elementos que se van a formatear. Se admiten elementos de cualquier tipo; los elementos que no sean de tipo string se devuelven sin cambios.

### `options` [#options]

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

Configuración de formato. La tabla enumera las opciones comunes expuestas por los tipos Core publicados y sus valores predeterminados efectivos de Core. Consulte las [opciones del constructor `Intl.ListFormat`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#options) para obtener detalles complementarios estándar y específicos del entorno de ejecución.

| Propiedad       | Descripción                                                          | Tipo                                       | Opcional | Predeterminado  |
| --------------- | -------------------------------------------------------------------- | ------------------------------------------ | -------- | --------------- |
| `locales`       | Configuración regional o configuraciones regionales para el formato. | `string \| string[]`                       | Sí       | `en`            |
| `localeMatcher` | Algoritmo de coincidencia de configuración regional.                 | `'lookup' \| 'best fit'`                   | Sí       | `'best fit'`    |
| `type`          | Tipo de formato de la lista.                                         | `'conjunction' \| 'disjunction' \| 'unit'` | Sí       | `'conjunction'` |
| `style`         | Estilo de formato de la lista.                                       | `'long' \| 'short' \| 'narrow'`            | Sí       | `'long'`        |

## Devuelve [#returns]

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

Una lista de los elementos originales, intercalados con separadores de cadena específicos de la configuración regional.

## Ejemplos [#examples]

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

// Lista de conjunción (predeterminada)
console.log(formatListToParts(['A', 'B', 'C'], { locales: 'en' }));
// Salida: ['A', ', ', 'B', ', and ', 'C']

// Lista de disyunción
console.log(formatListToParts(['A', 'B', 'C'], { locales: 'en', type: 'disjunction' }));
// Salida: ['A', ', ', 'B', ', or ', 'C']
```

```typescript
// Listas de tipos mixtos: los números y objetos se conservan
console.log(formatListToParts(['apple', 42, { type: 'fruit' }], { locales: 'en' }));
// Salida: ['apple', ', ', 42, ', and ', { type: 'fruit' }]
```

```typescript
// Disyunción en español
console.log(formatListToParts(['red', 'green', 'blue'], {
  locales: 'es',
  type: 'disjunction',
}));
// Salida: ['red', ', ', 'green', ' o ', 'blue']

// Estilo corto
console.log(formatListToParts(['first', 'second'], {
  locales: 'en',
  style: 'short',
}));
// Salida: ['first', ' & ', 'second']
```

## Notas [#notes]

* Se conservan los tipos de elemento originales; solo se insertan separadores de cadena entre los elementos.
* Esta es la principal diferencia con [`formatList`](/docs/platform/core/reference/utility-functions/formatting/format-list), que devuelve un `string` plano.
* Resulta especialmente útil para renderizar listas con elementos de tipos mixtos en frameworks de UI como React.
* Usa el mismo `Intl.ListFormat` subyacente que el método de la clase GT.