Previous Next

Utiliser les adaptateurs de traduction

L'étape suivante est d'utiliser l'adaptateur dans votre code.

Exemple #1 Exemple de code PHP monolingue

print "Exemple\n";
print "=======\n";
print "Ceci la ligne une\n";
print "Aujourd'hui nous sommes le " . date("d/m/Y") . "\n";
print "\n";
print "Correction de la langue ceci est la ligne deux\n";

L'exemple ci-dessus montre l'affichage sans le support de traduction. Vous écrivez probablement votre code dans votre langue maternelle. Généralement vous devez traduire non seulement l'affichage, mais également les messages d'erreur et les messages de log.

La prochaine étape est d'inclure Zend_Translate dans votre code existant. Naturellement il est beaucoup plus facile si vous écrivez dès le début votre code en utilisant Zend_Translate au lieu de modifier votre code après.

Exemple #2 Exemple de code PHP multilingue

$translate = new Zend_Translate('gettext',
                                '/mon/chemin/source-de.mo',
                                'de');
$translate->addTranslation('//mon/chemin/fr-source.mo', 'fr');

print $translate->_("Exemple")."\n";
print "=======\n";
print $translate->_("Ceci la ligne une")."\n";
printf($translate->_("Aujourd'hui nous sommes le %1\$s") . "\n",
                     date("d/m/Y"));
print "\n";

$translate->setLocale('fr');
print $translate->_("Correction de la langue ceci est la ligne deux") . "\n";

Maintenant regardons plus attentivement ce qui a été fait et la façon d'intégrer Zend_Translate dans votre code.

Créer un nouvel objet de traduction et définir l'adaptateur de base :

$translate = new Zend_Translate('gettext',
                                '/chemin/vers/source-de.mo',
                                'de');
Dans cet exemple nous avons décidé d'utiliser l'adaptateur Gettext. Nous plaçons notre fichier source-de.mo dans le dossier /chemin/vers. Le fichier gettext inclura la traduction allemande. Et nous avons également ajouté un autre fichier de langue pour le français.

L'étape suivante est d'envelopper toutes les chaînes qui doivent être traduites. L'approche la plus simple est d'avoir seulement des chaînes simples ou des phrases comme celle-ci :

print $translate->_("Exemple")."\n";
print "=======\n";
print $translate->_("Ceci la ligne une")."\n";
Certaines chaînes ne sont pas nécessairement traduites. La ligne séparatrice est toujours la même, même dans d'autres langues.

Avoir des valeurs de données intégrées dans une chaîne de traduction est également supporté par l'utilisation des paramètres inclus.

printf($translate->_("Aujourd'hui nous sommes le %1\$s") . "\n",
                     date("d/m/Y"));
Au lieu de print(), utiliser la fonction printf() et remplacer tous les paramètres avec des éléments de type %1\$s. Le premier est %1\$s, le second %2\$s, et ainsi de suite. De cette façon une traduction peut être faite sans savoir la valeur exacte. Dans notre exemple, la date est toujours le jour actuel, mais la chaîne peut être traduite sans connaissance du jour actuel.

Chaque chaîne est identifiée dans le stockage de traduction par un identificateur de message. Vous pouvez employer l'identificateur de message au lieu des chaînes dans votre code, comme ceci :

print $translate->_(1)."\n";
print "=======\n";
print $translate->_(2)."\n";
faire ceci a plusieurs inconvénients :

Vous ne pouvez pas voir ce que votre code devrait afficher juste en lisant celui-ci.

En outre vous obtiendrez des problèmes si certaines chaînes ne sont pas traduites. Vous devez toujours imaginer comment la traduction fonctionne. Premièrement Zend_Translate vérifie si la langue choisie a une traduction pour l'identificateur de message ou la chaîne fournie. Si aucune chaîne de traduction n'a été trouvée, elle se reporte sur la langue suivante comme définie dans Zend_Locale. Ainsi le "de_AT" devient seulement "de". Si aucune traduction n'est trouvée pour le "de", alors le message original est retourné. De cette façon vous avez toujours un affichage, au cas où la traduction de message n'existerait pas dans votre stockage des messages. Zend_Translate ne lève jamais d'erreur ou d'exception en traduisant les chaînes.

Structures des sources de traduction

L'étape suivante est la création des sources de traduction pour les multiples langues vers lesquelles vous traduisez. Chaque adaptateur est créé de sa propre manière comme décrit ici. Mais il y a quelques dispositifs généraux qui sont valables pour tous les adaptateurs.

Vous devrez savoir où stocker vos fichiers sources de traduction. Avec Zend_Translate vous n'avez aucune restriction. Les structures suivantes sont préférables :

  • Structure de source unique

    /application
    /languages
      lang.en
      lang.de
    /library

    Positif : Tous les fichiers sources pour chacune des langues peuvent être trouvés dans un dossier. Aucun fractionnement des fichiers.

  • Source structurée par langue

    /application
    /languages
      /en
        lang.en
        other.en
      /de
        lang.de
        other.de
    /library

    Positif : chaque langue est située dans un dossier. La traduction est facilitée car un seul dossier doit être traduit par une équipe de langue. En outre l'utilisation de dossiers multiples est transparente.

  • Source structurée par application

    /application
      /languages
        lang.en
        lang.de
        other.en
        other.de

    Positif : tous les fichiers sources pour chacune des langues peuvent être trouvés dans un seul dossier. Aucun fractionnement des fichiers.

    Négatif : avoir des dossiers multiples pour la même langue est problématique.

  • Source structurée par Gettext

    /languages
      /de
        /LC_MESSAGES
          lang.mo
          other.mo
      /en
        /LC_MESSAGES
          lang.mo
          other.mo

    Positif : de vieilles sources de gettext peuvent être utilisées sans changer la structure.

    Négatif : avoir des dossiers de dossiers peut être embrouillant pour les personnes qui n'ont pas utilisé gettext avant.

  • Source structurée par fichier

    /application
      /models
        mymodel.php
        mymodel.de
        mymodel.en
      /views
      /controllers
        mycontroller.de
    /document_root
      /images
      /styles
      .htaccess
      index.php
      index.de
    /library
      /Zend

    Positif : chaque fichier est lié à sa propre source de traduction.

    Négatif : de multiples petits fichiers sources de traduction rendent plus difficile la traduction. En outre chaque fichier doit être ajouté comme source de traduction.

