# generaltranslation: General Translation Core SDK: translateMany
URL: https://generaltranslation.com/it/docs/core/class/methods/translation/translate-many.mdx
---
title: translateMany
description: Riferimento API per il metodo GT translateMany per le traduzioni in blocco
---

## Panoramica

Il metodo `translateMany` traduce in modo efficiente più contenuti con una singola richiesta API.
È ottimizzato per l'elaborazione in batch e offre prestazioni migliori rispetto a più chiamate individuali a `translate`.

```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'
);
```

***


## Riferimento

### Overload 1: Array di voci

```typescript
translateMany(
  sources: TranslateManyEntry[],
  options: string | TranslateOptions,
  timeout?: number
): Promise<TranslateManyResult>
```

Restituisce un `TranslateManyResult` (un array di oggetti `TranslationResult`) nello stesso ordine dei dati di input.


### Overload 2: Record con voci

```typescript
translateMany(
  sources: Record<string, TranslateManyEntry>,
  options: string | TranslateOptions,
  timeout?: number
): Promise<Record<string, TranslationResult>>
```

Quando viene passato un record con chiavi hash, restituisce un record con le stesse chiavi hash.


### Parametri

<TypeTable
  type={{
  "sources": {
    type: 'TranslateManyEntry[] | Record<string, TranslateManyEntry>',
    description: 'Array o record di voci da tradurre.',
    optional: false,
  },
  "options": {
    type: 'string | TranslateOptions',
    description: "Stringa dell'impostazione regionale di destinazione (forma abbreviata) oppure un oggetto di opzioni.",
    optional: false,
  },
  "timeout?": {
    type: 'number',
    description: 'Timeout facoltativo della richiesta, in millisecondi.',
    optional: true,
  }
}}
/>

### TranslateManyEntry

Ogni voce può essere una stringa semplice oppure un oggetto con il contenuto di origine e metadati facoltativi:

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


### TranslateOptions

```typescript
type TranslateOptions = {
  targetLocale: string;
  sourceLocale?: string;
  modelProvider?: string;
};
```


### Descrizione dei parametri

| Parametro | Descrizione                                                                                                                                                                                 |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `sources` | Array o record di elementi `TranslateManyEntry`. Ciascuno può essere una semplice stringa o un oggetto con `source` e, facoltativamente, `metadata`.                                        |
| `options` | Una stringa che rappresenta l&#39;impostazione regionale di destinazione (ad esempio `'es'`) oppure un oggetto di opzioni con `targetLocale`, `sourceLocale` facoltativo e `modelProvider`. |
| `timeout` | Timeout facoltativo della richiesta in millisecondi.                                                                                                                                        |

### Restituisce

* **Input come array** → `Promise<TranslateManyResult>` (`TranslationResult[]`), nello stesso ordine dell&#39;input
* **Input come record** → `Promise<Record<string, TranslationResult>>`, con chiavi corrispondenti agli stessi hash

***

## Comportamento

### Array vs Record

* **Array**: Le voci vengono sottoposte internamente a hashing; i risultati vengono restituiti nell&#39;ordine di input.
* **Record**: Le chiavi vengono trattate come hash; la risposta è un record con le stesse chiavi.

### Strategia di gestione degli errori

* I singoli errori di traduzione non bloccano l&#39;intero batch
* Ogni risultato indica in modo indipendente se l&#39;operazione è riuscita o meno
* Gli scenari di successo parziale sono pienamente supportati

### Forma abbreviata delle opzioni

Puoi passare una stringa come parametro `options` come forma abbreviata di `{ targetLocale: string }`:

```typescript
// Questi sono equivalenti:
await gt.translateMany(['Hello', 'Goodbye'], 'es');
await gt.translateMany(['Hello', 'Goodbye'], { targetLocale: 'es' });
```

***


## Esempi

### Array di stringhe

```typescript
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}`);
  }
});
```


### Array con metadati

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


### Record (con chiave hash)

```typescript
const results = await gt.translateMany(
  {
    'greeting-hash': 'Hello, world!',
    'farewell-hash': 'Goodbye, world!'
  },
  'es'
);

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

***


## Note

* Traduce più elementi in una singola richiesta API
* Gli errori di traduzione in una voce non influiscono sulle altre
* I risultati mantengono lo stesso ordine delle voci di input (array) o le stesse chiavi (record)

## Prossimi passaggi

* Scopri le traduzioni singole con [translate](/docs/core/class/methods/translation/translate)
* Esplora il [tipo TranslateManyEntry](/docs/core/types/Entry)
* Comprendi la [struttura TranslateManyResult](/docs/core/types/translate-many-result)