# gt-next: General Translation Next.js SDK: derive
URL: https://generaltranslation.com/it/docs/next/api/strings/derive.mdx
---
title: derive
description: Riferimento API per la funzione derive() per le catene
---

{/* GENERATO AUTOMATICAMENTE: non modificare direttamente. Modifica il modello in content/docs-templates/. */}

## Panoramica

La funzione `derive` consente di usare chiamate di funzione statiche o espressioni di variabili all'interno di una stringa da tradurre.
È utile per scrivere codice riutilizzabile, internazionalizzare frasi frammentate e preservare la concordanza.

```jsx
const getDisplayName = (condition) => {
  return condition ? "User" : 'Admin';
};

gt(`${derive(getDisplayName(condition))} says hello.`);
// Crea due voci di traduzione:
// "User says hello." -> "Usuario dice hola."
// "Admin says hello." -> "Administrador dice hola."
```

Questo avviene generando traduzioni distinte per ogni possibile esito, con il vantaggio di preservare la concordanza, la coniugazione e i cambiamenti nell’ordine delle parole tra le lingue.

<Callout>
  **Voci di traduzione multiple:**
  `derive` crea voci di traduzione separate per ogni possibile esito della funzione racchiusa, il che può aumentare significativamente il numero di traduzioni.
  Usa questa funzionalità con giudizio e preferisci le istruzioni `select` di ICU quando il fattore di moltiplicazione diventa eccessivo.
</Callout>

<Callout>
  **Analisi statica:**
  `derive` può analizzare solo contenuti noti in fase di build.
  Qualsiasi contenuto dinamico (variabili, chiamate API, ecc.) deve essere racchiuso in `declareVar`.
</Callout>

## Riferimento

### Parametri

| Nome      | Tipo                                                         | Descrizione                                                            |
| --------- | ------------------------------------------------------------ | ---------------------------------------------------------------------- |
| `content` | `T extends string \| boolean \| number \| null \| undefined` | Una chiamata a funzione statica che restituisce contenuto traducibile. |

### Restituisce

Restituisce `content` di tipo `T`.

***

## Comportamento

### Analisi in fase di build

Durante il processo di build, lo strumento CLI:

1. Analizza la funzione racchiusa in `derive`
2. Determina tutti i possibili valori restituiti dalla funzione (devono essere analizzabili staticamente in fase di build)
3. Crea voci di traduzione separate per ogni esito distinto

### Considerazioni sulle prestazioni

Come `<Derive>`, `derive` moltiplica le voci di traduzione.
Ogni chiamata di funzione con più esiti crea traduzioni separate e più chiamate a `derive` nella stessa stringa moltiplicano esponenzialmente il numero totale di voci.

***

## Esempio

### Contenuti riutilizzabili

Puoi usare `derive` per gestire frasi frammentate o per creare contenuti riutilizzabili con chiamate di funzione.

```jsx copy
import { derive, gt } from 'gt-next';

function getSubject() {
  return "boy";
}

function Component() {
  const translation1 = gt(`The ${derive(getSubject())} is playing.`);
  const translation2 = gt(`The ${derive(getSubject())} is having fun.`);
  const translation3 = gt(`The ${derive(getSubject())} is having a great time.`);
  return <p>{translation1} {translation2} {translation3}</p>;
}
```


### Frasi frammentate

Puoi usare `derive` per gestire frasi frammentate tramite chiamate di funzione.

```jsx copy
import { derive, gt } from 'gt-next';

function getSubject(gender) {
  return gender === 'male' ? 'boy' : 'girl';
}

function Component({ gender }) {
  const translation = gt(`The ${derive(getSubject(gender))} is playing.`);
  return <p>{translation}</p>;
}
```


### Concordanza

Senza `derive`, tradurre la concordanza richiede una sintassi piuttosto complessa.
Devi aggiungere un&#39;istruzione `select` per gestire la concordanza (pluralità, genere, ecc.).
Poi devi anche elencare tutti i possibili risultati.

```jsx copy
import { gt } from 'gt-next';

function getSubject(gender) {
  return gender === 'male' ? 'boy' : 'girl';
}

function Component({ gender }) {
  const translation = gt(
    '{gender, select, boy {The boy is playing.} girl {The girl is playing.} other {}}',
    {
      gender: getSubject(gender) ,
    },
  );
  return <p>{translation}</p>;
}
```

Con `derive`, la concordanza diventa immediata.
Non è necessaria alcuna istruzione `select`, né devi specificare ogni possibile risultato.

```jsx copy
import { derive, declareVar, gt } from 'gt-next';

function getSubject(gender) {
  return gender === 'male' ? 'boy' : 'girl';
}

function Component({ gender }) {
  const translation = gt(`The ${derive(getSubject(gender))} is playing.`);
  return <p>{translation}</p>;
}
```

Usando `derive`, lo strumento CLI rileva che `getSubject` ha due possibili esiti e crea una voce di traduzione per ciascuno.
In questo modo, la concordanza viene gestita automaticamente.

* &quot;Il ragazzo sta giocando&quot; -&gt; &quot;*El* niño está jugando&quot;
* &quot;La ragazza sta giocando&quot; -&gt; &quot;*La* niña está jugando&quot;


### Con variabili

Puoi combinare `derive` con `declareVar` per i contenuti dinamici.

```jsx copy
import { derive, declareVar, gt } from 'gt-next';

function getGreeting(name) {
  return name ? `Hello, ${declareVar(name)}` : 'Hello, stranger';
}

function Component({ name }) {
  const translation = gt(`${derive(getGreeting(name))}! How are you?`);
  return <p>{translation}</p>;
}
```


### Funzioni complesse

Le funzioni possono contenere più rami condizionali e istruzioni `return`.

```jsx copy
import { derive, gt } from 'gt-next';

function getStatusMessage(status, priority) {
  if (status === 'complete') {
    return priority === 'high' ? 'Urgent task completed' : 'Task completed';
  } else if (status === 'pending') {
    return priority === 'high' ? 'Urgent task pending' : 'Task pending';
  }
  return 'Task status unknown';
}

function Component({ status, priority }) {
  const message = gt(`${derive(getStatusMessage(status, priority))}.`);
  return <p>{message}</p>;
}
```


### Espressioni inline e logica

Puoi inserire la logica direttamente nella chiamata a `derive`.

```jsx copy
import { derive, gt } from 'gt-next';

function Component({ gender }) {
  const message = gt(`The ${derive(gender === 'male' ? 'boy' : 'girl')} is playing.`);
  return <p>{message}</p>;
}
```

***


## Note

* Usa `derive` con giudizio, poiché può aumentare esponenzialmente il numero di voci di traduzione
* Tutti i possibili risultati devono poter essere analizzati staticamente in fase di build
* Le variabili all&#39;interno di funzioni statiche devono essere racchiuse in `declareVar`

## Passaggi successivi

* Vedi [`declareVar`](/docs/next/api/strings/declare-var) per contrassegnare i contenuti dinamici all&#39;interno di funzioni statiche
* Vedi [`decodeVars`](/docs/next/api/strings/decode-vars) per estrarre i valori originali dalle variabili dichiarate
* Vedi [`<Derive>`](/docs/next/api/components/derive) per l&#39;equivalente in JSX
* Leggi le [note di rilascio](/devlog/gt-next_v6_12_0) per ulteriori informazioni