Les fichiers source uniques et structurés par langue sont les plus utilisés pour Zend_Translate.

Maintenant, que nous connaissons la structure que nous voulons avoir, nous devons créer nos fichiers sources de traduction.

Créer des fichiers sources de type tableau

Les fichiers sources de type tableau sont simplement des tableaux. Mais vous devez les définir manuellement parce qu'il n'y a aucun outil pour automatiser cela. Mais parce qu'ils sont très simples, ils représentent la manière la plus rapide de rechercher des messages si votre code fonctionne comme prévu. C'est généralement le meilleur adaptateur pour démarrer avec des systèmes multilingues.

$english = array('message1' => 'message1',
                 'message2' => 'message2',
                 'message3' => 'message3');
$german = array('message1' => 'Nachricht1',
                'message2' => 'Nachricht2',
                'message3' => 'Nachricht3');

$translate = new Zend_Translate('array', $english, 'en');
$translate->addTranslation($deutsch, 'de');

Depuis la version 1.5 il est également possible d'avoir des tableaux inclus dans un fichier externe. Vous devez simplement fournir le nom de fichier, Zend_Translate l'inclura automatiquement et recherchera le tableau. Voir l'exemple suivant pour les détails :

// montableau.php
return array(
    'message1' => 'Nachricht1',
    'message2' => 'Nachricht2',
    'message3' => 'Nachricht3');

// contrôleur
$translate = new Zend_Translate('array',
                                'chemin/vers/montableau.php',
                                'de');

Note:

Les fichiers qui ne renvoient pas un tableau ne seront pas inclus. N'importe quel rendu issu de ce fichier sera ignoré et également supprimé.

Créer des fichiers sources Gettext

Des fichiers source Gettext sont créés par la bibliothèque GNU gettext. Il y a plusieurs outils libres disponibles qui peuvent analyser vos fichiers de code et créer les fichiers sources nécessaires à gettext. Ces fichiers se terminent par *.mo et ce sont des fichiers binaires. Un gratuiciel pour créer ces fichiers est » poEdit. Cet outil vous aide également pour le processus de traduction lui-même.

// Les fichiers mo sont créés et déjà traduits
$translate = new Zend_Translate('gettext',
                                'chemin/vers/english.mo',
                                'en');
$translate->addTranslation('chemin/vers/german.mo', 'de');

Comme vous pouvez le voir, les adaptateurs sont utilisés exactement de la même manière, avec juste une petite différence : changer "array" en "gettext". Toutes autres utilisations sont exactement les mêmes qu'avec tous autres adaptateurs. Avec l'adaptateur de gettext vous ne devez plus vous occuper de la structure des répertoires, du "bindtextdomain" et du "textdomain". Fournissez juste le chemin et le nom de fichier à l'adaptateur.

Note:

Vous devriez toujours employer UTF-8 comme source d'encodage. Autrement vous aurez des problèmes si vous employez deux encodages différents. Par exemple, si un de vos fichiers source est encodé en ISO-8815-1 et un fichier différent est codé avec CP815. Vous ne pouvez utiliser qu'un seul encodage pour vos fichiers sources, ainsi une de vos langues ne s'affichera probablement pas correctement.

UTF-8 est un format portable qui supporte toutes les langues. Si vous employez l'encodage UTF-8 pour toutes les langues, vous éliminez le problème des encodages incompatibles.

La plupart des éditeur gettext ajoutent les informations de l'adaptateur comme chaines de traduction vides. C'est pour cela que traduire des chaines vides ne fonctionne pas avec l'adaptateur gettext. A la place, elles sont effacées de la table de traduction. getAdapterInfo() retourne les informations de l'adaptateur gettext, notamment les informations des fichiers gettext ajoutés.

// Informations sur l'adaptateur
$translate = new Zend_Translate('gettext',
                                'path/to/english.mo',
                                'en');
print_r $translate->getAdapterInfo();

Créer des fichiers source TMX

Les fichiers sources TMX sont les nouveaux standards industriels. Ils ont l'avantage d'être des fichiers XML et ainsi ils sont lisibles par tout éditeur de fichier et naturellement ils sont lisibles pour l'homme. Vous pouvez soit créer des fichiers TMX manuellement avec un éditeur de texte, soit utiliser un outil. Mais la plupart des programmes actuellement disponibles pour développer des fichiers source TMX ne sont pas des gratuiciels.

Exemple #3 Exemple de fichier TMX




 
Nachricht1 message1 message2 Nachricht2
$translate = new Zend_Translate('tmx',
                                'chemin/vers/mytranslation.tmx',
                                'en');
// TMX peut contenir différentes langues dans le même fichier

