Pour suivre, il est indispensable d’utiliser eclipse, car celui-ci possède un mode graphique pour la création de web-service qui va nous faciliter la vie.

Le fonctionnement

Vous savez certainement qu’un Web-Service est un programme qui permet la communication et l’échange de données entre des applications et des systèmes totalement différents.

Pour que le Web-Service puisse communiquer avec n’importe quels systèmes, il faut utiliser un même format de données. Pour nous, ça sera le SOAP(c’est un protocole procédural basé sur du XML). Dans ce format, il faut aussi bien définir les données qui seront reçues et envoyées par le Web-Service.

Ne vous inquiétez pas si cela vous paraît trop abstrait, on va tout expliquer avec un exemple.

Voici une petite illustration du fonctionnement de ce Web-Service :


Première étape :
L’application java va faire appel au web-service en envoyant un message WSDL (en SOAP).

Qui avait dit que c’était compliqué les web-service ?


Fini la théorie passons à la pratique, nous allons faire un Web-Service qui nous donne le jour en fonction de la date que l’on envoie.

Création du wsdl

Nous allons créer un nouveau projet que nous appellerons MonWebService (il n’y a pas plus clair ^^).


On va commencer par faire le format WSDL (fichier soap) de notre web service.

On le nomme monFormat.wsdl

Pour nous aider, Eclipse nous construit automatiquement un format wsdl par défaut, nous allons le reprendre et le paramétrer. Mais avant tout, je vais vous parler rapidement de l’interface.

C’est avec la boîte à gauche que l’on définit l’adresse du serveur du web-service ( c’est là où tout le traitement php va se faire), Dans le champ de saisie, il faudra mettre : http://localhost/MonWebService/serveur.php

Input qui représente les données que va recevoir le Web-Service
Output qui représente les données que va envoyer le Web-Service


Tout le monde suit ?

En entrée, on aura besoin d’une chaine de caractère(string).
Pour se faire, on fait un clique droit sur case la plus à droite de la ligne input, dans le menu contextuel
On clique sur Set Type puis Existing Type et là on sélectionne string.


On réitère cette opération pour le paramètre de sortie.

Du serveur au client

On va s’attaquer à notre serveur, préparez vos doigts ça va coder !

On va le nommer serveur.php
Attention, le chemin de votre fichier doit être le même que celui que vous avez paramétré dans votre web-service.

Ex : http://localhost/MonWebService/serveur.php => C:\wam\www\MonWebService\serveur.php

Voici le code source, les commentaires parlent d’eux-même :

// Pour supprimer le cache du web-service
ini_set('soap.wsdl_cache_enabled', 0);
// Pour définir le temp maximal d'éxecution de notre web-service
ini_set('default_socket_timeout', 180);

// Nom de notre web-service
class Server {
     // Le service QuelJour que l'on a définit dans notre format wsdl
    function QuelJour($parm) {
    	return 'Web-Service ok';
    }
}
// On tente d'instancier la classe soapServer
// Si cela s'avère impossible, on affiche une erreur
try {
    $server = new SoapServer('monFormat.wsdl',  array('trace' => 1,'encoding'	=> 'ISO-8859-1'));
    // On définit la classe qui va gérer les requêtes SOAP (pour nous c'est la class Server)
    $server -> setclass('Server');
    $server->setPersistence(SOAP_PERSISTENCE_REQUEST);
} catch (Exception $e) {
    echo 'erreur'.$e;
}
// Si l'appel provient d'un Web-Service
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
	try {
		$server -> handle();}
	catch (Exception $e) {
    echo 'erreur'.$e;
	}
}
// Facultatif seulement pour montrer les fonctions disponibles par le web-service
else {
    echo '<strong>This SOAP server can handle following functions : </strong>';
    echo '<ul>';
    foreach($server -> getFunctions() as $func) {
        echo '<li>' , $func , '</li>';
    }
    echo '</ul>';
}

Si tout se passe bien et si on se rend sur cette adresse :

http://localhostMonWebService/serveur.php

