# Éviter qu’un thème enfant écrase les chaînes traduites de son thème parent

> Un thème enfant hérite normalement des traductions de son parent. Mal architecturé, il peut aussi silencieusement les remplacer par des chaînes en anglais.

- Auteur : WordPress Développement
- Publié le : 2021-11-08
- Mis à jour le : 2021-11-08
- Catégorie : Multilingue
- URL : https://www.wpmoderne.fr/multilingue/theme-enfant-ecrase-traductions-parent/

## L’essentiel

- Un thème enfant doit charger son propre domaine de texte, distinct du parent
- L'ordre de chargement des traductions détermine ce qui s'affiche réellement
- Un domaine de texte partagé par erreur peut écraser des chaînes correctes

Un thème enfant hérite normalement de tout ce que propose son thème parent : gabarits, styles, fonctions, et en principe traductions. Sur un projet en cours de personnalisation, certaines chaînes du thème parent, pourtant bien traduites en français dans son fichier `.mo` d'origine, réapparaissent soudainement en anglais dès que le thème enfant est activé. Rien n'a pourtant été modifié dans les fichiers de traduction eux-mêmes.

Ce comportement révèle un problème d'architecture assez classique : le thème enfant charge, volontairement ou non, un domaine de texte qui entre en collision avec celui du parent, ou charge ses traductions dans un ordre qui finit par masquer celles déjà présentes.

## Comprendre le rôle du domaine de texte dans l'héritage

Chaque thème, parent ou enfant, déclare son propre domaine de texte dans l'en-tête de son fichier `style.css`, via le champ `Text Domain`. Ce domaine sert de clé pour retrouver le bon fichier de traduction au moment de l'affichage d'une chaîne, via les fonctions `__()` et `_e()` appelées avec ce même domaine en second argument.

Le thème parent charge généralement ses traductions via `load_theme_textdomain()`, accroché à l'action `after_setup_theme`. Le problème apparaît quand le thème enfant reprend, par copier-coller depuis le parent, exactement le même appel avec le même domaine de texte, sans ajuster le chemin vers son propre dossier `languages/`.

## Le piège concret : deux appels concurrents sur le même domaine

> L'essentiel à retenir : Un thème enfant doit charger son propre domaine de texte, distinct du parent ; L'ordre de chargement des traductions détermine ce qui s'affiche réellement ; Un domaine de texte partagé par erreur peut écraser des chaînes correctes

Prenons un thème parent nommé `theme-parent` qui charge correctement ses traductions :

```
// Dans functions.php du thème parent
function theme_parent_charger_traductions() {
    load_theme_textdomain( 'theme-parent', get_template_directory() . '/languages' );
}
add_action( 'after_setup_theme', 'theme_parent_charger_traductions' );
```

Si le thème enfant reprend le même domaine de texte, mais pointe vers son propre dossier de langues, potentiellement vide ou incomplet :

```
// Dans functions.php du thème enfant, version fautive
function theme_enfant_charger_traductions() {
    load_theme_textdomain( 'theme-parent', get_stylesheet_directory() . '/languages' );
}
add_action( 'after_setup_theme', 'theme_enfant_charger_traductions' );
```

Selon l'ordre d'exécution des deux fonctions accrochées à `after_setup_theme`, le second appel peut écraser le premier pour le même domaine de texte, en pointant vers un dossier où les fichiers `.mo` traduits n'existent tout simplement pas encore, faisant réapparaître les chaînes source en anglais faute de traduction trouvée.

## La bonne architecture : deux domaines distincts

La pratique la plus sûre consiste à donner un domaine de texte propre au thème enfant, différent de celui du parent, réservé aux chaînes qu'il ajoute ou surcharge lui-même, sans jamais recharger le domaine du parent :

```
// Dans functions.php du thème enfant, version correcte
function theme_enfant_charger_traductions() {
    load_child_theme_textdomain(
        'theme-enfant',
        get_stylesheet_directory() . '/languages'
    );
}
add_action( 'after_setup_theme', 'theme_enfant_charger_traductions' );
```

La fonction `load_child_theme_textdomain()` a justement été prévue pour ce cas de figure, en complément de `load_theme_textdomain()` déjà appelée par le parent. Les deux domaines coexistent alors sans collision : le parent conserve ses chaînes traduites intactes, tandis que le thème enfant gère séparément ses propres ajouts.

- Ne jamais réutiliser le domaine de texte du thème parent dans le thème enfant.
- Utiliser `load_child_theme_textdomain()` plutôt que de dupliquer l'appel du parent.
- Vérifier l'en-tête `Text Domain` de chaque `style.css` pour confirmer qu'ils diffèrent bien.

## Ce qu'il reste à surveiller lors d'une évolution du thème

Ce genre de collision réapparaît souvent après une mise à jour du thème parent, si son domaine de texte change de nom sans que le thème enfant ne soit ajusté en conséquence. Un test simple consiste à activer temporairement uniquement le thème parent seul, pour vérifier que toutes ses chaînes s'affichent correctement, avant de réactiver le thème enfant et de comparer les différences éventuelles.

> Un repère utile pour concevoir un couple parent-enfant sain : le thème enfant ne devrait jamais avoir besoin de connaître le domaine de texte du parent, seulement le sien propre.

## En résumé

La collision de domaines de texte entre un thème parent et son enfant reste une source d'erreurs discrète, qui ne provoque aucun message visible mais fait disparaître des traductions correctes sans raison apparente. Séparer clairement les deux domaines, en s'appuyant sur les fonctions prévues pour ce cas précis, évite ce genre de surprise lors de chaque évolution future du thème enfant.