# generaltranslation: General Translation Core SDK: translate
URL: https://generaltranslation.com/it/docs/core/class/methods/translation/translate.mdx
---
title: translate
description: Riferimento API per il metodo `translate` di GT
---

## Panoramica

Il metodo `translate` è la funzione di traduzione principale della libreria GT.
Traduce i contenuti dall'impostazione regionale di origine a una specifica impostazione regionale di destinazione utilizzando servizi di traduzione basati sull'IA.

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

const result = await gt.translate('Hello, world!', 'es');
console.log(result); // "¡Hola, mundo!"
```

Il metodo supporta diversi tipi di contenuto, tra cui testo normale, formato messaggio ICU e messaggi in stile i18next, con metadati facoltativi per migliorare la precisione della traduzione.

<Callout>
  **Autenticazione richiesta:**
  Il metodo `translate` richiede che nell&#39;istanza GT siano configurati sia `apiKey` (o `devApiKey`) sia `projectId`.
</Callout>

***


## Guida di riferimento

### Parametri

<TypeTable
  type={{
  "source": {
    type: 'TranslateManyEntry',
    description: 'Il contenuto da tradurre. Può essere una stringa semplice o un oggetto con source e metadati.',
    optional: false,
  },
  "options": {
    type: 'string | TranslateOptions',
    description: "Stringa dell'impostazione regionale di destinazione (forma abbreviata) o un oggetto di opzioni con targetLocale e altre impostazioni.",
    optional: false,
  },
  "timeout?": {
    type: 'number',
    description: 'Timeout facoltativo della richiesta in millisecondi.',
    optional: true,
  }
}}
/>

### TranslateManyEntry

Il parametro `source` accetta una semplice stringa o un oggetto:

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


### TranslateOptions

Il parametro `options` può essere una stringa che indica l&#39;impostazione regionale (abbreviazione di `targetLocale`) oppure un oggetto:

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


### Descrizione dei parametri

| Parametro | Descrizione                                                                                                                                                                     |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `source`  | Il contenuto da tradurre. Una stringa semplice oppure un oggetto con `source` (Content) e `metadata` facoltativo (EntryMetadata).                                                        |
| `options` | Una stringa con 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

```typescript
Promise<TranslationResult | TranslationError>
```

* **TranslationResult**: Contiene il contenuto tradotto e i metadati
* **TranslationError**: Contiene le informazioni sull&#39;errore se la traduzione non va a buon fine

***


## Comportamento

### Rilevamento del tipo di contenuto

Il metodo rileva automaticamente il tipo di contenuto in base al parametro `source`:

* **String**: Trattata come testo normale o messaggio in formato messaggio ICU
* **Elementi JSX**: Gestiti come contenuto JSX in stile React
* **Oggetti**: Trattati come messaggi strutturati

### Risoluzione dell&#39;impostazione regionale

* L&#39;impostazione regionale di destinazione viene convalidata secondo lo standard BCP-47
* Le mappature personalizzate delle impostazioni regionali vengono applicate, se configurate
* Per le richieste API vengono usati codici locale standard

### Forma abbreviata delle opzioni

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

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

***


## Esempi

### Traduzione semplice di stringhe

```typescript
const result = await gt.translate('Welcome to our application', 'fr');
```


### Con un oggetto di opzioni

```typescript
const result = await gt.translate('Welcome to our application', {
  targetLocale: 'fr',
  sourceLocale: 'en',
});
```


### Con i metadati di origine

```typescript
const result = await gt.translate(
  { source: '{count, plural, other {{count} items}}', metadata: { dataFormat: 'ICU', context: 'Item count display' } },
  { targetLocale: 'es' }
);
```


### Con timeout

```typescript
const result = await gt.translate('Hello, world!', 'es', 5000);
```

***


## Note

* Traduce una determinata stringa nell&#39;impostazione regionale di destinazione e restituisce una Promise
* Usa `translateMany` internamente con una singola voce

## Passaggi successivi

* **[Traduci più elementi con translateMany](/docs/core/class/methods/translation/translate-many)**
* **[Scopri le opzioni di EntryMetadata](/docs/core/types/entry-metadata)**
* **[Esplora il tipo TranslationResult](/docs/core/types/translation-result)**