On devrait voir :



Tout marche ? On est trop fort \o/

// Pour supprimer le cache du web-service
ini_set('soap.wsdl_cache_enabled', 0);

// Nouveau Client SOAP
try {
    // Nouvelle instance de la classe soapClient
   $client = new SoapClient('http://localhost/MonWebService/monFormat.wsdl', array('trace' => 1));
   $parm = date('Y-m-d');
    // Appel de la méthode QuelJour du service web
   try{
    $oReturn =  $client -> __soapCall('QuelJour', array('string' =>$parm));
	} catch (SoapFault $fault) {
    	trigger_error("SOAP Fault: (faultcode: {$fault->faultcode}, faultstring: {$fault->faultstring})", E_USER_ERROR);
	}
        // affiche le résultat
	var_dump($oReturn);
} catch (SoapFault $fault) {
    echo 'erreur : '.$fault;
}

    function QuelJour($parm) {
    	$aJour[1] = 'Lundi';
    	$aJour[2] = 'Mardi';
    	$aJour[3] = 'Mercredi';
    	$aJour[4] = 'Jeudi';
    	$aJour[5] = 'Vendredi';
    	$aJour[6] = 'Samedi';
    	$aJour[0] = 'Dimanche';
    	return $aJour[date("w",strtotime($parm))];
    }

Debugger un web-service

Le debugage d’un web-service est toujours difficile. Le client interprète directement la réponse du web-service et si la réponse n’est pas correctement formaté (qui ne respecte pas le format wsdl du web-service), il affiche une erreur du type :

( ! ) Fatal error: SOAP Fault: (faultcode: Client, faultstring: looks like we got no XML document) in /var/www/MonWebService/client.php on line 17 Call Stack #TimeMemoryFunctionLocation 10.000158584{main}( )../client.php:0 20.002180708trigger_error ( )../client.php:17

Les erreurs :


Pendant le développement de différents de web-services, je suis tombé sur des erreurs de toute part, malheureusement je ne les ai pas tous mémorisé mais voici un début de liste qui pourrait vous aider. Si vous aussi vous êtes embétez un petit commentaire et on pourra certainement vous aider.

Installation

Pour l’installation, nous allons commencer à ouvrir une invite de commande dos.
Et commencer par faire :

set PATH=%PATH%;C:\wamp\php

Normalement dans votre dossier php, vous avez un dossier PEAR, il faut s’y rendre.

Par exemple, pour wamp il faut taper : cd C:\wamp\php\PEAR

Vous trouverez un fichier php go-pear.phar, il suffit de l’exécuter :

php go-pear.phar

Et là, l’installation se lance

installation pear

Si vous voulez que l’installation de pear concerne toutes les sessions d’utilisateurs, il faut mettre system.

Un récapitulatif des chemins de configuration de pear est affiché, vous pouvez laisser la configuration par défaut, elle est très bien.

installation pear

Dernière étape, on accepte de modifier notre fichier php.ini pour qu’il prenne en compte notre bibliothèque PEAR.

pear installation

Eh voilà c’est installé

pear installation

Première utilisation

Nous allons installer la librairie DATE

Dans un premier temps nous allons faire :

set PATH=%PATH%;C:\wamp\php\PEAR

Il faut aller ensuite sur http://pear.php.net/packages.php.

Date and Time -> Date -> Download.

On va récupérer la commande pour le téléchargement :

utilisation pear

Pour moi, il faut taper :

pear install Date-1.5.0a1

PEAR Fatal error: Allowed memory size of 8388608 bytes exhausted

Il faut modifier votre fichier C:\wamp\php\php.ini, aller dans l’attribut memory_limit = 8M
et remplacer par : memory_limit = 256M

Comme ça, on est tranquille

// on fait appel a notre librairie PEAR
set_include_path(get_include_path() . ";C:\wamp\php\PEAR\pear");

require_once 'DATE.php';
$now = new Date();

//UNIX timestamp:
echo $now->getTime().'<br/>';

