En gros, un « slug » c’est un texte, par exemple « Salut l’ami » qui est transformé en son équivalent URL « friendly ». Ce qui donne « salut-l-ami » ou encore « salut-ami ».

Si vous ne connaissiez pas l’expression « slug », dans d’autres CMS ont trouve parfois des noms comme « friendy_url » ou encore « rewrote_url ». Mais si on cherche la définition ou la traduction du mot « slug » on trouve assez difficilement quelque chose de cohérent par rapport à l’utilisation qui en est faite dans WordPress.

Un « slug » en imprimerie

Un « slug » ça vient d’une machine d’imprimerie utilisée, principalement dans le domaine de la presse, entre 1800 et 1970 : la Linotype. Cette machine permettait de produire des lignes de textes en plomb. Contrairement aux machines de typographie classiques de l’époque où chaque caractère était indépendant, la Linotype permettait de fondre des lignes complètes de texte (plus facile et plus rapide à manipuler)

Ces lignes de texte s’appelaient, en français, des « ligne-bloc » et en anglais des « slug ». Voilà pour la définition originale de « slug ». On commence à y voir plus clair.

En cas d’erreur (elles étaient apparemment fréquentes) dans une ligne-bloc, on devait remplacer toute la ligne. Par extension, le mot « slug » s’appliqua à l’action de remplacer les ligne-blocs par leurs versions corrigées.

Un « slug » en journalisme

Une autre définition qui pourrait coller à l’utilisation de l’expression « slug » dans WordPress est celle qui en faite dans le domaine du journalisme. Dans ce cas un « slug » est, parfois employé pour définir une référence à un travail.

Cela pourrait coller avec le fait que le « slug » dans l’URL fait référence à un article. En revanche cela fonctionne moins bien si on fait référence à des pages classiques ou a des catégories.

Conclusion finale : faites votre choix, ou prenez un peu des deux. :p

Je ne vais pas expliquer comment le Web fonctionne, mais juste rappeler un élément clé de notre média : le lien hypertexte. Quand je fais un lien vers une ressource c’est pour permettre à l’utilisateur d’y accéder simplement. Si cette ressource est un site externe, j’accorde, en plus, ce qu’on pourrait appeler un vote de confiance à ce site en invitant l’internaute à la visiter.

Ça, c’est la base du fonctionnement du Web, mais c’est aussi celle du fonctionnement de Google (et de tous les moteurs de recherche modernes, Bing, Yandex, etc.). Ce n’est bien sûr pas le seul critère, mais il reste encore aujourd’hui très important.

Quand je suis sur le forum et que je fais un lien vers un site, je fais un vote de confiance vers cette ressource avec la voix d’Alsacreations. Google traduit cela par : Alsacreations recommande cette ressource.

Le nofollow est une sorte de patch bancal proposé par les moteurs de recherche qui permet de supprimer cette valeur de vote positif d’un lien. Quand je fais un lien nofollow je dis aux moteurs de recherche : voici un lien, mais je n’accorde pas ma confiance à cette ressource donc n’en tenez pas compte.

Le but de cette aberration ce patch est de réduire le spam. Dans la pratique cela fonctionne un peu, mais pas entièrement, et surtout cela va à l’encontre de ce qu’est et de la façon dont fonctionne le Web. En fait cela sert surtout à alléger la charge de travail des éditeurs de moteurs de recherche.

Ce qui est vraiment dommage c’est que d’un coup tout le poids que donnait le forum Alsacreations à d’excellentes ressources vient de partir en fumée. Et dans un deuxième temps, la communauté s’est privée d’une partie de sa voix pour promouvoir les ressources de qualité.

Bien sûr, il s’agit de la partie réservée aux moteurs de recherche en général et à Google en particulier. Mais on sait comment fonctionne le Web actuel et les moteurs y ont une place prépondérante (et c’est bien dommage). C’est triste de voir que de très bons sites comme Alsacreations, soient contraints de recourir à des méthodes que Google et les autres moteurs imposent, de fait, car ils ne sont pas capables de lutter efficacement contre le spam. Surtout quand les méthodes causent des dommages collatéraux pour le bon Web.

