# General Translation React SDKs (gt-react, gt-next): derive
URL: https://generaltranslation.com/it/docs/react/reference/functions/derive.mdx
---

title: derive
description: Contrassegna varianti di contenuto finite all'interno di una traduzione delle stringhe per l'estrazione con General Translation gt-react. Riferimento API per derive.

---

La funzione `derive` consente di usare chiamate di funzione statiche o espressioni di variabili all&#39;interno di una traduzione delle stringhe. È l&#39;equivalente per le stringhe del componente [`<Derive>`](/docs/react/reference/components/derive), utile per il riutilizzo del codice, per internazionalizzare frasi frammentate e per preservare la concordanza grammaticale.

*Disponibile in `gt-react`, `gt-next`, `gt-tanstack-start` e `gt-react-native`. Gli esempi importano da `gt-react`; importa invece dal pacchetto del framework che utilizzi.*

## Panoramica [#overview]

Racchiudi una chiamata di funzione o un&#39;espressione con risultato variabile. La CLI determina ogni possibile esito e crea una voce di traduzione per ciascuno.

```tsx
const getDisplayName = (condition) => (condition ? 'User' : 'Admin');

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

*Nota: `derive` crea una voce di traduzione separata per ogni possibile esito, il che può aumentare notevolmente il numero di traduzioni. Usalo con giudizio e, quando il fattore di moltiplicazione diventa eccessivo, preferisci le istruzioni `select` di ICU.*

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

* **Analisi in fase di build.** La CLI analizza l&#39;espressione racchiusa, determina tutti i possibili valori di ritorno statici e crea una voce di traduzione separata per ciascuno. In questo modo preserva la concordanza grammaticale, la coniugazione e l&#39;ordine delle parole nelle diverse lingue.
* **Invariato a runtime.** `derive` restituisce il proprio argomento invariato a runtime; la derivazione influisce solo sull&#39;estrazione. Esegui `gt validate` dopo aver aggiunto o modificato chiamate a `derive` per verificare che la CLI riesca a risolvere ogni espressione.
* **Requisito di staticità.** È possibile derivare solo contenuti noti in fase di build. Racchiudi qualsiasi contenuto dinamico con [`declareVar`](/docs/react/reference/functions/declare-var).
* **Prestazioni.** Come [`<Derive>`](/docs/react/reference/components/derive), più chiamate a `derive` in una singola stringa moltiplicano il numero totale di voci.

## Parametri [#parameters]

| Parametro             | Descrizione                                                       | Tipo                                               | Facoltativo | Predefinito |
| --------------------- | ----------------------------------------------------------------- | -------------------------------------------------- | ----------- | ----------- |
| [`content`](#content) | Un&#39;espressione statica che restituisce contenuto traducibile. | `string \| boolean \| number \| null \| undefined` | No          | —           |

### `content` [#content]

**Tipo** `string | boolean | number | null | undefined` · **Obbligatorio**

Una chiamata di funzione statica o un&#39;espressione i cui possibili esiti sono analizzabili in fase di build.

## Returns [#returns]

**Type** `T`

Restituisce `content` invariato, mantenendone il tipo `T`.

## Esempi [#examples]

```tsx title="FragmentedSentence.tsx"
import { derive, gt } from 'gt-react';

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

function Component({ gender }) {
  const translation = gt(`The ${derive(getSubject(gender))} is playing.`);
  return <p>{translation}</p>;
}
// "The boy is playing"  -> "El niño está jugando"
// "The girl is playing" -> "La niña está jugando"
```

```tsx title="WithVariables.tsx"
import { derive, declareVar, gt } from 'gt-react';

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

```tsx title="ComplexFunction.tsx"
import { derive, gt } from 'gt-react';

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

```tsx title="InlineExpression.tsx"
import { derive, gt } from 'gt-react';

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

## Note [#notes]

* Usa `derive` con giudizio: può aumentare esponenzialmente le voci di traduzione.
* Tutti i possibili esiti devono essere analizzabili staticamente in fase di build.
* Racchiudi i valori dinamici nelle funzioni derivate in [`declareVar`](/docs/react/reference/functions/declare-var).
* Per la forma JSX, consulta il componente [`<Derive>`](/docs/react/reference/components/derive).