//format de date iso
echo $now->getDate();

Et voilà, vous savez utiliser PEAR

FirePHP qu’est ce que c’est ?

Tout d’abord FirePHP est un plugin firefox, qui s’attache à celui de firebug.
Les données de debug sont représentées de cette façon :

C’est à l’aide d’une classe php, que l’on va définir les données de debug à afficher.
Et c’est cette classe php, qui envoie ces données au format JSON.
Pour finir le plugin s’occupe d’afficher les données.

Passons maintenant à la pratique .

Installation

Si vous ne l’avez pas fait , il faut installer firebug,une fois ceci fait, vous pouvez installer le plugin firephp.

Maintenant nous allons récupérer la dernière version de la librairie .

Nous allons voir si firePHP fonctionne :

require_once './FirePHPCore/FirePHP.class.php';
$oFirebug = FirePHP::getInstance(true);
$oFirebug->fb('FirePhp fonctionne !');

Voilà ce que cela doit donner :

Si vous ne voyez rien, c’est que vous avez oublié d’activer la surveillance réseau de votre firebug:

Utilisation de firePhp

Avant toute chose, il faut bien avoir en tête que ces données sont visibles par tous les visiteurs qui possèdent firePHP. Il est préférable d’afficher les données dans un environnement de développement ou de test.

Normalement avec l’exemple de fonctionnement vous avez déjà du tout comprendre

$oFirebug = FirePHP::getInstance(true);
c’est notre objet firebug.
$f->fb(‘FirePhp fonctionne !’);
pour afficher un message.

Grouper les variables de debug

Vous pouvez regroupez vos variables de debug avec Firephp. Cela peut être utile si vos tests se font sur plusieurs fonctions.

$oFirebug->group('Fonction animal');
$oFirebug->log('Chien');
$oFirebug->log('Chat');
$oFirebug->log('Poisson');
$oFirebug->groupEnd();

$oFirebug->group('Fonction ville');
$oFirebug->log('Lens');
$oFirebug->log('Rennes');
$oFirebug->log('Caen');
$oFirebug->groupEnd();

Voilà ce que ça donne :

Définir des niveaux d’erreurs

Tout comme l’objet error_reporting de php, avec firePHP on peux définir un niveau d’erreur.

méthode info : ressemble au notice
méthode warn : ressemble au warning
méthode error : ressemble au fatal error

$oFirebug->log('Plain Message');     // or FB::
$oFirebug->info('Info Message');     // or FB::
$oFirebug->warn('Warn Message');     // or FB::
$oFirebug->error('Error Message');   // or FB::

Firebug va donc afficher :

Afficher les tableaux

C’est avec la méthode table() que l’on va pouvoir afficher les tableaux avec FirePHP

Voici un exemple de code :

$aTable   = array();
$aTable[] = array('Col 1 Heading','Col 2 Heading');
$aTable[] = array('Row 1 Col 1','Row 1 Col 2');
$aTable[] = array('Row 2 Col 1','Row 2 Col 2');
$aTable[] = array('Row 3 Col 1','Row 3 Col 2');

$oFirebug->table('Table Label', $aTable)

Cela donne :

Laissez des traces avec trace()

Affiche un bascktrace de la ligne ou est tapée la méthode trace().

Voici un exemple d’utilisation:

mess($oFirebug);
function mess($oFirebug)
{
 $oFirebug->trace('Trace Label');
}

Firephp va afficher :

Attraper les erreurs avec firePhp

On peut aussi gérer l’affichage des erreurs par firePhp

$oFirebug->registerErrorHandler();
$oFirebug->registerExceptionHandler();

try {
  throw new Exception('Test erreur');
} catch(Exception $e) {
  $oFirebug->error($e);
}

Et voila notre belle erreur

On a fait le tour de firePhp, vous pouvez maintenant debugger en toute transparence.

Mis en place de simpletest

Pour télécharger la librairie c’est ici. Vous pouvez allez aussi sur le site officiel pour télécharger la dernière version.

simpletest dernière version