Pourtant on pourrait essayer de trouver des parades, comme limiter le nofollow aux membres récemment inscrits ou participants peu (ancienneté, nombre de publications). Ou chercher d’autres pistes, mais toujours moins pénalisantes pour les ressources de qualité.

Heureusement, depuis la version 5 de PHP on peut définir une fonction magique nommée __autoload et qui se chargera de charger automatiquement les fichiers contenant les classes à la volée.

Pour pouvoir utiliser cette fonctionnalité, il faut avoir une certaine rigueur dans l’organisation de ses fichiers et dans la façon de nommer ses classes.

Voici un exemple de structure et de conventions que j’utilise pour mes sites :

Mes classes sont nommées en utilisant le style CamelCase majuscule. C’est-à-dire que les mots sont tous composés d’une première lettre en majuscule suive de minuscules. Les mots sont collés les uns aux autres. Exemples : MaClasse, Database, Pdf… .

Mes noms de fichiers contenant des classes sont composés uniquement de lettres minuscules et les mots sont séparés par des tirets-bas. Le nom du fichier se termine par le suffixe : « .class.php ». Exemples : ma_classe.class.php, database.class.php, pdf.class.php… .

Mes scripts PHP sont stockés dans un dossier nommé « core ». Une constante CORE_DIR est définie et contient le chemin absolu vers ce dossier.

Mes classes sont stockées dans trois sous dossiers contenus dans « core » :

• « libs » pour les classes génériques
• « controllers » pour les contrôleurs
• « models » pour les modèles

Ma fonction __autoload devra donc effectuer les opérations suivantes :

• Faire la correspondance entre le nom de la classe et le nom du fichier. MaClasse devient ma_classe.class.php
• Vérifier si le fichier existe dans les 3 dossiers, l’un après l’autre.
• Si le fichier est trouvé, l’inclure et renvoyer un booléen.

La fonction __autoload prend en argument le nom de la classe appelée. Elle doit renvoyer un booléen : TRUE si le fichier a été trouvé et inclut, FALSE dans le cas contraire.

Et voici le code de notre fonction __autoload correspondant à nos besoins :

function __autoload($class_name)
{
 // on converti le nom de la classe en nom de fichier.
 $base_name = strtolower(preg_replace('/(?<=[a-z])(?=[A-Z])/', '_', $class_name));
 $file_name = $base_name.'.class.php';
 
 // un tableau contenant nos chemins dans l'ordre dans lequel on veut les tester
 $paths = Array();
 $paths[] = CORE_DIR . 'libs/';
 $paths[] = CORE_DIR . 'controllers/';
 $paths[] = CORE_DIR . 'models/';
 
 /**
  * On teste si le fichier existe dans nos dossiers,
  * si le fichier existe, on l'inclut et on quitte la fonction
  * en renvoyant le booléen TRUE.
   */
 foreach ($paths as $path) {
 
  if (file_exists($path.$file_name)) {
 
   require $path.$file_name;
   return TRUE;
 
  }
 }
 
 /**
  * Si le fichier n'a pas été trouvé, on quitte la fonction
  * en renvoyant le booléen FALSE.
   */
 return FALSE;
}

Il suffit d’inclure cette fonction dans un fichier commun à nos scripts et elle sera exécutée automatiquement quand on tentera d’instancier une classe qui n’est pas déclarée.

Dans le cadre d’une connexion à la base de données, ce motif est très pratique, car nous sommes certains de récupérer la connexion courante et de ne pas en créer une à chaque fois.

Principe du motif Singleton

Le Singleton est l’un des patrons de conception que l’on apprend en général au début de son apprentissage de la programmation orientée objet, car il est très facile à comprendre.

Le principe est le suivant :

• Une classe Singleton aura une instance unique quoiqu’il arrive.
• Quand on appellera cette classe, nous recevrons à chaque fois cette unique instance.
• Il n’est pas possible d’instancier manuellement ni de cloner une classe Singleton.

En programmation cela se traduit par :

• Le constructeur est privé afin que l’on ne puisse pas instancier l’objet.
• Le cloneur est privé afin que l’on ne puisse pas cloner l’objet.
• L’unique instance de la classe est contenue dans la classe elle même.
• Quand on demande à récupérer l’instance de la classe, elle est créée si elle n’existe pas, puis elle est renvoyée.