Les fichiers TMX peuvent avoir plusieurs langues dans le même fichier. Toute autre langue incluse est ajoutée automatiquement, ainsi vous n'avez pas à appeler addLanguage().

Si vous voulez avoir seulement les langues spécifiées de la source traduite, vous pouvez régler l'option defined_language à TRUE. Avec cette option vous pouvez ajouter les langues souhaitées explicitement avec addLanguage(). La valeur par défaut pour cette option est d'ajouter toutes les langues.

Créer des fichiers source CSV

Les fichiers sources CSV sont petits et lisibles pour l'homme. Si vos clients veulent eux-mêmes traduire, vous utiliserez probablement l'adaptateur CSV.

Exemple #4 Exemple avec un fichier CSV

#Exemple de fichier csv
message1;Nachricht1
message2;Nachricht2
$translate = new Zend_Translate('csv',
                                'chemin/vers/matraduction.csv',
                                'de');
$translate->addTranslation('chemin/vers/autretraduction.csv',
                           'fr');

Il existe trois options différentes pour l'adaptateur CSV. Vous pouvez paramétrer "delimiter", "limit" et "enclosure".

Le délimiteur standard des fichiers CSV est le signe ";". Mais celui-ci n'est pas obligatoire. Avec l'option "delimiter" vous pouvez décider d'utiliser un autre signe de séparation.

La taille limite d'une ligne de fichier CSV est par défaut "0" Ce qui veut dire que la fin de la ligne est recherchée automatiquement. Si vous paramétrez l'option "limit" avec une valeur quelconque, alors le fichier CSV sera lu plus rapidement, mais toute ligne dont la longueur excédera la limite sera tronquée.

"L'échappement" par défaut d'un fichier CSV est le """. Vous pouvez en paramétrer un autre avec l'option "enclosure".

Exemple #5 Exemple avec un fichier CSV (2)

#Exemple de fichier csv
# original 'message,1'
"message,1",Nachricht1
# traduction 'Nachricht,2'
message2,"Nachricht,2"
# original 'message3,'
"message3,",Nachricht3
$translate = new Zend_Translate('csv',
                                'chemin/vers/matraduction.csv',
                                'de',
                                array('delimiter' => ','));
$translate->addTranslation('chemin/vers/autretraduction.csv',
                           'fr');

Créer des fichiers sources INI

Les fichiers sources INI sont lisibles par l'homme mais habituellement pas très petits puisqu'ils incluent également d'autres données à côté des traductions. Si vous avez des données qui seront éditables par vos clients, vous pouvez aussi utiliser l'adaptateur INI dans ce cas.

Exemple #6 Exemple avec un fichier INI

[Test]
;Commentaires possibles
Message_1="Nachricht 1 (de)"
Message_2="Nachricht 2 (de)"
Message_3="Nachricht :3 (de)"
$translate = new Zend_Translate('ini',
                                'path/to/mytranslation.ini',
                                'de');
$translate->addTranslation('path/to/other.ini',
                           'it');