Dans ce tutoriel nous allons créer une classe de toute pièce pour faire nos tests unitaires.

Nous allons créer un dossier operation où nous allons mettre notre dossier décompressé simpletest.

comment construire un test unitaire

Construire un test unitaire efficace, demande beaucoup d’abstraction. En effet le test unitaire à la responsabilité de prévoir de façon exhaustive toute les possibilités et les comportements d’un code source. On peu dire que le test unitaire doit s’assurer que le code source fonctionne en toute circonstance et qu’il répond aux spécifications fonctionnelles.

Roul, mais comment veux tu que je fasse test unitaire qui prévoie tout ?

Ne vous inquiétez pas, je suis loin d’être un as en développement , mais j’arrive à faire des test unitaires corrects. D’ailleurs vous allez voir que ce n’est vraiment pas compliqué, parce que allons justement en faire un (sur une classe très simple). Il faut juste suivre une bonne méthode de travail pas à pas et ne pas précipiter les choses ^^. Mettez vos combinaisons nous allons devoir tester une classe vraiment pas propre …

La classe opération

Nous allons commencer, par créer une classe toute simple. La classe opération, cette classe donnera juste la possibilité d’effectuer des opérations basiques (addition, soustraction, multiplication ….) sur des réels.

class operation
{
	public function __construct()
	{
		;
	}
	public function addition($fNb1,$fNb2) {
		return $fNb1 + $fNb2;
	}
}

Donc la première méthode de la classe opération, est de faire une addition.
Nous allons faire le test unitaire ce cette méthode.

On va faire appel à la librairie simpletest.

require_once('simpletest/unit_tester.php');
require_once('simpletest/reporter.php');
require_once('./operation.class.php');

Là on va créer notre classe de testUnitaire qui héritera de la classe UniTestCase.

class testUnitaireOperation extends UnitTestCase {
	function __construct() {
	      $this->UnitTestCase('Test unitaire sur la classe operation');
        }
}

Maintenant on va tester notre méthode addition.

Comment simpletest test une addition ?

En fait c’est très simple, on va faire appel à une série de méthode simpletest.
Chaque méthodes simpletest va faire appel aux fonctions que nous allons tester (pour nous, ça sera la méthode addition). Chaque méthodes simpletest vont bien entendu attendent un résultat.
Si les résultats ne correspondent pas à ce que l’on attend, simpletest va tout de suite afficher un message d’erreur et indiquer sa provenance.

On va commencer par cette méthode :

$this->assertIsA

Alors, dans cette méthode on va lui indiquer un type. Ensuite il va vérifier si l’objet passé en paramètre est bien du même type que celui-ci.
C’est pas très clair ? Bon on va voir un exemple :

$this->assertIsA($oKevin, ‘garçon’);

Le test unitaire vérifie si l’objet $oKevin est bien un objet du type garçon.

Revenons dans notre classe opération. Pour commencer nous allons vérifier si l’objet oMonOpération que l’on va créer est bien du type operation :

public function testAddition() {
	echo 'Debut des test sur les additions '."n";
	// Creation du objet operation
	$oMonOperation = new operation();
	$this->assertIsA($oMonOperation, 'operation');
}

Pour déclencher le test, juste après votre classe vous pouvez faire :

$oOperationTest = &new testUnitaireOperation();
$oOperationTest->run(new TextReporter());

Vous pouvez lancer votre test unitaire via interface Web
Normalement le test unitaire devrait bien se dérouler et vous devriez voir ça :

test unitaire

Comment lire le résultat :

Passes : Le nombre de test qui sont se bien déroulé.
Failures : Le nombre de test dont résultat ne corresponds pas à ce que l’on attends.
Exceptions : Le nombre de test qui ont généré une erreur.

Nous allons voir une autre méthode de simpletest. Cell-ci vérifie si la fonction testée, retourne bien vrai.
$this->assertTrue
la fonction qui vérifie si la fonction retourne faux c’est :
$this->assertFalse