Exemple en PHP :

class Singleton {
 
 /**
   * @var Singleton
   * @access private
   * @static
   */
   private static $instance = NULL;
 
  /**
   * Le constructeur est privé pour qu'on ne puisse
   * pas instancier la classe depuis l'extérieur
   *
   * @access private
   * @param void
   * @return void
   */
   private function __construct()
   {
     // constructeur privé
   }
 
  /**
   * Le cloneur est privé pour qu'on ne puisse pas cloner l'objet
   *
   * @access private
   * @param void
   * @return void
   */
   private function __clone()
   {
     // cloneur privé
   }
 
  /**
   * Méthode qui crée l'unique instance de la classe
   * si elle n'existe pas puis la renvoie.
   *
   * @access public
   * @static
   * @param void
   * @return Singleton object
   */
   public static function getInstance()
   {
     if(self::$instance === NULL) {
       self::$instance = new Singleton();
     }
 
     return self::$instance;
   }
 
  /**
   * Méthode qui détruit l'unique instance de la classe.
   *
   * @access public
   * @static
   * @param void
   * @return void
   */
   public static function killInstance()
   {
     self::$instance = NULL;
   }
}

Voici comment on utilisera cette classe :

// on crée ou récupère l'objet Singleton
$singleton = Singleton::getInstance();
 
// $singleton est un objet représentant l'unique instance de la classe Singleton.
 
// on détruit l'objet Singleton
$singleton = Singleton::killInstance();

On imagine bien le côté pratique pour la gestion d’une connexion à une base de données. Quand on demande l’instance de l’objet on vérifie si l’objet mysqli ou PDO existe, si ce n’est pas le cas on le crée en se connectant à la base de données et enfin on renvoi l’objet (et donc l’unique connexion). Si on souhaite couper la connexion explicitement il suffit d’appeler la méthode killInstance().

Néanmoins il existe une limite avec ce système : si le site utilise plusieurs bases de données et que l’on souhaite les utiliser au cours d’un même script on ne pourra pas le faire. Pour pallier à ce problème, il existe une variante du Singleton qu’on appelle le Multiton.

Variante : le Multiton

On ne peut pas dire que le Multiton soit un patron de conception différent du Singleton, c’est en fait une variante qui permet tout simplement de travailler avec plusieurs instances uniques d’un objet Singleton.

Dans le cadre d’une utilisation avec une base de données cela permet de gérer plusieurs connexions tout en étant sûr que chaque connexion sera elle même unique quoiqu’il arrive.

Ce qui donne en PHP :

class Multiton {
 
 /**
   * @var Multiton
   * @access private
   * @static
   */
   private static $instance = Array();
 
  /**
   * Le constructeur est privé pour qu'on ne puisse
   * pas instancier la classe depuis l'extérieur
   *
   * @access private
   * @param void
   * @return void
   */
   private function __construct()
   {
     // constructeur privé
   }
 
  /**
   * Le cloneur est privé pour qu'on ne puisse pas cloner l'objet
   *
   * @access private
   * @param void
   * @return void
   */
   private function __clone()
   {
     // cloneur privé
   }
 
  /**
   * Méthode qui crée une instance unique si elle n'existe pas puis la renvoie.
   *
   * @access public
   * @static
   * @param string $id
   * @return Multiton object
   */
   public static function getInstance($id)
   {
     if(!isset(self::$instance[$id])) {
       self::$instance[$id] = new Multiton();
     }
 
     return self::$instance[$id];
   }
 
  /**
   * Méthode qui détruit l'instance.
   *
   * @access public
   * @static
   * @param string $id
   * @return void
   */
   public static function killInstance($id)
   {
     unset(self::$instance[$id]);
   }
}

Voici comment on utilisera cette classe :

// on crée ou récupère une instance
$un_id = Singleton::getInstance('un_id');
 
// $un_id est un objet representant une instance unique de la classe.
 
// on crée ou récupère une autre instance
$un_autre_id = Singleton::getInstance('un_autre_id');
 
// $un_autre_id est un objet representant une autre instance unique de la classe.
 
// on détruit une des instances
$singleton = Singleton::killInstance('un_id');

Cas pratique pour la connexion à une base de données