Les fichiers INI ont de multiples restrictions. Si une valeur dans le fichier INI contient un caractère non-alphanumérique, il doit être entouré avec des guillemets doubles ("). Il y a aussi des mots réservés qui ne doivent pas être utilisés en tant que clés des fichiers INI. Ceci inclut : NULL, yes, no, TRUE et FALSE. Les valeurs NULL, no et FALSE sont retournées sous la forme "". yes et TRUE sont retournés en "1". Les caractères {}|&~![()" ne doivent pas être utilisés dans la clé et ont une signification particulière dans la valeur. Ne les utilisez pas ou vous rencontrerez des comportements inattendus.

Options pour les adaptateurs

Les options peuvent être utilisées avec tous les adaptateurs. Bien sûr chacun d'eux accepte des options différentes. Vous pouvez passer des options quand vous créez l'adaptateur. Pour l'instant il y a qu'une option qui est valable pour tous les adaptateurs. 'clear' décide si des données de traduction peuvent être ajoutées à l'existant ou non. Le comportement standard est d'ajouter des nouvelles données de traduction à l'existant. Les données de traduction sont seulement effacées pour la langue choisie. Donc on ne touchera pas aux autres langues.

Vous pouvez régler des options temporaires en utilisant addTranslation($data, $locale, array $options = array()) comme troisième paramètre optionnel. Ou vous pouvez utiliser la fonction setOptions() pour régler une option.

Exemple #7 Utiliser les options de traduction

// définir ':' comme séparateur pour les fichiers sources de traduction
$options = array('delimiter' => ':');
$translate = new Zend_Translate('csv',
                                'chemin/vers/matraduction.csv',
                                'fr',
                                $options);

...

// efface le langage défini et utilise de nouvelles données de traduction
$options = array('clear' => true);
$translate->addTranslation('chemin/vers/nouveau.csv',
                           'en',
                           $options);

Ici vous pouvez trouver toutes les options disponibles pour les différents adaptateurs avec une description de leur utilisation :

Options des adaptateurs de traduction
Adaptateur Option Valeur standard Description
Tous clear FALSE Si réglé à TRUE, les traductions déjà lues seront effacées. Ceci peut être utilisé au lieu de créer une nouvelle instance quand on lit de nouvelles données de traduction.
Tous disableNotices FALSE Si réglé à TRUE, toutes les notices concernant la non-disponibilité des traductions seront désactivées. Vous devriez mettre cette option à TRUE dans votre environnement de production.
Tous ignore . Tous les dossiers et les fichiers commençant par ce caractère seront ignorés dans la recherche automatique de traductions. La valeur par défaut est '.', ce qui signifie que tous les fichiers cachés (Unix) seront ignorés. Mettre une valeur par exemple à 'tmp' aura pour effet d'ignorer les dossiers ou fichiers 'tmpImages' ou encore 'tmpFiles' (par exemple), ainsi que tous les sous-dossiers
all log null An instance of Zend_Log where untranslated messages and notices will be written to
logMessage all The message which will be written into the log Untranslated message within '%locale%': %message%
all logUntranslated false When this option is set to true, all message id's which can not be translated will be written into a also attached log
Tous scan NULL Si réglé à NULL, aucun scan de la structure de répertoire ne sera effectué. Si réglé à Zend_Translate::LOCALE_DIRECTORY, la localisation sera détectée dans le répertoire. Si réglé à Zend_Translate::LOCALE_FILENAME, la localisation sera détectée dans le nom de fichier. Voir Détéction automatique de la source pour de plus amples détails.
Csv delimiter ; Définit quel signe est utilisé pour la séparation de la source et de la traduction.
Csv length 0 Définit la longueur maximum d'une ligne de fichier. Réglé à 0, la recherche sera automatique.
Csv enclosure " Définit le caractère d'échappement.

Si vous souhaitez avoir vos propres définitions d'options, vous pouvez les utiliser avec tous les adaptateurs. La méthode setOptions() peut être utilisée pour définir vos options. La méthode setOptions() nécessite un tableau avec les options que vous voulez paramétrer. Si une option fournie existe déjà, elle sera alors ré-assignée. Vous pouvez définir autant d'options que nécessaire car elles ne seront pas vérifiées par l'adaptateur. Vérifiez simplement que vous ne créez pas une option qui existe déjà dans l'adaptateur, vous affecteriez alors une nouvelle valeur.

Pour récupérer l'ensemble des options, vous pouvez utiliser la méthode getOptions(). Quand getOptions() est appelée sans paramètre, elle retourne l'ensemble des options. Si un paramètre est fourni, seule l'option particulière sera retournée.

Gérer les langues

En travaillant avec différentes langues il y a quelques méthodes qui seront utiles.

La méthode getLocale() peut être utilisée pour récupérer la langue actuellement réglée. Elle peut retourner soit une instance de Zend_Locale, soit un identifiant de localisation.

La méthode setLocale() règle une nouvelle langue standard pour la traduction. Ceci évite de placer le paramètre facultatif de langue plus d'une fois lors de l'appel de la méthode translate(). Si la langue donnée n'existe pas, ou si aucune donnée de traduction n'est disponible pour la langue, setLocale() essaye de remonter à la langue sans région si elle est indiquée. Une langue fr_FR serait remontée à fr. Si la remontée n'est pas possible, une exception sera levée.

La méthode isAvailable() vérifie si une langue donnée est déjà disponible. Elle retourne TRUE si des données existent pour la langue fournie.

Et enfin la méthode getList() peut être utilisée pour récupérer sous la forme d'un tableau tous les langues paramétrées pour un adaptateur.

Exemple #8 Gestion des langues avec des adaptateurs

...
// retourne la langue paramétrée actuelle
$actual = $translate->getLocale();

...
// vous pouvez utiliser le paramètre optionel au moment de la traduction
echo $translate->_("mon_texte", "fr");
// ou paramètrer une langue standard
$translate->setLocale("fr");
echo $translate->_("mon_texte");
// référence à la langue de base... fr_CH sera remonté à fr
$translate->setLocale("fr_CH");
echo $translate->_("mon_texte");
...
// vérifie si la langue existe
if ($translate->isAvailable("fr")) {
    // la langue existe
}

Gestion automatique des langues

Notez que tant que vous ajouterez les nouvelles sources de traduction seulement via la méthode addTranslation(), Zend_Translate cherchera automatiquement la langue correspondant au mieux à votre environnement quand vous utiliserez une des localisations automatiques "auto" ou "browser". Donc normalement vous ne devriez pas appeler setLocale(). Ceci ne doit être utilisé qu'en conjonction avec la détection automatique des sources de traduction.

L'algorithme recherchera la meilleure locale suivant le navigateur des utilisateurs et votre environnement. Voyez l'exemple suivant pour les détails :

Exemple #9 Comment la détection automatique de la langue fonctionne-t-elle ?

// Assumons que le navigateur retourne ces valeurs
// HTTP_ACCEPT_LANGUAGE = "de_AT=1;fr=1;en_US=0.8";

// Exemple 1 :
$translate = new Zend_Translate('gettext',
                                '\my_it.mo',
                                'auto',
                                array('scan' => Zend_Translate::LOCALE_FILENAME);
// pas de langue trouvée, on retourne le messageid

// Exemple 2 :
$translate = new Zend_Translate('gettext',
                                '\my_fr.mo',
                                'auto',
                                array('scan' => Zend_Translate::LOCALE_FILENAME);
// langue correspondante trouvée "en_US"

// Exemple 3 :
$translate = new Zend_Translate('gettext',
                                '\my_de.mo',
                                'auto',
                                array('scan' => Zend_Translate::LOCALE_FILENAME);
// langue correspondante trouvée "de" car "de_AT" est descendue à "de"

// Exemple 4 :
$translate = new Zend_Translate('gettext',
                                '\my_it.mo',
                                'auto',
                                array('scan' => Zend_Translate::LOCALE_FILENAME);
$translate->addTranslation('\my_ru.mo', 'ru');
$translate->setLocale('it_IT');
// retourne "it_IT" comme source de traduction et surcharge le réglage automatique

Si vous utilisez setLocale(), la detection automatique de la langue sera alors annulée, et la langue à utiliser sera celle spécifiée par l'appel de la méthode.

Si vous voulez réactiver la détection automatique, réappelez setLocale() et passez lui la valeur auto.

Depuis Zend Framework 1.7.0 Zend_Translate reconnait une locale globale pour l'application. Vous pouvez ainsi simplement mettre un objet Zend_Locale dans le registre, comme montré ci-après. Avec cette fonctionnalité, vous pouvez oublier le passage de la locale à votre objet de traduction.

// En fichier d'amorçage (bootstrap)
$locale = new Zend_Locale('de_AT');
Zend_Registry::set('Zend_Locale', $locale);

// ailleurs dans votre application
$translate = new Zend_Translate('gettext', '\my_de.mo');
$translate->getLocale();

Détéction automatique de la source

Zend_Translate peut détecter les sources de traduction de manière automatique. Ainsi vous n'avez pas à déclarer toutes les sources manuellement. Vous laissez Zend_Translate faire ce travail et scanner complètement tout un répertoire à la recherche de fichiers de langue de traduction.

Note:

La détection automatique des sources de traduction est disponible depuis Zend Framework version 1.5.

L'utilisation est assez semblable à celle qui permet de spécifier une source de langue. Vous devez simplement donner un dossier, et non plus un fichier, à l'adaptateur. Ce dossier sera alors scanné

Exemple #10 Scanner un dossier à la recherche de sources de traduction

// Soit la structure suivante :
//  /language
//  /language/login/login.tmx
//  /language/logout/logout.tmx
//  /language/error/loginerror.tmx
//  /language/error/logouterror.tmx

$translate = new Zend_Translate('tmx', '/language');

Notez que Zend_Translate cherche dans tous les sous-repertoires. L'utilisation devient alors relativement simple. Aussi, Zend_Translate ignorera tout fichier qui ne l'interresse pas : des fichiers non représentatifs de traductions ou encore des fichiers illisibles. Vérifiez donc que le dossier principal ne contienne que des fichiers de traductions, car Zend_Translate ne renverra aucune erreur dans le cas contraire, il ignorera simplement de tels fichiers.

Note:

Selon la compléxité de la récursivité, la traversée du répertoire principal peut devenir longue et couteuse.

Dans notre exemple, nous utilisons l'adaptateur TMX qui inclut la langue à utiliser dans le fichier en question. D'autres adaptateurs n'agissent pas comme cela, ainsi les noms de fichiers devront comporter les noms des langues à considérer pour de tels adaptateurs.

La langue se trouve dans le nom des dossiers

One way to include automatic language detection is to name the directories related to the language which is used for the sources within this directory. This is the easiest way and is used for example within standard gettext implementations.

Zend_Translate needs the 'scan' option to know that it should search the names of all directories for languages. See the following example for details:

Exemple #11 Directory scanning for languages

// expect we have the following structure
//  /language
//  /language/de/login/login.mo
//  /language/de/error/loginerror.mo
//  /language/en/login/login.mo
//  /language/en/error/loginerror.mo

$translate = new Zend_Translate('gettext',
                                '/language',
                                null,
                                array('scan' =>
                                    Zend_Translate::LOCALE_DIRECTORY));

Note:

This works only for adapters which do not include the language within the source file. Using this option for example with TMX will be ignored. Also language definitions within the filename will be ignored when using this option.

Note:

You should be aware if you have several subdirectories under the same structure. Expect we have a structure like /language/module/de/en/file.mo. The path contains in this case multiple strings which would be detected as locale. It could be eigther de or en. As the behaviour is, in this case, not declared it is recommended that you use file detection in such situations.

Language through filenames

Another way to detect the langage automatically is to use special filenames. You can either name the complete file or parts of a file with the used language. To use this way of detection you will have to set the 'scan' option at initiation. There are several ways of naming the sourcefiles which are described below:

Exemple #12 Filename scanning for languages

// expect we have the following structure
//  /language
//  /language/login/login_en.mo
//  /language/login/login_de.mo
//  /language/error/loginerror_en.mo
//  /language/error/loginerror_de.mo

$translate = new Zend_Translate('gettext',
                                '/language',
                                null,
                                array('scan' =>
                                    Zend_Translate::LOCALE_FILENAME));

Complete Filename

Having the whole file named after the language is the simplest way but only usable if you have only one file per directory.

/languages
  en.mo
  de.mo
  es.mo

Extension of the file

Another very simple way if to use the extension of the file for the language detection. But this may be confusing because you will no longer know which file extension the file originally was.

/languages
  view.en
  view.de
  view.es

Filename tokens

Zend_Translate is also captable of detecting the language if it is included within the filename. But if you use this way you will have to seperate the language with a token. There are three supported tokens which can be used: A point '.', a underline '_', or a hyphen '-'.

/languages
  view_en.mo  -> detects english
  view_de.mo  -> detects german
  view_it.mo  -> detects italian

The first found token which can be detected as locale will be used. See the following example for details.

/languages
  view_en_de.mo  -> detects english
  view_en_es.mo  -> detects english and overwrites the first file
                    because the same messageids are used
  view_it_it.mo  -> detects italian

All three tokens are used to detect the locale. The first one is the point '.', the second is the underline '_' and the third the hyphen '-'. If you have several tokens within the filename the first found depending on the order of the tokens will be used. See the following example for details.

/languages
  view_en-it.mo  -> detects english because '_' will be used before '-'
  view-en_it.mo  -> detects italian because '_' will be used before '-'
  view_en.it.mo  -> detects italian because '.' will be used before '_'

Vérifier les traductions

Normalement le texte sera traduit sans aucun calcul. Mais il est quelquefois nécessaire si un texte est traduit ou non dans la source. Dans ce cas la méthode isTranslated() peut être utilisé.

isTranslated($messageId, $original = false, $locale = null) prend comme premier paramètre le texte dont vous voulez vérifier que la traduction est possible. Et comme troisième paramètre optionnel la langue dont vous voulez connaître la traduction. Le second paramètre optionnel détermine si la traduction est fixée à la langue déclarée ou si une autre langue peut être utilisée. Si vous avez un texte qui peut être traduit en "fr" mais pas en "fr_fr" vous obtiendriez normalement la traduction fournie, mais avec $original réglé à TRUE, la méthode isTranslated() retournera FALSE dans ce cas.

Exemple #13 Vérifier si une texte est traduisible

$english = array('message1' => 'Nachricht 1',
                 'message2' => 'Nachricht 2',
                 'message3' => 'Nachricht 3');
$translate = new Zend_Translate('array', $english, 'de_AT');

if ($translate->isTranslated('message1')) {
    print "'message1' peut être traduit";
}
if (!($translate->isTranslated('message1', true, 'de'))) {
    print "'message1' ne peut pas être traduit en 'de', "
        . "il est seulement disponible en 'de_AT'";
}
if ($translate->isTranslated('message1', false, 'de')) {
    print "'message1' peut être traduit en 'de_AT' "
        . "et par conséquent en 'de'";}

How to log not found translations

When you have a bigger site or you are creating the translation files manually, you often have the problem that some messages are not translated. But there is a easy solution for you when you are using Zend_Translate.

You have to follow two or three simple steps. First, you have to create a instance of Zend_Log. And then you have to attach this instance to Zend_Translate. See the following example:

Exemple #14 Log translations

$translate = new Zend_Translate('gettext', $path, 'de');

// Create a log instance
$writer = new Zend_Log_Writer_Stream('/path/file.log');
$log = new Zend_Log($writer);

// Attach it to the translation instance
$translate->setOptions(array(
    'log' => $log,
    'logUntranslated' => true));

$translate->translate('unknown string');

Now you will have in the log a new notice: Untranslated message within 'de': unknown string.

Note:

You should note that any translation which can not be found will be logged. This means all translations when a user requests a not supported language. But also every request to a message which can not be translated will be logged. Be aware that when 100 people request the same translation you will have 100 notices logged.

This feature can not only be used to log messages but also to attach this not translated messages into a empty translation file. To archive this you will have to write your own log writer which writes the format you want to have and strips the prepending "Untranslated message" for you.

You can also set the 'logMessage' option when you want to have your own log message. Use the '%message%' token for placing the messageId within your log message, and the '%locale%' token for the requested locale. See the following example for a self defined log message:

Exemple #15 Self defined log messages

$translate = new Zend_Translate('gettext', $path, 'de');

// Create a log instance
$writer = new Zend_Log_Writer_Stream('/path/to/file.log');
$log    = new Zend_Log($writer);

// Attach it to the translation instance
$translate->setOptions(array(
    'log'             => $log,
    'logMessage'      => "Missing '%message%' within locale '%locale%'",
    'logUntranslated' => true));

$translate->translate('unknown string');

Access to the source data

Of course sometimes it is useful to have access to the translation source data. Therefor two functions exist.

The getMessageIds($locale = null) method returns all known message ids as array.

And the getMessages($locale = null) method returns the complete translation source as array. The message id is used as key and the translation data as value.

Both methods accept an optional parameter $locale which, when set, returns the translation data for the specified language. If this parameter is not given, the actual set language will be used. Keep in mind that normally all translations should be available in all languages. Which means that in a normal situation you will not have to set this parameter.

Additionally the getMessages() method is able to return the complete translation dictionary with the pseudo-locale 'all'. This will return all available translation data for each added locale.

Note:

Attention: The returned array can be very big, depending on the count of added locales and the amount of translation data.

Exemple #16 Handling languages with adapters

...
// returns all known message ids
$messageids = $translate->getMessageIds();
print_r($messageids);

...
// or just for the specified language
$messageids = $translate->getMessageIds('en_US');
print_r($messageids);

...
// returns all the complete translation data
$source = $translate->getMessages();
print_r($source);
Previous Next
Introduction au Zend Framework
Présentation
Installation
Apprendre Zend Framework
Démarrez rapidement avec Zend Framework
Zend Framework & MVC Introduction
Create Your Project
Create A Layout
Create a Model and Database Table
Create A Form
Congratulations!
Chargement automatique avec Zend Framework
Introduction
Architecture et buts
Utilisation de base de l'autoloader
Auto-chargement de resources
Conclusion
Les plugins dans Zend Framework
Introduction
Utiliser des Plugins
Conclusion
Bien démarrer avec Zend_Layout
Introduction
Utiliser Zend_Layout
Zend_Layout: Conclusions
Bien démarrer avec Zend_View
Introduction
Basic Placeholder Usage
Standard Placeholders
View Placeholders: Conclusion
Bien comprendre et utiliser les décorateurs Zend Form
Introduction
Les bases des décorateurs
Chainer les décorateurs
Rendu individuel des décorateurs
Créer et rendre des éléments composites
Conclusion
Bien démarrer avec Zend_Session, Zend_Auth, et Zend_Acl
Fabrique une application Multi-Utilisateurs avec Zend Framework
Gérer les sessions dans ZF
Authentification d'utilisateurs dans Zend Framework
Fabriquer un système de gestion d'autorisations avec Zend Framework
Bien démarrer avec Zend_Search_Lucene
Introduction à Zend_Search_Lucene
Structure d'index Lucene
Ouverture et création d'index
Indexation
Recherche
Requêtes supportées
Pagination de résultat de recherche
Bien démarrer avec Zend_Paginator
Introduction
Exemples simples
Contrôles de la pagination et styles de défilement
Assembler le tout
Guide de référence Zend Framework
Zend_Acl
Introduction
Affiner les Contrôles d'Accès
Utilisation avancée
Zend_Amf
Introduction
Zend_Amf_Server
Zend_Application
Introduction
Zend_Application démarrage rapide
Théorie générale
Exemples
Fonctionnalités principales
Plugins de ressources disponibles
Zend_Auth
Introduction
Authentification avec une table de base de données
Authentification "Digest"
Adaptateur d'authentification HTTP
LDAP Authentication
Authentification OpenID
Zend_Barcode
Introduction
Création de code-barres avec la classe Zend_Barcode
Zend_Barcode Objects
Zend_Barcode Renderers
Zend_Cache
Introduction
Aspect théorique
Les frontends Zend_Cache
Les backends Zend_Cache
Le gestionnaire de Cache
Zend_Captcha
Introduction
Opération Captcha
Adaptateurs CAPTCHA
Zend_CodeGenerator
Introduction
Exemples Zend_CodeGenerator
Zend_CodeGenerator Réference
Zend_Config
Introduction
Aspect théorique
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Introduction
Déclarer les règles Getopt
Extraire les options et les arguments
Configurer Zend_Console_Getopt
Zend_Controller
Zend_Controller - Démarrage rapide
Fondations de Zend_Controller
Le contrôleur frontal (Front Controller)
L'objet Requête
Routeur Standard
Le distributeur
Contrôleurs d'action
Aides d'action (Helper)
Objet de réponse
Plugins
Utilisation de conventions de dossiers modulaires
Exceptions avec MVC
Zend_Currency
Introduction à Zend_Currency
Utiliser Zend_Currency
Options des monnaies
Qu'est ce qui définit une monnaie?
Où est le symbole monnétaire?
A quoi ressemble une monnaie?
Travailler avec les valeurs des monnaies (les montants)
Calculs avec les monnaies
Echanger (convertir) des monnaies
Informations complémentaires pour Zend_Currency
Zend_Date
Introduction
Aspect théorique
Méthodes de base
Zend_Date API Overview
Créer des dates
Constants for General Date Functions
Exemples concrets
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Relations Zend_Db_Table
Zend_Db_Table_Definition
Zend_Debug
Afficher des informations
Zend_Dojo
Introduction
Zend_Dojo_Data: dojo.data Envelopes
Les aides de vues Dojo
Les éléments de formulaire et les décorateurs Dojo
Zend_Dojo build layer support
Zend_Dom
Introduction
Zend_Dom_Query
Zend_Exception
Utiliser les exceptions
Utilisation classique
Exceptions précédentes
Zend_Feed
Introduction
Importer des flux
Obtenir des flux à partir de pages Web
Consommer un flux RSS
Consommer un flux Atom
Consommer une entrée Atom particulière
Modifier la structure du flux ou des entrées
Classes personnalisées pour les flux et entrées
Zend_Feed_Reader
Zend_Feed_Writer
Zend_Feed_Pubsubhubbub
Zend_File
Zend_File_Transfer
Validateurs pour Zend_File_Transfer
Filtres pour Zend_File_Transfer
Zend_Filter
Introduction
Classes de filtre standards
Chaînes de filtrage
Écriture de filtres
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Zend_Form démarrage rapide
Creating Form Elements Using Zend_Form_Element
Creating Forms Using Zend_Form
Créer un visuel personnalisé en utilisant Zend_Form_Decorator
Standard Form Elements Shipped With Zend Framework
Décorateurs standards fournis avec Zend Framework
Internationaliser un formulaire Zend_Form
Advanced Zend_Form Usage
Zend_Gdata
Introduction
Authentification par procédé AuthSub
Using the Book Search Data API
Authentification avec ClientLogin
Using Google Calendar
Using Google Documents List Data API
Using Google Health
Using Google Spreadsheets
Using Google Apps Provisioning
Using Google Base
Utilisation des albums Web Picasa
Using the YouTube Data API
Attraper les exceptions Gdata
Zend_Http
Introduction
Zend_Http_Client - Utilisation avancée
Zend_Http_Client - Adaptateurs de connexion
Zend_Http_Cookie and Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Introduction
Zend_Json
Introduction
Utilisation de base
Utilisation avancée de Zend_Json
XML to JSON conversion
Zend_Json_Server - JSON-RPC server
Zend_Layout
Introduction
Zend_Layout - Démarrage rapide
Zend_Layout options de configuration
Zend_Layout, utilisation avancée
Zend_Ldap
Introduction
API overview
Scénarios d'utilisation
Outils
Accès à l'arbre LDAP de manière orientée objet avec Zend_Ldap_Node
Récupérer des informations depuis un serveur LDAP
Serialiser des données LDAP depuis/vers LDIF
Zend_Loader
Charger les fichiers et les classes dynamiquement
L'autoloader
Autoloaders de ressources
Chargeur de Plugins
Zend_Locale
Introduction
Using Zend_Locale
Normalization and Localization
Working with Dates and Times
Supported locales
Zend_Log
Présentation
Rédacteurs (Writers)
Formateurs (mise en forme)
Filtres
Utiliser la fabrique pour créer des logs
Zend_Mail
Introduction
Envoyer des émail en utilisant SMTP
Envoyer plusieurs émail par connexion SMTP
Utiliser différents transports
Émail HTML
Fichiers joints
Ajouter des destinataires
Contrôler les limites MIME
En-têtes additionnels
Jeux de caractères
Encodage
Authentification SMTP
Sécuriser les transports SMTP
Lire des émail
Zend_Markup
Introduction
Guide de démarrage avec Zend_Markup
Analyseurs Zend_Markup (parsers)
Moteurs de rendu Zend_Markup
Zend_Measure
Introduction
Création d'une mesure
Récupérer des mesures
Manipuler des mesures
Types de mesures
Zend_Memory
Présentation
Manager de mémoire
Objet mémoire
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_Navigation
Introduction
Pages
Containers
Zend_Oauth
Introduction to OAuth
Zend_OpenId
Introduction
Zend_OpenId_Consumer Basics
Zend_OpenId_Provider
Zend_Paginator
Introduction
Utilisation
Configuration
Utilisation avancée
Zend_Pdf
Introduction
Créer et charger des documents PDF
Sauvegarder les changement dans un document PDF
Les pages d'un document
Dessiner
Interactive Features
Informations du document et métadonnées
Exemple d'utilisation du module Zend_Pdf
Zend_ProgressBar
Zend_ProgressBar
Zend_Queue
Introduction
Example usage
Framework
Adapters
Customizing Zend_Queue
Stomp
Zend_Reflection
Introduction
Zend_Reflection Exemples
Réference de Zend_Reflection
Zend_Registry
Utiliser le registre
Zend_Rest
Introduction
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Vue d'ensemble
Créer des index
Chercher dans un index
Langage de requêtes
API de construction de requêtes
Jeu de caractères
Extensibilité
Agir avec Lucene Java
Avancé
Bonnes pratiques
Zend_Serializer
Introduction
Zend_Serializer_Adapter
Zend_Server
Introduction
Zend_Server_Reflection
Zend_Service
Introduction
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Amazon_Ec2
Zend_Service_Amazon_Ec2: Instances
Zend_Service_Amazon_Ec2: Windows Instances
Zend_Service_Amazon_Ec2: Reserved Instances
Zend_Service_Amazon_Ec2: CloudWatch Monitoring
Zend_Service_Amazon_Ec2: Amazon Machine Images (AMI)
Zend_Service_Amazon_Ec2: Elastic Block Storage (EBS)
Zend_Service_Amazon_Ec2: Elastic IP Addresses
Zend_Service_Amazon_Ec2: Keypairs
Zend_Service_Amazon_Ec2: Regions and Availability Zones
Zend_Service_Amazon_Ec2: Security Groups
Zend_Service_Amazon_S3
Zend_Service_Amazon_Sqs
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_DeveloperGarden
Zend_Service_Flickr
Zend_Service_LiveDocx
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Zend_Service_SlideShare
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Bundled Services
Zend_Service_StrikeIron: Advanced Uses
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_WindowsAzure
Zend_Service_Yahoo
Zend_Session
Introduction
Usage basique
Utilisation avancée
Gestion générale de la session
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL
Auto découverte
Zend_Tag
Introduction
Zend_Tag_Cloud
Zend_Test
Introduction
Zend_Test_PHPUnit
Zend_Test_PHPUnit_Db
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Introduction
Utiliser Zend_TimeSync
Zend_Tool
Using Zend_Tool On The Command Line
Extending Zend_Tool
Zend_Tool_Framework
Introduction
Using the CLI Tool
Architecture
Creating Providers to use with Zend_Tool_Framework
Shipped System Providers
Extending and Configuring Zend_Tool_Framework
Zend_Tool_Project
Introduction
Créer un projet
Fournisseurs de Zend_Tool_Project
Rouages internes de Zend_Tool_Project
Zend_Translate
Introduction
Adaptateurs pour Zend_Translate
Utiliser les adaptateurs de traduction
Creating source files
Additional features for translation
Notation des pluriels pour Translation
Zend_Uri
Zend_Uri
Zend_Validate
Introduction
Classes de validation standard
Chaînes de validation
Écrire des validateurs
Messages de validation
Zend_Version
Lire la version de Zend Framework
Zend_View
Introduction
Scripts de contrôleur
Scripts de vue
Aides de vue
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Introduction
Zend_XmlRpc_Client
Zend_XmlRpc_Server
ZendX_Console_Process_Unix
ZendX_Console_Process_Unix
ZendX_JQuery
Introduction
ZendX_JQuery View Helpers
ZendX_JQuery Form Elements and Decorators
Configuration système requise par Zend Framework
Introduction
Notes de migration de Zend Framework
Zend Framework 1.10
Zend Framework 1.9
Zend Framework 1.8
Zend Framework 1.7
Zend Framework 1.6
Zend Framework 1.5
Zend Framework 1.0
Zend Framework 0.9
Zend Framework 0.8
Zend Framework 0.6
Convention de codage PHP de Zend Framework
Vue d'ensemble
Formatage des fichiers PHP
Conventions de nommage
Style de codage
Zend Framework Documentation Standard
Overview
Documentation File Formatting
Recommendations
Recommended Project Structure for Zend Framework MVC Applications
Overview
Recommended Project Directory Structure
Module Structure
Rewrite Configuration Guide
Guide de performance Zend Framework
Introduction
Chargement des classes
Performance de Zend_Db
Internationalisation (i18n) and Localisation (l10n)
View Rendering
Informations de copyright