# generaltranslation: General Translation Core SDK: translateMany
URL: https://generaltranslation.com/fr/docs/core/class/methods/translation/translate-many.mdx
---
title: translateMany
description: Référence de l’API pour la méthode GT translateMany de traduction par lot
---

## Vue d’ensemble

La méthode `translateMany` permet de traduire efficacement plusieurs éléments de contenu en une seule requête API.
Elle est optimisée pour le traitement par lots et offre de meilleures performances que plusieurs appels individuels à `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'
);
```

***


## Référence

### Surcharge 1 : tableau d’entrées

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

Renvoie un `TranslateManyResult` (un tableau d’objets `TranslationResult`) dans le même ordre que l’entrée.


### Surcharge 2 : objet enregistrement d’entrées

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

Lorsqu’elle reçoit un enregistrement dont les clés sont des hachages, renvoie un enregistrement dont les clés sont les mêmes hachages.

### Paramètres

<TypeTable
  type={{
  "sources": {
    type: 'TranslateManyEntry[] | Record<string, TranslateManyEntry>',
    description: 'Tableau ou objet contenant les entrées à traduire.',
    optional: false,
  },
  "options": {
    type: 'string | TranslateOptions',
    description: 'Chaîne du paramètre régional cible (forme abrégée) ou objet d’options.',
    optional: false,
  },
  "timeout?": {
    type: 'number',
    description: 'Délai d’expiration facultatif de la requête, en millisecondes.',
    optional: true,
  }
}}
/>

### TranslateManyEntry

Chaque entrée peut être une simple chaîne ou un objet contenant le contenu source et des métadonnées facultatives :

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


### TranslateOptions

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


### Description des paramètres

| Paramètre | Description                                                                                                                                                   |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `sources` | Tableau ou enregistrement d’éléments `TranslateManyEntry`. Chacun peut être une simple chaîne ou un objet avec `source` et `metadata` facultatif.                     |
| `options` | Une chaîne représentant le paramètre régional cible (par ex. `'es'`) ou un objet d’options avec `targetLocale`, `sourceLocale` facultatif et `modelProvider`. |
| `timeout` | Délai d’expiration facultatif de la requête, en millisecondes.                                                                                                |

### Renvoie

* **Entrée sous forme de tableau** → `Promise<TranslateManyResult>` (`TranslationResult[]`), dans le même ordre que l’entrée
* **Entrée sous forme d’enregistrement** → `Promise<Record<string, TranslationResult>>`, indexé par les mêmes hachages

***

## Comportement

### tableau vs enregistrement

* **Array** : les éléments sont hachés en interne ; les résultats sont renvoyés dans l’ordre d’entrée.
* **Record** : les clés sont traitées comme des hachages ; la réponse est un enregistrement avec les mêmes clés.

### Stratégie de gestion des erreurs

* Les échecs de traduction individuels n&#39;interrompent pas l&#39;ensemble du lot
* Chaque résultat indique indépendamment s&#39;il s&#39;agit d&#39;une réussite ou d&#39;un échec
* Les scénarios de réussite partielle sont entièrement pris en charge

### Raccourci pour les options

Vous pouvez passer une chaîne au paramètre `options` comme raccourci pour `{ targetLocale: string }` :

```typescript
// Ces deux formes sont équivalentes :
await gt.translateMany(['Hello', 'Goodbye'], 'es');
await gt.translateMany(['Hello', 'Goodbye'], { targetLocale: 'es' });
```

***


## Exemples

### Tableau de chaînes de caractères

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


### Tableau avec métadonnées

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


### enregistrement (indexé par hachage)

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

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

***


## Remarques

* Traduit plusieurs éléments dans une seule requête API
* Les échecs de traduction d&#39;une entrée n&#39;affectent pas les autres
* Les résultats conservent le même ordre que les entrées d&#39;origine (tableau) ou les mêmes clés (objet)

## Étapes suivantes

* Découvrez les traductions simples avec [translate](/docs/core/class/methods/translation/translate)
* Explorez le [type TranslateManyEntry](/docs/core/types/Entry)
* Familiarisez-vous avec la [structure TranslateManyResult](/docs/core/types/translate-many-result)