Pour notre test unitaire nous allons utiliser la méthode assertTrue pour vérifier si la méthode addition peut être appeler (a travers l’objet opération).

notre test unitaire doit maintenant ressembler à ça :

public function testAddition() {
echo 'Debut des test sur les additions '."n";
        // Creation du objet operation
        $oMonOperation = new operation();
        $this->assertIsA($oMonOperation, 'operation');
        $aMethode = array($oMonOperation, 'addition');
         //Appel de la methode addition
        $this->assertTrue(is_callable($aMethode, true));
}

Maintenant, on doit avoir deux tests qui sont passés. C’est vrai pour l’instant ce test unitaire n’est pas très utile.
Mais ne vous inquiétez pas, nous allons vite arriver sur des cas que l’on avait pas forcément pensé.
Les test unitaires vont se faire un plaisir de nous rappeler à l’ordre.

$this->assertEqual

Pour cette méthode il faut deux paramètres. Le premier c’est la fonction que l’on veut tester,
et le second c’est ce que doit renvoyer la fonction.
Si on veut tester la commande addition, on va faire une addition du style 1 + 1 et notre méthode devra retourner … (ou est cette calculette ?) … 2 !

En langage php cela donne : $this->assertEqual($oMonOperation->addition(1,1), 2);

Pour notre classe opération on va faire toute une batterie de test pour vérifier que tout fonctionne bien.

public function testAddition() {
	echo 'Debut des test sur les additions '."n";
	// Creation du objet operation
	$oMonOperation = new operation();
	$this->assertIsA($oMonOperation, 'operation');
	$aMethode = array($oMonOperation, 'addition');
	//Appel de la methode addition
	$this->assertTrue(is_callable($aMethode, true));
	// 1 + 1 = 1
	$this->assertEqual($oMonOperation->addition(1,1), 2);
	// 1 + 0 = 0
	$this->assertEqual($oMonOperation->addition(1,0), 1);
	// 0 + 1 = 1
	$this->assertEqual($oMonOperation->addition(0,1), 1);
	// 24 112 126 468 + 54 456 123 123 = 78 568 249 591
	$this->assertEqual($oMonOperation->addition(24112126468,54456123123), 78568249591);
	// 12.5 + 13.3 = 25.8
	$this->assertEqual($oMonOperation->addition(12.5,13.3), 25.8);
}

Super ! nos 7 tests sont passés

Jusque là c’était facile, maintenant nous allons nous lancer sur des tests plus perspicaces.

Mais comment faire Roul ?

Il faut juste essayer de pourrir notre code en envoyant tout et n’importe quoi en paramètre.

Pour le test unitaire de la méthode addition on va faire :

$this->assertFalse($oMonOperation->addition(‘a’,12));

On test ….

test unitaire

Oh lalala ! La belle erreur ! Notre fonction ne renvoie pas faux, mais 120.
Notre fonction, n’est pas encore opérationnelle, on va vite corriger ça.

public function addition($fNb1,$fNb2) {

	if (is_numeric($fNb1) && is_numeric($fNb2))
	{
		return $fNb1 + $fNb2;
	}else{
		return false;
	}
}

C’est bon, tout passe ^^.

Vous savez maintenant faire des test-unitaires. Bien sur ce test unitaire n’est pas du tout fiable, on devrait faire des batteries des tests beaucoup plus importantes. Il n’est pas nécessaire d’approfondir plus sur le test d’addition, parce que chaque test unitaire est propre au code qu’il vérifie.

Oui, je sais faire un test unitaire, mai j’ai un gros blanc, je ne sais pas quoi tester, comment faire ???

En fait la démarche pour faire les test vous la connaissez déjà.
Dans un premier temps on vérifie si notre fonction ne retourne pas d’erreur.
Puis nous faisons différents tests pour voir si les fonctions retournent bien le résultat demandé.
Et enfin, on en fait voir de toutes les couleurs à nos fonctions(voir si elle ne génère pas d’erreur).