Nous allons maintenant voir comment implémenter ce motif avec le cas pratique de la gestion de la connexion à une ou plusieurs bases de données. Pour l’exemple j’utilise l’API PDO pour gérer ma connexion.

/**
 * Db class
 */
class Db {
 
 /**
   * @var Db
   * @access private
   * @static
   */
 private static $instance = Array();
 
  /**
   * Le constructeur est privé pour qu'on ne puisse
   * pas instancier la classe depuis l'extérieur
   *
   * @access private
   * @param void
   * @return void
   */
   private function __construct()
   {
     // constructeur privé
   }
 
  /**
   * Le cloneur est privé pour qu'on ne puisse pas cloner l'objet
   *
   * @access private
   * @param void
   * @return void
   */
   private function __clone()
   {
     // cloneur privé
   }
 
  /**
   * Méthode qui crée une instance unique si elle n'existe pas puis la renvoie.
   *
   * @access public
   * @static
   * @param string $id
   * @return Db object
   */
 public static function getInstance($id = 'default')
 {
  if (!isset(self::$instance[$id]))
  {
   $config = Config::getInstance();
   $db_config = $config->get('database', $id);
 
   if ($db_config === FALSE) {
 
    throw new Exception(__CLASS__.': Database configuration no found: "'.$id.'".');
 
   } else {
 
    $dsn = $databases[$id]['driver'].':host='.$databases[$id]['host'].';dbname='.$databases[$id]['name'];
    $user = $databases[$id]['user'];
    $password = $databases[$id]['password'];
 
    try {
      self::$instance[$id] = new PDO($dsn, $user, $password, array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES 'UTF8'"));
      self::$instance[$id]->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
     } catch (PDOException $e) {
      die('Erreur de connexion à la base de données.
Vous pouvez essayer de rafraîchir la page.
'.$e->getMessage());
     }
 
   }
   }
 
  return self::$instance[$id];
 }
 
  /**
   * Méthode qui détruit l'instance.
   *
   * @access public
   * @static
   * @param string $id
   * @return void
   */
   public static function killInstance($id = 'default')
   {
     unset(self::$instance[$id]);
   }
}

Et voici comment on l’utilise :

// on se connecte ou on récupère la connexion à la base de données "default"
$db = Db::getInstance();
 
// on se connecte ou on récupère la connexion à la base de données "chat"
$db_chat = Db::getInstance('chat');
 
// on ferme explicitement la connexion à la base de données "default"
Db::killInstance();
 
// on ferme explicitement la connexion à la base de données "chat"
Db::killInstance('chat');

Vous aurez remarqué que je fais appel à un objet $config pour récupérer la configuration de la base de données. Cet objet est un simple Singleton qui me permet d’accéder à la configuration de mon site depuis mes scripts sans utiliser de constantes ou de variables globales.

Pour voir si vous avez bien compris le principe vous pourriez essayer d’implémenter vous même la classe Singleton Config.

Quels sont les avantages et les inconvénients de chacune d’elle et laquelle doit-on utiliser dans ses scripts ?

L’extension mysql

Tout d’abord, parlons un peu de l’extension originale mysql. C’est la plus connue et on la retrouve, hélas, dans de nombreux scripts disponibles sur le Web.

De nombreux débutants l’utilisent encore en 2011, ce qui est une vraie erreur. En effet cette extension n’est incluse la distribution PHP que pour des raisons de compatibilité avec les anciens scripts. Elle n’est plus développée depuis la sortie de PHP 5.0 en 2004. Les seules modifications apportées à cette extension sont des opérations de maintenance, par exemple la correction de failles de sécurité.

De plus cette extension ne supporte que les spécificités de MySQL versions 4.1 et inférieures (pour rappel, à la date où j’écris cet article nous sommes à la version 5.6 de MySQL). En fait la seule raison d’utiliser aujourd’hui cette extension serait d’hériter d’un vieux projet tournant sous PHP 4.x ou moins et dont on ne pourrait pas mettre à jour la version de PHP.

L’extension mysqli

Le « i » signifie « improved » (amélioré) et explique bien ce qu’est cette extension : une version améliorée de l’ancienne extension mysql. Mysqli est disponible depuis PHP 5.0 et est l’extension par défaut pour les versions récentes de PHP.

Cette API supporte les spécificités des versions supérieures à 4.1 de MySQL et possède de nombreux avantages par rapport a l’ancienne extension mysql :

• Interface au choix orientée objet ou procédurale
• Support des requêtes préparées
• Support des commandes multiples
• Support des Transactions
• Capacités de débogage avancées
• Support du serveur embarqué

Mysqli est construite pour travailler en mode orienté objet. Si vous vous lancez dans un nouveau projet utilisant cette API c’est un bon choix de travailler dans ce mode. Néanmoins elle autorise de travailler en mode procédural comme avec l’ancienne API mysql. Cela peut être pratique pour 2 raisons :

• On peut facilement convertir un projet utilisant l’ancienne mysql pour travailler avec mysqli, pour cela il suffit dans la plupart des cas des simplement changer le nom des fonctions mysql_* par mysqli_*. Et c’est tout.
• Si on n’est pas habitué à la programmation orientée objet ou si on ne souhaite tout simplement pas l’utiliser, alors on peut travailler avec mysqli en mode procédural.

D’après la documentation officielle de PHP, cette extension est celle à préférer lorsqu’on souhaite développer un nouveau projet utilisant MySQL (voir tableau comparatif à la fin de l’article).

Pour aller plus loin reportez-vous à la documentation officielle de mysqli.

L’extension PDO

L’abréviation PDO signifie PHP Data Object. Il s’agit d’une couche d’abstraction de base de données. En clair PDO permet de travailler avec MySQL mais aussi avec de nombreux autres gestionnaires de bases de données. L’avantage est que vous apprenez les commandes PDO et si vous devez travailler un jour sur un projet utilisant un autre moteur de base de données que MySQL vous n’avez pas à réapprendre de nouvelles commandes.

PDO gère automatiquement les différences entre les différents types de bases de données de façon transparente. Cela signifie que si vous utilisez une fonction PDO qui n’est pas supportée par votre moteur de base de données, PDO se chargera d’émuler la fonctionnalité de manière transparente.

L’utilisation de PDO se fait en mode orienté objet et il est très simple à utiliser. De plus cette API supporte la plupart des spécificités des versions modernes de MySQL (mais moins que mysqli).

Pour aller plus loin reportez-vous à la documentation officielle de PDO.

Comparatif des 3 extensions

Voici un tableau comparant mysql, mysqli et PDO et tiré de la documentation officielle de PHP :

Conclusion

Oubliez l’obsolète extension mysql, elle ne permet pas de travailler correctement avec les versions récentes de MySQL et n’est présente que pour des raisons de compatibilité.

Préférez lui mysqli ou PDO. Selon vos goûts et vos besoins.

Bien que simple à utiliser, il pose souvent problème aux débutants. Nous allons donc voir comment l’utiliser pour la réalisation d’un site Web.

La configuration logicielle sous laquelle fonctionnera notre site sera le classique trio :

• Apache pour le serveur HTTP.
• PHP 5.x comme langage de script.
• MySQL 5.x pour le gestionnaire de bases de données.

Pour utiliser UTF-8 sans problème avec cet environnement, il suffit de suivre ces quelques règles :

• Les fichiers du site doivent être codés en UTF-8.
• Les entêtes définissant l’encodage des caractères comme étant de l’UTF-8 doivent être envoyés au client.
• La base de données doit être codée et déclarée en UTF-8.
• Certaines fonctions de PHP ne supportant pas l’UTF-8 doivent être abandonnées au profit de leurs équivalents supportant ce format.
• Il faut s’assurer que les données externes utilisées par le site sont bien codées en UTF-8 et dans le cas contraire les convertir.

Encodage des fichiers

La première étape pour utiliser le codage UTF-8 est d’être sûr que les fichiers du site sont bien encodés dans ce format. Pour cela, il faut utiliser un éditeur de texte ou un IDE qui le supporte correctement. À l’heure actuelle, ce n’est plus un problème, car tous les éditeurs modernes supportent correctement l’UTF-8.

Avec ou sans BOM ?

Le BOM (Byte Order Mark) est un caractère qui peut être utilisé pour spécifier qu’un fichier est encodé en UTF-8. Il est écrit automatiquement par votre éditeur de texte au tout début du fichier. Quand il est utilisé, l’éditeur de texte reconnaitra automatiquement que le fichier est encodé en UTF-8 et le traitera comme tel.

Un problème peut survenir quand des fichiers enregistrés avec BOM sont utilisés avec PHP. Ce problème survient quand on inclut des fichiers avec les directives include, include_once, require ou require_once. Dans ces cas le BOM des fichiers inclus est envoyé sur la sortie ce qui casse le fonctionnement des fonctions d’envoi d’entêtes, des cookies ainsi que des sessions.

La solution à ce problème est très simple : il suffit de configurer votre éditeur pour enregistrer les fichiers UTF-8 sans BOM.

Si vous vous retrouvez dans vos scripts avec une erreur PHP du type : « Headers already sent… », vérifiez bien que tous vos fichiers sont bien enregistrés sans BOM.

Néanmoins il peut exister un petit problème avec quand on utilise des fichiers sans BOM. Si vous avez un fichier qui ne contient que des caractères contenus dans la table de caractères US-ASCII votre éditeur n’aura aucun moyen de faire la différence avec de l’UTF-8 car ce dernier est rétro compatible avec le standard ASCII. Ce qui peut arriver c’est que plus tard vous éditez votre fichier et vous saisissez des caractères spécifiques à l’UTF-8. Quand vous sauvegardez votre fichier, l’éditeur l’enregistrera dans le codage par défaut, et si ce dernier n’est pas de l’UTF-8 alors vous aurez des erreurs à l’affichage de ces nouveaux caractères.

Il existe 2 solutions simples pour corriger ce problème :

Vous configurez votre éditeur pour qu’il enregistre toujours les fichiers en UTF-8. Ce qui n’est pas toujours possible.

Vous faites en sorte que vos fichiers contiennent toujours au moins un caractère UTF-8. Par exemple le caractère « é ». Pour vos fichiers PHP c’est très facile à mettre en place, il suffit de rajouter ce caractère dans un commentaire au début de chaque fichier : <?php /* force utf-8: é */ ?>.

Les entêtes UTF-8

Pour que le client (en général un navigateur Web) reconnaisse à coup sûr les données qu’il reçoit comme étant codé en UTF-8 il faut lui envoyer des entêtes déclarant ce codage.

L’entête HTTP

Pour envoyer l’entête HTTP vous avez 2 possibilités : l’envoyer depuis le script PHP ou l’envoyer depuis le serveur HTTP (Apache). Pour être sûr que votre script soit portable d’une configuration à une autre ce n’est pas un mal de toujours envoyer l’entête depuis PHP.

Pour envoyer l’entête depuis votre script PHP il suffit d’ajouter la ligne suivante au tout début de votre script (avant l’affichage de n’importe quel caractère) :

header('Content-type: text/html; charset=UTF-8');

Si vous avez un script commun inclus à toutes vos pages, il est judicieux de placer ce code au début de script.

Si vous envoyez des emails depuis un script PHP, pensez aussi à déclarer le jeu de caractères UTF-8 dans l’entête des emails.

Si vous souhaitez laisser le serveur envoyer l’entête UTF-8 vous pouvez définir ce codage comment étant celui par défaut. Ajoutez simplement la directive suivante dans votre fichier de configuration (httpd.conf) ou dans votre fichier .htaccess :

AddDefaultCharset UTF-8

L’entête HTML

Vos fichiers HTML doivent aussi être déclarés en UTF-8. Pour cela c’est très simple, ajoutez simplement la balise meta suivante entre <head> et </head> :

<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

Oui si vous utilisez le Doctype HTML 5 :

<meta charset="utf-8">

Utiliser de l’UTF-8 dans vos scripts PHP

PHP 5.x ne travaillent pas avec le standard Unicode, il ne supporte pas nativement le traitement de chaines de caractères UTF-8. Ces fonctions supportant uniquement les caractères codés sur un octet et UTF-8 permettant de coder les caractères sur un nombre variable d’octets, elles ne fonctionneront pas correctement.

Par exemple le caractère “é” est encodé sur 2 octets en UTF-8. Si nous testons avec la fonction strlen() (qui renvoi le nombre de caractères d’une chaine) nous aurons un résultat erroné :

echo strlen("é"); // affiche 2

Par chance PHP dispose d’une extension officielle (donc incluse par défaut dans l’installation de PHP) qui supporte les caractères codés sur un nombre d’octets variable. Il s’agit de l’extension mbstring.

L’utilisation de cette extension est extrêmement simple puisque qu’elle ne fait rien de plus qu’implémenter des équivalents multioctet des fonctions de manipulation de chaines natives de PHP.

La seule chose à faire et de préfixer les fonctions natives par « mb_ ».

Exemple:

strlen($text);
// devient :
mb_strlen($text);

La liste des fonctions à utiliser en place des fonctions natives de PHP est disponible sur la documentation officielle :

http://fr.php.net/manual/en/book.mbstring.php

Il suffit ensuite de déclarer à l’extension mbstring que vous souhaitez travailler en UTF-8. Pour cela il suffit de rajouter la ligne suivante dans le script commun à toutes vos pages :

mb_internal_encoding('UTF-8');

NOTE : mbstring contient des versions multioctet des fonctions ereg/eregi. L’utilisation de ces dernières n’est pas recommandée, car leurs équivalents natifs sont dépréciés en PHP 5. Donc utilisez les fonctions preg natives, car elles supportent bien l’UTF-8.

UTF-8 avec MySQL

Quand on veut travailler en UTF-8 avec MySQL il faut observer plusieurs points :

Encodage des données dans la base

Vos bases de données, tables et colonnes doivent être déclarées en UTF-8. Vous devez déclarer le jeu de caractères et la collation qui correspond.

En général, on utilisera le jeu de caractères utf8 et la collation utf8_general_ci. Utf8_general_ci est une collation rapide et suffisante pour la plupart des cas. Pour voir en détail les autres types de collations, reportez-vous à la documentation de MySQL.

CREATE DATABASE `ma_base` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

Déclarer le jeu de caractères lors de la connexion

Quand vous vous connectez à votre base de données, la première chose à faire et de déclarer le jeu de caractères comme étant de l’UTF-8.

Si vous utilisez l’extension mysqli il vous suffit d’exécuter cette fonction juste après la connexion à la base de données :

mysqli_set_charset($link, 'utf8'); // procédural
 
$mysqli->set_charset('utf8'); // orienté objet

Si vous utilisez PDO, il n’y a pas de fonction équivalente, donc il vous suffit d’exécuter la requête suivante juste après la connexion à la base de données :

SET NAMES 'utf8';

NOTE : Si vous utilisez l’extension mysql vous devriez penser à mettre à jour vos scripts pour utiliser au moins mysqli.

Travailler avec des données externes

Parfois vous devez travailler avec des données provenant de l’extérieur et sur lesquelles vous n’avez pas de contrôle.

Par exemple :

• Des flux RSS, Json ou XML
• Des fichiers
• Des bases de données distantes

Quand vous recevez ces données, vous devez vérifier si elles sont bien encodées en UTF-8 et si ce n’est pas le cas les convertir dans ce jeu de caractères.

Pour déterminer si des données sont encodées en UTF-8 vous pouvez utiliser la fonction mb_detect_encoding() de l’extension mbstring :

if (mb_detect_encoding($data, 'UTF-8', true) == 'UTF-8')
echo "C'est bien de l'UTF-8";
else
echo "Ce n'est pas de l'UTF-8";

Si les données sont bien en UTF-8 vous pouvez les utiliser directement sur votre site. Sinon il vous suffit de les convertir avec la fonction mb_convert_encoding().

Vous pouvez aussi regarder les fonctions utf8_encode() et utf8_decode() qui permettent respectivement d’encoder et décoder UTF-8 de et vers le jeu de caractères ISO-8859-1.

Repérer et corriger les erreurs d’affichage des caractères

Il existe 2 cas de figure classiques :

Les caractères accentués sont remplacés par des caractères du genre : é, Ã, etc :

Problème :

Vos données sont bien encodées en UTF-8 mais le navigateur tente de les afficher en ISO-8859-1.

Solutions :

• Vérifiez que vous envoyez bien l’entête HTTP pour déclarer les données en UTF-8.
• Vérifiez que le jeu de caractères est bien déclaré en UTF-8 dans votre entête HTML (meta charset).
• Vérifiez que vous avez bien déclaré le jeu de caractères après la connexion à la base de données (SET NAME).

Les caractères accentués sont remplacés par des losanges contenant un point d’interrogation :

Problème :

Vos données sont encodées en ISO-8859-1 mais le navigateur tente de les afficher en UTF-8.

Solutions :

S’il s’agit d’un texte contenu en dur dans votre page :

• Convertissez votre fichier en UTF-8 depuis votre éditeur de texte.
• Vérifiez que vous envoyez bien l’entête HTTP pour déclarer les données en UTF-8.
• Vérifiez que le jeu de caractères est bien déclaré en UTF-8 dans votre entête HTML (meta charset).

Si le texte provient de la base de données :

• Vérifiez l’encodage de la base de données et les collations.
• Vérifiez que vous avez bien déclaré le jeu de caractères après la connexion à la base de données (SET NAME).

Si le texte provient d’une source externe (fichier, flux RSS, etc.) :

• Utilisez mbstring ou utf8_decode()/utf8_encode() pour convertir les données dans le bon jeu de caractères.

Mais il faut aussi tester que la date soit valide : le mois ne doit pas dépasser 12, le jour ne doit pas dépasser le nombre de jours du mois, etc.

Tester si l’année est bissextile

Une année bissextile contient un jour de plus qu’une année normale. Elle comporte un 29 février et possède donc 366 jours au lieu de 365.

Pour savoir si une année est bissextile, elle doit remplir l’un ou l’autre des critères suivants :

• Elle est divisible par 4, mais non divisible par 100
• Elle est divisible par 400

Il suffit donc d’écrire une fonction qui teste si l’année vérifie l’un ou l’autre de ces critères :

function is_leap_year(year) {
return( (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0 );
}

Que vous utiliserez comme ceci :

var year = 1992;
 
if (is_leap_year(1992)) {
 console.log(year + " est une année bissextile.");
} else {
 console.log(year + " n'est pas une année bissextile.");
}

L’équivalent en PHP coule de source :

function is_leap_year($year) {
return( ($year % 4 === 0 && $year % 100 !== 0) || $year % 400 === 0 );
}

Tester la validité de la date

Ici on ne parlera pas de tester la syntaxe de la date, mais bien si la date est valide. Pour la syntaxe, il suffit d’utiliser une expression rationnelle.

Pour qu’une date soit valide elle doit répondre aux critères suivants :

• le mois doit être une valeur comprise entre 1 et 12
• le jour ne doit pas être plus grand que 31
• le jour ne doit pas être plus grand que 30 pour les mois 4, 6, 9, et 11
• si le mois est février, le jour ne doit pas être plus grand que 29, ni plus grand que 28 pour les années non bissextiles

La fonction qui teste ces critères :

function is_valid_date(year, month, day) {
 
 // le mois doit être une valeur comprise entre 1 et 12
 if (month < 1 || month > 12)
  return false;
 
 // le jour ne doit pas être plus grand que 31
 if (day > 31)
  return false;
 
 // le jour ne doit pas être plus grand que 30 pour les mois 4, 6, 9, et 11
 if ((month == 4 || month == 6 || month == 9 || month == 11) && day > 30)
  return false;
 
 // si le mois est février...
 if (month == 2) {
  // le jour ne doit pas être plus grand que 29, ni plus grand que 28 pour les années non bissextiles
  if( (day > 29) || (!is_leap_year(year) && day > 28) )
   return false;
 }
 
 return true;
}

Que vous utiliserez comme ceci :

var year = 1992;
var month = 02;
var day = 29;
 
if (is_valid_date(year, month, day)) {
 console.log(day + "/" + month + "/" + year + " est une date valide.");
} else {
 console.log(day + "/" + month + "/" + year + " n'est pas une date valide.");
}

En PHP il existe une fonction qui teste la date pour vous : checkdate()

Elle s’utilise simplement comme ceci :

$year = 1992;
$month = 02;
$day = 29;
 
if (checkdate($month, $day, $year)) {
 echo $day . "/" . $month . "/" . $year + " est une date valide.";
} else {
 echo $day . "/" . $month . "/" . $year + " n'est pas une date valide.";
}