Un peu de tout et surtout rien - web

Générer un squelette de page xHTML façilement

knoodrake — Fri, 28 Dec 2007 20:32:00 +0100

Une petite astuce que j'ai trouvé lorsque je créé une nouvelle page ( sous Linux ) avec tidy .

Dans une console : --------------------------------------------------------------

$ tidy -i -asxhtml /dev/null > monFichier.html

qui donnera

$ cat monFichier.html



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta name="generator" content=
  "HTML Tidy for Linux/x86 (vers 1 September 2005), see www.w3.org" />

  <title></title>
</head>

<body>
</body>
</html>

l'option -i permet de demander à tidy d'identer le code, et l'option -asxhtml précise que l'on souhaite avoir du code xhtml ( on aurait pu utiliser -ashtml pour avoir du html )

Pour plus d'informations: $ man tidy

Pour installer tidy , simplement $ sudo apt-get install tidy

Notez que tidy est un formidable outil qui vous servira à moultes choses comme la "réparation" d'un fichier mal écrit, plein d'erreur.

My Jamendo Favorites albums :-)

knoodrake — Sun, 05 Aug 2007 11:11:00 +0200

Vous conaissiez Jamendo ?
Vous savez, ce site ou on trouve des milliers d'heures de musique libre !

PHP: Introduction au design patterns, partie 1: Singleton

knoodrake — Sat, 21 Apr 2007 13:18:00 +0200

Commence ici une petite serie de billets sur les "design patterns", les motifs de conception en français. Les motifs de conception ne sont rien d'autre que des solutions toutes prêtes à des problèmes couramment rencontrés, il s'agit de morceaux de code, des "squelettes" prêts à remplir leur fonction (variable) et à être adaptés a votre situation.

La quasi-totalité des design patterns ne dépendent pas d'un langage et peuvent être adaptés à n'importe quel langage moyennant l'adaptation de la syntaxe. Bien évidemment, un design pattern proposant une solution orientée objet ne sera valable que pour un language orienté objet, etc..

Singleton: Utilité

Le motif de conception nommé "singleton" est sans conteste un des plus simples à mettre en oeuvre et à comprendre, c'est aussi un des plus utilisés et les exemples de singleton pullulent sur le web, d'ailleurs, j'y mets là mon grain de sel

Destiné a la programmation orientée objet, il permet de n'avoir toujours qu'une seule et unique instance d'un objet quel que soit le nombre de fois où l'on en a besoin.
Une situation typique et courante est la connection a une BDD (Base De Données): en général, vous ne voulez avoir pour toute l'exécution du script qu'une unique connection a la BDD même si vous faites appel à votre classe de gestion de BDD a maintes reprises et dans différents contextes.

Un autre cas pourrait être le suivant: Vous utilisez un ensemble de classes par le biais d'une autre classe, par exemple, votre classe de gestion de BDD ainsi que votre classe de gestion d'utilisateur sont accessibles toutes deux au travers de la classe "moteur":

$moteur->bdd->query_sql()
$moteur->users->is_online();

Dans un tel contexte, vous voudriez sans doute là aussi n'avoir qu'une unique instance de la classe "moteur".

resultat recherché

Afin d'utiliser toujours la même instance d'une classe "BaseSql" par exemple, une solution pourrait être de l'instantiser une première fois lors de l'initialisation de votre script puis de faire passer la référence de l'objet de classe en classe de la sorte



class MaClasse_A 
{
 private $BaseSql;

 __construct (&InstanceBDD) {
        $this->BaseSql =& $InstanceBDD;
    }

    uneFonction () {
       $requete = "SELECT * FROM `MaTable` WHERE 1";
        $this->BaseSql->query_sql($requete);
    }
}

Mais cette solution n'est vraiment pas pratique ! car elle vous oblige à appeler votre classe en fournissant en argument l'instance de $BaseSql:

$classA = new MaClasse_A ($BaseSql);

Mais surtout, cela devient vraiment vraiment pénible dès qu'il est question d'héritage et de collaboration entre les classes ! voyez l'exemple ci-dessous:

class MaClasse_A {
    __construct (&instanceBDD) {
        $this->BaseSql =& $InstanceBDD;
    }

    /*
        ... plein de methodes
    */

    getUserInscriptionDate () {
       $classeDate = new DATE ($this->BaseSql);
        return $classeDate->userInstription();
    }
}

class DATE {

    __construct (&$instanceBDD) {
        $this->bdd =& $instanceBDD;
    }

    userInscription() {
        /*     ...     */
    }
}

Là c'était juste pour une classe qui se sert d'une autre classe, mais imaginez si cette même autre classe se sert elle-même d'une autre classe, puis que cette autre classe se serve de 4 autres classes, et ces 4 autres de 2 autres, etc.. Il faudra veiller à chaque fois que l'on a besoin de BASESQL à prendre la référence de son instance, bien veiller à toujours passer l'instance à d'autres classes, etc.. en d'autres mots, croyez-moi: ca devient le bordel !

