# General Translation Platform: translateMany
URL: https://generaltranslation.com/it/docs/platform/core/reference/gt-class-methods/translation/translate-many.mdx
---

title: translateMany
description: Traduce più stringhe o voci di contenuto strutturato in un'unica richiesta. Riferimento API per translateMany.

---

Traduce più voci di contenuto in un'unica richiesta all'API di General Translation. Usalo per la traduzione batch: è più efficiente che effettuare numerose chiamate individuali a [`translate`](/docs/platform/core/reference/gt-class-methods/translation/translate).

## Panoramica [#overview]

Chiama `translateMany` su un'istanza [`GT`](/docs/platform/core/reference/gt-class/constructor) configurata con una raccolta di voci e una stringa dell'impostazione regionale di destinazione (forma abbreviata) oppure un oggetto options. Accetta le voci come un array o come un record con hash come chiave e restituisce i risultati nella forma corrispondente.

```typescript
const gt = new GT({ apiKey: 'your-api-key', projectId: 'your-project-id' });

const results = await gt.translateMany(
  ['Hello, world!', 'Welcome to our app', 'Click here to continue'],
  'es'
);
```

Firma:

```typescript
// Overload 1: array di entries
translateMany(
  sources: TranslateManyEntry[],
  options: string | TranslateOptions,
  timeout?: number
): Promise<TranslateManyResult>

// Overload 2: record di entries con chiave hash
translateMany(
  sources: Record<string, TranslateManyEntry>,
  options: string | TranslateOptions,
  timeout?: number
): Promise<Record<string, TranslationResult>>
```

*Nota: `translateMany` richiede un `apiKey` (o `devApiKey`) e `projectId` sull&#39;istanza GT.*

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

* **Array vs. record.** Con un array, le voci vengono sottoposte internamente a hashing e i risultati vengono restituiti nell&#39;ordine di input. Con un record, le chiavi vengono trattate come hash e la risposta è un record con le stesse chiavi.
* **Risultati indipendenti.** I singoli errori di traduzione non interrompono il batch: ogni risultato segnala autonomamente il successo o l&#39;errore, quindi il successo parziale è pienamente supportato.
* **Sintassi abbreviata per le opzioni.** Passare una stringa per `options` è una forma abbreviata di `{ targetLocale: string }`, quindi `gt.translateMany(['Hello'], 'es')` e `gt.translateMany(['Hello'], { targetLocale: 'es' })` sono equivalenti.

## Parametri [#parameters]

| Parametro             | Descrizione                                                                        | Tipo                                                                                                                     | Facoltativo | Predefinito |
| --------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | ----------- | ----------- |
| [`sources`](#sources) | Array o record di voci da tradurre.                                                | [`TranslateManyEntry[] \| Record<string, TranslateManyEntry>`](/docs/platform/core/reference/types/translate-many-entry) | No          | —           |
| [`options`](#options) | Stringa dell&#39;impostazione regionale di destinazione oppure un oggetto options. | `string \| TranslateOptions`                                                                                             | No          | —           |
| [`timeout`](#timeout) | Timeout della richiesta in millisecondi.                                           | `number`                                                                                                                 | Sì          | —           |

### `sources` [#sources]

**Tipo** [`TranslateManyEntry[] \| Record<string, TranslateManyEntry>`](/docs/platform/core/reference/types/translate-many-entry) · **Obbligatorio**

Le voci da tradurre. Ogni [`TranslateManyEntry`](/docs/platform/core/reference/types/translate-many-entry) è una semplice stringa oppure un oggetto con `source` (il [`Content`](/docs/platform/core/reference/types/content)) e `metadata` facoltativo (un [`EntryMetadata`](/docs/platform/core/reference/types/entry-metadata)):

```typescript
type TranslateManyEntry = string | { source: Content; metadata?: EntryMetadata };
```

Passa un array per ottenere i risultati nello stesso ordine dell&#39;input, oppure un record con chiavi hash per ottenere i risultati con le stesse chiavi.

### `options` [#options]

**Tipo** `string | TranslateOptions` · **Obbligatorio**

Una stringa che indica l&#39;impostazione regionale di destinazione, ad esempio `'es'`, oppure un oggetto options:

```typescript
type TranslateOptions = {
  targetLocale: string; // impostazione regionale in cui tradurre
  sourceLocale?: string; // sovrascrive il sourceLocale dell'istanza
  modelProvider?: string; // suggerimento facoltativo sul provider del modello
};
```

### `timeout` [#timeout]

**Type** `number` · **Facoltativo**

Timeout della richiesta in millisecondi. Se omesso, viene utilizzato il valore predefinito dell&#39;istanza.

## Restituisce [#returns]

**Tipo** `Promise<TranslateManyResult> | Promise<Record<string, TranslationResult>>`

* L&#39;**input array** restituisce un [`TranslateManyResult`](/docs/platform/core/reference/types/translate-many-result) (un array di oggetti [`TranslationResult`](/docs/platform/core/reference/types/translation-result)), nello stesso ordine dell&#39;input.
* L&#39;**input Record** restituisce un `Record<string, TranslationResult>`, indicizzato con gli stessi hash dell&#39;input.

Prima di leggerne la traduzione, fai il narrowing di ogni risultato in base a `success`.

## Esempi [#examples]

```typescript
// Array di stringhe
const results = await gt.translateMany(['Home', 'About', 'Products', 'Contact'], 'fr');

results.forEach((result, index) => {
  if (result.success) {
    console.log(`Item ${index}: ${result.translation}`);
  } else {
    console.error(`Item ${index} failed: ${result.error}`);
  }
});
```

```typescript
// Array con metadati per voce
const results = await gt.translateMany(
  [
    { source: 'Hello, world!', metadata: { dataFormat: 'ICU' } },
    { source: 'Goodbye, world!' },
  ],
  { targetLocale: 'es' }
);
```

```typescript
// Record indicizzato per hash — i risultati vengono restituiti con le stesse chiavi
const results = await gt.translateMany(
  {
    'greeting-hash': 'Hello, world!',
    'farewell-hash': 'Goodbye, world!',
  },
  'es'
);

console.log(results['greeting-hash'].translation);
```

## Note [#notes]

* Traduce più voci in un&#39;unica richiesta API.
* Un errore in una voce non influisce sulle altre.
* I risultati mantengono lo stesso ordine dell&#39;array di input oppure le stesse chiavi del record di input.