{gt("Hello, world!")}
; } ``` Chaque appel à `gt()` crée une **entrée source** — un élément de texte à traduire. En général, une entrée source produit une traduction par langue. ### Qu’est-ce que derive ? La fonction [`derive()`](/docs/react/reference/functions/derive) indique à la CLI de GT d’enregistrer **plusieurs entrées de traduction** à partir d’un seul appel à `gt()`, selon différentes valeurs à l’exécution. Au lieu d’écrire des appels `gt()` distincts pour chaque variante, vous utilisez [`derive()`](/docs/react/reference/functions/derive) pour exprimer toutes les variantes au même endroit, et la CLI génère les entrées source appropriées au build. Par exemple, l’anglais ne marque pas le genre dans "The boy/girl is playing,", alors que l’espagnol le fait ("El niño está jugando" vs "La niña está jugando"). Avec [`derive()`](/docs/react/reference/functions/derive), vous pouvez gérer cela dans un seul appel à `gt()` : ```jsx const subject = isBoy ? "boy" : "girl"; gt(`The ${derive(subject)} is playing.`); ``` Le CLI détecte l’appel à [`derive()`](/docs/react/reference/functions/derive) et enregistre deux entrées source — l’une pour `"The boy is playing."` et l’autre pour `"The girl is playing."` — chacune avec sa propre traduction, avec l’accord grammatical correct en espagnol. ## Le problème : les mappages de un à plusieurs Considérez trois cas de figure montrant comment les entrées source sont associées aux entrées de traduction : ### Cas 1 : mappage un à un Chaque entrée source correspond à une seule entrée de traduction. C’est le cas le plus simple. | Entrées source | Entrées de traduction | | ---------------------- | --------------------- | | The boy is beautiful. | El niño es hermoso. | | The girl is beautiful. | La niña es hermosa. | ### Cas 2 : mappage de plusieurs vers un Plusieurs entrées source fusionnent en une seule traduction. Par exemple, l’anglais a des formes du pluriel, mais le mandarin n’en a pas : | Entrées source | Entrées de traduction | | ----------------- | --------------------- | | J’ai `{n}` chat. | 我有`{n}`只猫。 | | J’ai `{n}` chats. | | ### Cas 3 : mappage de un à plusieurs Une seule entrée source nécessite **plusieurs** traductions. Par exemple, en espagnol, les adjectifs s’accordent en genre, contrairement à l’anglais : | Entrées source | Entrées de traduction | | -------------- | --------------------- | | I am tired | Estoy cansado | | | Estoy cansada | C’était le cas qui n’était pas pris en charge avant cette version. GT partait auparavant du principe d’un mappage un à un entre les entrées source et les traductions. ## Solution : derive avec $context L’option `$context` de GT vous permet de lever l’ambiguïté entre plusieurs entrées de traduction pour un même texte source. Combinée à [`derive()`](/docs/react/reference/functions/derive), vous pouvez l’exprimer directement au point d’appel : ```jsx import { useGT, derive } from 'gt-react'; function StatusMessage({ isMasculine }) { const gt = useGT(); return ({gt("I am tired", { $context: derive( isMasculine ? "inflect as masculine" : "inflect as feminine" ) })}
); } ``` Au moment du build, la CLI détecte l’appel à [`derive()`](/docs/react/reference/functions/derive) et enregistre deux entrées source distinctes, chacune produisant sa propre traduction : ``` "I am tired" ($context: "inflect as masculine") → "Estoy cansado" "I am tired" ($context: "inflect as feminine") → "Estoy cansada" ``` À l’exécution, la bonne traduction est sélectionnée en fonction de la valeur de `isMasculine`. Sans [`derive()`](/docs/react/reference/functions/derive), vous devriez faire deux appels distincts : ```jsx // Sans derive — plus verbeux, texte source dupliqué const message = isMasculine ? gt("I am tired", { $context: "inflect as masculine" }) : gt("I am tired", { $context: "inflect as feminine" }); ``` [`derive()`](/docs/react/reference/functions/derive) permet d’obtenir le même résultat avec moins de redondance et clarifie l’intention. ### Pourquoi ne pas simplement utiliser une condition ? Comme les chaînes de caractères de contenu, les valeurs `$context` doivent être **statiques** — la CLI doit pouvoir les résoudre au build. Vous ne pouvez pas passer directement une expression évaluée à l’exécution comme `$context`, car la CLI ne saurait pas quelles valeurs elle peut prendre. [`derive()`](/docs/react/reference/functions/derive) résout ce problème en remontant la pile d’appels pour déterminer toutes les chaînes de caractères statiques possibles qui pourraient être passées, ce qui permet à la CLI d’enregistrer une entrée source pour chacune d’elles. ## En résumé La dérivation du contexte comble une lacune fondamentale du modèle de traduction : l’incapacité à représenter des mappages de un à plusieurs entre les entrées source et les entrées de traduction. En combinant [`derive()`](/docs/react/reference/functions/derive) avec `$context`, un seul appel à `gt()` peut produire plusieurs traductions, désambiguïsées à l’exécution. ## Liens connexes * [`référence API de derive() pour les chaînes de caractères`](/docs/react/reference/functions/derive) * [`référence API de derive() pour les composants`](/docs/react/reference/components/derive) * [`derive() en Python`](/docs/python/reference/functions/derive) * [`tutoriel derive() (Python)`](/docs/python/guides/declaring-variables) ## Sitemap See the full [sitemap](https://generaltranslation.com/sitemap.md) for all pages.