LA solution qui serait élégante serait, de tout simplement, et à chaque fois que l'on a besoin d'utiliser la classe BASESQL, faire:



/* quelque part dans le code.. dans une classe ou n'importe ou */

$basesql = BASESQL::getInstance();    // et mainteant on fait ce qu'on veut
$basesql->methodeXYZ();               // et si on fait a nouveau
$Autre = BASESQL::getInstance();
/*
    et ben on se retrouve avec toujours la même instance,
    $basesql et $Autre contiendront la même instance de BASESQL
*/

le motif Singleton le permet en 2 ou 3 lignes.

Mise en Oeuvre

La classe qui ne devra être instantisée qu'une seule fois devra être comme ceci:



class BASESQL {

    private static $instance;

    /* ...some code */

    public static getInstance ()   {
        if (is_null(self::instance)) {
           self::instance = new BASESQL (/* ..some args */ );    }
        return self::instance;
    }

    /* ...some code */
}

Explication:

Lorsque vous faites un appel à la methode getInstance() comme ceci:


$BaseSql = BASESQL::getInstance();

La méthode regarde si la propriété $Instance est vide ( nulle ), si elle est vide, elle y affecte une nouvelle instance de BASESQL ( donc d'elle-même ), sinon, si elle n'est pas nulle, c'est qu'elle contient déja une instance d'elle-même précédemment créée, donc rien à faire.
Elle finit par retourner $Instance qui dans tous les cas contiendra donc une instance de BASESQL.
Ainsi, si BASESQL est déja instantisée on en transmet l'instance, sinon on instantise (et le prochain appel de la method getInstance transmettra cette instance qui vient d'être faite ) et on transmet.

La méthode getInstance() et la propriété $Instance sont publiques et statiques dans le but d'être accessibles par tout le monde et ce sans avoir besoin que la classe ait été déjà instantisée (logique, c'est le but ! )

Des questions ? des suggestions ? des conseils ? n'hésitez pas a vous servir des commentaires, ils sont là pour ça, ou de la page contact (cf. menu a droite) pour un mail.
Le prochain billet traitera du motif Registry ou du motif Factory.

MAO et Acousmatique: Le SCRIME

compuls — Sat, 03 Mar 2007 01:43:00 +0100

Je conseil un petit détour à cette adresse à ceux qui s'intéressent la création musicale par informatique, à la recherche en musique ou à l'acousmatique le site de la SCRIME: http://scrime.labri.fr

Je conseil aussi, bien évidament, le site de l'IRCAM (Institut de Recherche et de Coordination Acoustique et Musicale): http://www.ircam.fr/

PHP: Detection de la langue du visiteur

knoodrake — Wed, 21 Feb 2007 13:46:00 +0100

Comment puis-je détécter la langue du visiteur pour éventuelement le rediriger vers tel ou tel version de mon site ?

Une des variables superglobales de PHP est la variable $_SERVER ( ou $HTTP_SERVER_VARS pour les versions de php anterieures a 4.1 ). Comme c'est une variable super globale, nul besoin de la déclarer d'aucune manière, elle sera accésible n'importe quand et n'importe ou.
Dans cette variable (un tableau en fait) on va trouver les informations contenus dans $_SERVER['HTTP_ACCEPT_LANGUAGE'] , ce qui donne quelque chose comme "fr,fr-fr;q=0.8,en-us;q=0.5,en;q=0.3" (une chaine de caractère).

Donc à partir de la, plusieurs solutions:
De nombreuses bibliothèques peuvent prendre en charge le "décriptage" de cette chaine comme par exemple l'illustre PECL. Voir la fonction http_negociate_language.
Une autre possibilité, moins éfficace mais qui évite d'installer une librairie tièrce, c'est de ranger tout les morceaux de la chaine dans un tableau et de ne prendre en compte que le premier élement (qui est la langue par defaut ) , comme dans l'exemple que je vous propose:

$lang = explode(",",$_SERVER["HTTP_ACCEPT_LANGUAGE"]);
if (($langs[0] == "en" )|($lang[0]=="en-us"))
header("Location: http://monsite.versionAnglaise.com");

Pour information, la detection ainsi qu'une éventuelle redirection peuvent aussi s'éffectuer simplement avec les entêtes html, ou bien encore à l'aide de Javascript.

Enfin, si redirection il y à, il est très important de toujours laisser la possibilité au visiteur de choisir lui-même la version du site qu'il souhaite visiter. Ainsi, pensez à mettre (et bien en évidence) un lien vers le site dans les autres langues disponibles.