Après en fonction des spécifications techniques, on peux faire des test unitaire sur la consommation de mémoire (qui est un vrai problème en php) ou sur la vitesse d’exécution du script.

Quand faut-il faire les tests unitaires ?

En fait cela dépend de votre projet, mais il faut savoir qu’il y a trois techniques différents pour savoir quand construire ces tests unitaires :

La technique classique : le code d’abord, les tests ensuite.
La technique inversée : les tests d’abord et le code ensuite
La technique entrelacée : on fait les test en fonction de l’avancement du projet.

Un dernier exemple plus poussée

On va construire la méthode division de notre classe opération :

public function division($fNb1,$fNb2) {

	if (is_numeric($fNb1) && is_numeric($fNb2))
	{
		return $fNb1 / $fNb2;
	}else{
		return false;
	}
}

Et on va reprendre notre test unitaire de la méthode addition pour faire celle de la méthode division.

public function testDivision() {
	echo 'Debut des test sur les divisions '."n";
	// Creation du objet operation
	$oMonOperation = new operation();
	$this->assertIsA($oMonOperation, 'operation');
	$aMethode = array($oMonOperation, 'division');
	//Appel de la methode division
	$this->assertTrue(is_callable($aMethode, true));
	// 1 / 1 = 1
	$this->assertEqual($oMonOperation->division(1,1), 1);
	// 1 / 0 = faux
	$this->assertFalse($oMonOperation->division(1,0));
	// 0 / 1 = 0
	$this->assertEqual($oMonOperation->division(0,1), 0);
	// 24 112 126 468 / 54 456 123 123 = 0.442
	$this->assertEqual($oMonOperation->division(24112126468,54456123123), 0.442);
	// 12 / 4 = 3
	$this->assertEqual($oMonOperation->division(12,4), 3);
	// a / 12 => false
	$this->assertFalse($oMonOperation->division('a',12));
}

Eh la, malheur ! nos tests unitaires nous renvoie que des erreurs.

Maintenant il reste plus qu’à debugger, mais la ce n’est pas l’objectif du tutoriel, et pour moi il est l’heure de me coucher

Installation rapide de PhpDocumentor :

Vous l’aurez deviné, il faut tout d’abord le télécharger C’est par ici.

php documentator

Une fois décompressé vous allez mettre votre dossier PhpDocumentor dans la racine de votre dossier www.

Bravo vous avez installé PhpDocumentor

Comme vous l’imagez PhpDocumentor met un certain temps pour générer toute la documentation d’une application php. Et apache par défaut limite le traitement du script php à 30 secondes. Ce qui bien évidement ne suffit pas pour faire tourner PhpDocumentor. Pour pallier ce problème il suffit de modifier fichier php.ini :

max_execution_time = 0;
max_input_time = 0;

Comme ça on est tranquille il n’y a plus de limite

Configuration de PhpDocumentator

Il faut se rendre sur cette adresse pour arriver la page d’administration de PhpDocumentor.

En haut à gauche vous allez voir ce menu :

PhpDocumentator

C’est l’onglet Files qui va nous intéresser.

Directory to parse : C’est le chemin du dossier où se situe votre application php (celui que phpDocumentor va traiter)

Files to ignore : On doit indiquer les types de fichier à ne pas traiter (ex : *.png, *.jpg, *.css)

Passons maintenant à l’onglet Output.

Target : Nous allons indiquer l’adresse où notre documentation va être générée ( ex: C:wampwwwdoc)

Output Format : C’est la forme que prendra votre doc (vous aurez le choix entre du xml , html ou pdf)

La dernière modification sera dans l’onglet Options.

Generated Documentation Title : C’est le nom de votre documentation.

Génération de la documentation

La c’est le plus simple on a juste à cliquer sur un bouton :

php documentor

La il faut attendre un peu que le script se génère. La durée est relative à la taille de votre application.

Si vous voyez ça, c’est que votre doc est bien généré :

PhpDocumentor

Oui, ma doc est bien formée, mais j’ai pratiquement pas d’information dessus.
Mais comment cela se fait-il Roul ???

