# react-native: derive
URL: https://generaltranslation.com/it/docs/react-native/api/strings/derive.mdx
---
title: derive
description: Riferimento API per la funzione `derive()` sulle stringhe
---

{/* 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 della traduzione di una stringa.
Questo è 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 funziona generando traduzioni distinte per ogni possibile esito, con il vantaggio di preservare la concordanza, la coniugazione e i cambiamenti nell’ordine delle parole nelle diverse lingue.

<Callout>
  **Voci di traduzione multiple:**
  `derive` crea voci di traduzione separate per ogni possibile esito della funzione avvolta, il che può aumentare significativamente il numero di traduzioni.
  Usa questa funzionalità con giudizio e preferisci le espressioni ICU `select` 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 una funzione statica che restituisce contenuto traducibile. |

### Valore restituito

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 determinabili 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 contenuti riutilizzabili con chiamate di funzione.

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

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 le frasi frammentate nelle chiamate di funzione.

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

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 è sintatticamente complesso.
Devi aggiungere un&#39;istruzione `select` per gestire la concordanza (numero, genere, ecc.).
Poi devi anche elencare tutti i possibili risultati.

```jsx copy
import { gt } from 'gt-react-native';

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 semplice.
Non serve alcuna istruzione `select`, né devi specificare ogni possibile esito.

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

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 gestire contenuti dinamici.

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

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-react-native';

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 e logica inline

Puoi incorporare la logica direttamente nella chiamata `derive`.

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

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

***


## Note

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

## Passaggi successivi

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