Si vous avez une documentation appauvrie, c’est que vous avez mal commenté vos fonctions dans votre code source php.

Voici un exemple qui devrait faire une documentation assez complète :

/**
 * @author Roul
 * @access public
 * @param float $fNombre
 * @todo double le nombre entré en paramètre
 * @return float
 */

 public function double(float $fNombre)
 {
 	return $fNombre*2;
 }

Si vous voulez plus d’indications sur le formatage des commentaires je vous conseille de lire ceci

Fonctionnement gettext

Pour pouvoir appliquer des traductions avec gettext on va avoir besoin de deux types de fichiers :

• .po : C’est le fichier où l’on va entrer les traductions. Ce fichier est uniquement lisible par les humains.
• .mo : C’est le fichier compilé du .po où son stockées les traductions. Ce fichier est uniquement lisible par php.

L’installation gettext

Pour l’installer sur votre serveur, il n’y a rien de plus simple. Il suffit d’entrer « apt-get install php-gettext » dans votre console linux (attention il faut être loguer en root), Et tout s’installe automatiquement.

L’organisation des traductions

Pour ne pas se perdre au milieu de tous les fichiers de traductions, nous allons créer un dossier par langue.

arborescence gettext

L’utilisation de gettext en php

Dans un premier temps vous devez retrouver votre fichier gettext.inc pour l’inclure
Il doit se situer normalement dans « /usr/share/php/php-gettext/ ».

Nous allons créer notre premier fichier multilingue : bienvenue.php

//inclusion de la librairie gettext
require_once('/usr/share/php/php-gettext/gettext.inc');

$dir=setlocale(LC_ALL, 'fr_FR');
if($dir =='')
{
	die("Erreur : la localisation n'est pas implémentée sur votre plate-forme ou la variable de localisation n'existe pas");
}
// Spécifie la localisation des tables de traduction
bindtextdomain("welcome", "./language");

// Choisit le domaine
textdomain("welcome");

// La traduction est cherché dans ./language/fr_FR/LC_MESSAGES/welcome.mo

// Affichage d'un message de test
echo gettext("hello")."</br>";

// Ou utilisation de l'alias _() pour gettext()
echo _("goodbye");

Maintenant il faut ouvrir votre page bienvenue.php.
Normalement vous devriez voir le message « hello » suivit de « goodbye »;
Ceci est normal, vu que gettext ne trouve pas la traduction, il affiche alors le mot non traduit.

création et compilation des fichiers de traductions

Tout d’abord nous allons créer notre fichier de traduction.
Dans votre console linux, positionnez-vous dans le dossier où ce situe votre fichier bienvenue.php

Une fois ceci fait, on lance la comande :
xgettext -kT_gettext -kT_ bienvenue.php

Le gettext va alors récupèrer les chaînes à traduire dans le code source bienvenue.php, il va génèrer automatiquement le fichier .po

Un fichier messages.po doit être créer dans la racine, nous allons le renommer welcome.po et le copier dans « languagefr_FRLC_MESSAGES »

Maintenant nous allons pouvoir éditer notre fichier et traduire les mots répertoriés(de la page bienvenue.php) par get text.

Pour qu’une traduction soit effectuée, il faut définir un identifiant de message : msgid et le texte attacher à celui-ci : msgtr.

pour nous nous allons mettre :

#: bienvenue.php:19
msgid "hello"
msgstr "salut"

#: bienvenue.php:20
msgid "goodbye"
msgstr "aurevoir"

Pour compiler notre fichier welcome.po, il faut utiliser la commande msgfmt.
Il faut bien sur ce positionner dans le dossier ou est situé welcome.po, et taper « msgfmt welcome.po -o welcome.mo  »
Normalement vous devez voir apparaître votre fichier welcome.mo.

Voici ce que cela va donner au final sur notre arborecence :

arborescence gettext

Maintenant vous pouvez ouvrir votre page bienvenue.php

eh la ! Miracle on voit que la traduction se met en français