Redécouvrir JavaScript avec Node.js

JavaScript est un langage créé en 1995 pour le compte du navigateur Netscape. Sa syntaxe a été ouvertement inspirée de Java. Les deux langages étaient d'ailleurs présentés en complément (les sociétés Netscape et Sun Microsystems étant partenaires), ce qui a créé une confusion générale, encore présente aujourd'hui. Disons-le clairement : JavaScript et Java ne sont pas (ou plus) du tout liés. (On entend souvent l'analogie « Java is to JavaScript as ham is to hamster », ou Java est à JavaScript ce que le jambon (ham) est au hamster.)

Depuis, JavaScript a été standardisé par l'organisme ECMA International (le standard a été nommé ECMAScript). C'est un langage qui évolue encore, les versions 1.7 et 1.8, apportant plusieurs nouvelles possibilités, sont progressivement supportées par les navigateurs (et par Node.js !).

JavaScript a connu plusieurs essors. Tout d'abord, il a ajouté aux pages HTML statiques des effets pour les rendre plus dynamiques : des animations au survol d'une image, des textes défilants, etc. Aujourd'hui ces effets (qui avaient été globalement nommés DHTML pour Dynamic _ HTML_) nous semblent un peu vieillots, caractéristiques du web des années 1990-début 2000.

Vers le début des années 2000, JavaScript connaît alors un deuxième essor majeur, avec l'apparition d'une technologie qui révolutionnera la manière dont on utilise Internet : Ajax (Asynchronous JavaScript and XML). Pour faire simple, Ajax consiste à utiliser des possibilités de JavaScript et des navigateurs pourtant présentes depuis fort longtemps pour faire charger des données depuis le serveur sans avoir besoin de recharger la page. Cela paraît simple, pourtant cette avancée a permis de concevoir des applications web tellement réactives qu'elles se sont progressivement substituées aux applications de bureau.

Pour faciliter l'utilisation d'Ajax (et notamment pour gérer les différences d'implémentation entre les navigateurs), plusieurs bibliothèques JavaScript ont vu le jour ; celle qui fait référence aujourd'hui est jQuery (http://jquery.com).

Enfin, on assiste aujourd'hui à une nouvelle avancée majeure de l'utilisation de JavaScript. Alors que jQuery permet de faire des appels Ajax et de manipuler une page HTML très facilement, certains frameworks vont encore plus loin en créant des applications JavaScript complexes et structurées, par exemple en donnant la possibilité d'utiliser une architecture modèle-vue- contrôleur (MVC), avec gestion de modèles (templates). Et pour accompagner cette tendance, cela se passe à la fois :

• côté client : avec des frameworks comme Backbone ou AngularJS ;
• côté serveur : avec Node.js, c'est l'objet de ce livre !

Il est donc désormais possible d'utiliser avec JavaScript des méthodes réservées, il y a peu, aux gros langages comme PHP, Java ou Ruby : architecture MVC, tests unitaires, build, distribution de modules, gestion de dépendances, etc.

Bien que ce livre suppose que vous soyez déjà familier avec JavaScript, il peut être utile de rappeler quelques bases du langage que même les plus expérimentés d'entre nous pourraient avoir oublié. Si vous êtes confiant, rien ne vous empêche de passer au chapitre suivantDécouverte de Node.js !

I-B-1. Les variables▲

var a;
var b = 1;
a = b + 2;

I-B-2. Les types simples▲

a = true;    // booléen
a = 1;       // entier
a = 1.1;     // flottant
a = "Hello"; // chaîne de caractères
a = 'Hello'; // idem

I-B-3. Les tableaux et les objets▲

var t = [ 1, true, 'Hello' ];
var u = t[0]; // u = 1

var o = { prop1: 'Hello', prop2: 'World!' };
var v = o['prop1']; // les deux lignes sont
var v = o.prop1;    // équivalentes

I-B-4. Les fonctions▲

var f = function(i) {
    return i + 1;
};

function f() {
    return i + 1;
}

var o = {
    f: function(i) {
        return i + 1;
    }
};
var a =o.f(1); // a = 2

I-B-5. Mixons le tout▲

var o = {
    t: 1,
    s: [
        'test',
        function(p) {
            return function(q, f, t) {
                u = q + (f(t))(q);
                return { somme: q + p, produit: q * p };
            };
        }
    ]
};

Depuis sa création, JavaScript a naturellement été associé aux sites et applications web, domaine pour lequel il a été créé. Il a permis de rendre les pages web plus dynamiques, en commençant par des animations très flash dans les années 1990/2000 (ce que l'on appelait le DHTML), pour en arriver vers les applications les plus complexes que nous connaissons tous aujourd'hui et qui se substituent aux applications de bureau : webmail avec Gmail, cartographie avec Google Maps, etc.

Mais si JavaScript a été créé plus spécialement pour être exécuté dans un navigateur, il a été standardisé et permet théoriquement d'être utilisé pour tout type d'application, et notamment des programmes autonomes, c'est-à-dire ne nécessitant pas de navigateur web pour s'exécuter. C'est sur cet usage que se base Node.js.

Node.js est constitue d'un programme appelé node permettant d'interpréter du code JavaScript, traditionnellement en ligne de commande. Il est également accompagné d'outils supplémentaires, dont le plus intéressant s'appelle npm, pour Node package manager. Il s'agit d'un gestionnaire de paquets à l'image de yum ou apt (pour les distributions Linux RedHat et Debian/Ubuntu respectivement), sauf que lui permet de récupérer proprement des outils tiers utilisables avec Node.js.

Note : dans la suite du livre, pour faire référence à Node.js, je pourrai également parler simplement de Node.

Node est un outil multiplateforme. Il est possible très facilement de l'utiliser sous Linux, Windows, OS X, etc. Son installation est on ne peut plus simple :

• sous Windows, rendez-vous sur le site officiel de Node (http://nodejs.org) qui à ce jour propose en page d'accueil un lien permettant de télécharger l'installeur ;
• sous Linux ou MacOS, votre gestionnaire de paquets favori permet généralement de trouver le programme node ou nodejs sans problème.

Pour vérifier que l'installation a bien été effectuée, lancez dans un terminal la commande suivante :

$ node --version

Le résultat doit être la version de Node.js installée (v0.10.18 au moment de l'écriture de ce livre).

À présent que tout est en place, passons à l'écriture de notre premier script Node.js !

Pour notre premier script, nous allons créer un petit serveur web. Là vous devez vous dire que c'est ambitieux comme premier exercice, mais c'est parce que vous ne connaissez pas encore Node.js !

II-C-1. Le code du programme▲

var http = require('http');
http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
}).listen(1337, '127.0.0.1');

console.log('Server running at http://127.0.0.1:1337/');

$ node hello.js
Server running at http://127.0.0.1:1337/

II-C-2. Explication détaillée▲

var http = require('http');

http.createServer(function(req,res) { ... }).listen(1337, '127.0.0.1');

var server = http.createServer(function(req,res) { ... });
server.listen(1337, '127.0.0.1');

function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
}

var f1 = function(callback) {
    console.log("Première fonction...");
    callback("test");
};
var f2 = function(resultat) {
    console.log("Résultat : " +resultat);
}

f1(f2);
// Sortie :
// Première fonction...
// Résultat : test

console.log('Server running at http://127.0.0.1:1337/');

II-C-3. En résumé▲

Dans cette partie nous allons raffiner le petit serveur web créé précédemment en ajoutant quelques fonctionnalités. Nous allons imaginer une application très simple, demandant à l'utilisateur son prénom, pour le saluer personnellement ensuite. Il ne s'agit pas ici de vendre ce concept révolutionnaire aux grands noms du web, mais d'illustrer plusieurs fonctionnalités offertes par Node.js :

• récupérer et utiliser les paramètres GET passés à la requête ;
• lire un fichier HTML local et le renvoyer au navigateur ;
• renvoyer du contenu structuré en JSON.

Notre application se constituera d'un formulaire contenant un champ invitant l'utilisateur à saisir son nom. Un clic sur le bouton OK lancera un appel AJAX, qui recevra en réponse un message adapté au nom de l'utilisateur. Le message sera affiché sur la page.

II-D-1. Une page HTML▲

<input type="text" placeholder="Enter your name" id="name"/>
<input type="button" value="OK" onclick="valid()"/>
<div id="message"></div>
<script src="http://code.jquery.com/jquery-1.10.1.min.js"></script>
<script>
function valid() {
    $.get('', { name: $('#name').val() }, function(data) {
        $('#message').html(data.message);
    }, 'json');
}
</script>

II-D-2. Le script Node.js▲

var http = require('http');
var url = require('url');
var fs = require('fs');

var server = http.createServer(function (req, res) {
    var url_parts = url.parse(req.url, true);
    var name = url_parts.query.name;
    if (name) {
        console.log('Name: ' +name);
        res.writeHead(200, {'Content-Type': 'application/json'});
        res.end(JSON.stringify({message: 'Hello ' +name + '!'}));
    } else {
        console.log('No name!');
        res.writeHead(200, {'Content-Type': 'text/html'});
        fs.readFile('hello02.html',function (err,data) {
            res.end(data);
        });
    }
}).listen(1337, '127.0.0.1');

console.log('Server running at http://127.0.0.1:1337/');

var http = require('http');
var url = require('url');
var fs = require('fs');

var url_parts = url.parse(req.url, true);
var name = url_parts.query.name;
if (name) {
    ...
} else {
    ...
}

console.log('No name!');
res.writeHead(200, {'Content-Type': 'text/html'});
fs.readFile('hello02.html', function (err,data) {
    res.end(data);
});

console.log('Name: ' + name);
res.writeHead(200, {'Content-Type': 'application/json'});
res.end(JSON.stringify({message: 'Hello ' + name + '!'}));

II-D-3. En résumé▲

Contrairement à http ou url que nous avons utilisés précédemment, Express (qui se constitue principalement du module express) ne fait pas partie de la distribution de base de Node.js. Pour l'inclure dans notre application, il suffit de suivre la procédure suivante :

• se rendre en ligne de commande dans le répertoire de notre application (répertoire vierge ou répertoire utilisé pour les exemples précédents) ;
• utiliser le gestionnaire de paquets de Node.js npm grâce à la commande : npm install express.

La commande va télécharger le module express ainsi que tous les modules dont il dépend (et ils sont nombreux). Si tout se passe bien, vous devez remarquer l'apparition d'un répertoire « nodemodules_ » dans votre répertoire courant.

Note sur les modules : vous le comprendrez rapidement, la philosophie des modules de Node est un module = une utilité. Autrement dit, un module n'accomplit en général qu'une tâche précise. C'est l'utilisation conjointe de plusieurs modules qui permet de générer des applications (ou modules) plus complexes.

Afin d'en découvrir le fonctionnement de base, je vous propose de reprendre notre application révolutionnaire du chapitre précédentUn exemple plus complexe…, celle qui demande son nom à l'utilisateur pour le saluer ensuite.

Voici pour rappel le code principal de l'application telle que nous l'avons écrit :

var url_parts = url.parse(req.url, true);
var name = url_parts.query.name;
if (name) {
    res.writeHead(200, {'Content-Type': 'application/json'});
    res.end(JSON.stringify({message: 'Hello ' +name + '!'}));
} else {
    res.writeHead(200, {'Content-Type': 'text/html'});
    fs.readFile('hello02.html', function (err,data) {
        res.end(data);
    });
}

On voit que les différents cas de figure qui peuvent se présenter sont distingués par un if. Ici nous n'en avons que deux, mais si nous devions traiter dix types de requêtes différents, le programme deviendrait vite illisible… C'est alors que l'usage d'un routeur va nous simplifier la vie.

Plongeons au cœur du sujet, voici le code de la version de notre programme utilisant Express :

var express =require('express');
var fs = require('fs');
var app = express();

app.get('/',function(req, res) {
    res.writeHead(200, {'Content-Type': 'text/html'});
    fs.readFile('express01.html', function (err,data) {
        res.end(data);
    });
});

app.get('/hello/:name', function(req,res) {
    res.writeHead(200, {'Content-Type': 'application/json'});
    res.end(JSON.stringify({message: 'Hello ' + req.params.name + '!'}));
});

app.listen(8080);

À première vue, et même sans connaître le fonctionnement d'Express, le code semble déjà plus « aéré ».

var express = require('express');
var fs = require('fs');
var app = express();

On inclut comme d'habitude les modules que l'on va utiliser. Nous avons déjà vu le module fs permettant de lire un fichier ; le module express s'inclut de la même manière pour créer la fonction express() qui sert à créer notre application app. Cette application est l'objet global que nous utiliserons pour configurer les actions à effectuer en fonction de la requête.

app.get('/', function(req, res){
    res.writeHead(200, {'Content-Type': 'text/html'});
    fs.readFile('express01.html', function (err,data) {
        res.end(data);
    });
});

La méthode get de l'objet app nous permet ici de définir le comportement lorsque c'est l'URL http://localhost:8080/ qui est appelée, autrement dit la racine (/) de notre site. Le contenu de la fonction qu'elle prend en deuxième paramètre est strictement identique à celui vu au chapitre précédent : on lit le fichier express01.html et on le renvoie.

app.get('/hello/:name', function(req,res) {
    res.writeHead(200, {'Content-Type': 'application/json'});
    res.end(JSON.stringify({message: 'Hello ' + req.params.name + '!'}));
});

Le deuxième cas de figure est plus intéressant. On gère ici le cas où l'URL est de la forme /hello/:name. La partie :name correspond ici à un paramètre, c'est-à-dire a une valeur qui pourra être remplacée par n'importe quoi. Par exemple, si l'on appelle l'URL http://localhost:8080/hello/Jean, c'est cette fonction qui sera utilisée.

Le plus intéressant avec ce paramètre est évidemment qu'il est possible de récupérer sa valeur. C'est ce qui est fait lorsque l'on renvoie le contenu en JSON, via req.params.name. C'est tout de même beaucoup plus simple que de récupérer l'URL, de la décomposer avec le module url, et d'adapter le comportement en fonction de la présence ou non du paramètre name !

Voici le code du fichier express01.html, qui ressemble à l'exemple du chapitre précédent :

<input type="text" placeholder="Enter your name" id="name"/>
<input type="button" value="OK" onclick="valid()"/>
<div id="message"></div>
<script src="http://code.jquery.com/jquery-1.10.1.min.js"></script>
<script>
function valid() {
    $.getJSON('/hello/' + $('#name').val())
        .done(function(data) {
            $('#message').html(data.message);
        });
}
</script>

Bien évidemment, les fonctionnalités proposées par Express vont bien au-delà de cela, continuons notre exploration avec une fonction dont tout webmaster un minimum rigoureux a besoin : les templates.

Si vous avez déjà développé un site web, vous connaissez sans doute le principe des templates. Le but est d'écrire la vue (traditionnellement du HTML) séparément du code métier. Dans l'idéal, un webdesigner ne connaissant pas du tout le code métier (qu'il soit JavaScript, PHP, Ruby…) doit être capable d'écrire le template.

Concrètement, un langage de templates se caractérise par deux fonctions principales :

• la substitution de variables : remplacer, par exemple « Bonjour #{name} » par « Bonjour Jean » si la variable name vaut « Jean » ;
• l'utilisation de structures conditionnelles et de boucles, dépendant notamment des variables données en paramètre.

Les moteurs de templates les plus avancés proposent des fonctions bien plus évoluées comme l'application de fonctions aux valeurs affichées, de l'héritage de templates, etc.

Il existe plusieurs moteurs de templates utilisables avec Node.js ; j'ai choisi de vous présenter Jade, d'une part parce qu'Express permet de l'utiliser très facilement, et d'autre part parce qu'il dispose d'une syntaxe un peu particulière mais très efficace.

III-C-1. Présentation du moteur de templates Jade▲

doctype html
html
    head
        title= title
    body
        div Choisir un prénom :
        - for name in names  
            label
                input(type="radio",name="name",value=name)
                span Prénom : #{name}
            br
        div
            input(type="button",onclick="valid()",value="OK")
            #message
        script(src="http://code.jquery.com/jquery-1.10.1.min.js")
        script.
            function valid() {
                $.get('/hello/' + $('[name=name]:checked').val(), function(data) {
                    $('#message').html(data.message);
                }, 'json');
            }

doctype html

html
    head
        title= title

body
    div Choisir un prénom :

- for name in names  
    label
        input(type="radio",name="name",value=name)
        span Prénom : #{name}
    br

script(src="http://code.jquery.com/jquery-1.10.1.min.js")
script.
    function valid() {
        $.get('/hello/' + $('[name=name]:checked').val(), function(data) {
            $('#message').html(data.message);
        }, 'json');
    }

III-C-2. Utiliser Jade avec Express▲

$ npm install jade

var express = require('express');
var fs = require('fs');
var app = express();

app.set('view engine', 'jade');
app.set('views', __dirname);

app.get('/', function (req, res) {
  res.render('express02', { title: 'Hello', names: [ 'Pierre', 'Paul', 'Jacques' ] });
});

app.get('/hello/:name', function (req, res) {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ message: 'Hello ' + req.params.name + '!' }));
});

app.listen(8080);

app.set('view engine', 'jade');
app.set('views', __dirname);

res.render('express02', { title: 'Hello', names: [ 'Pierre', 'Paul', 'Jacques' ] });

Nous avons vu dans les parties précédentes comment créer une application minimaliste avec Express. Mais que se passe-t-il lorsque votre application (ou site) est composée de plusieurs pages, par exemple ? Il est alors nécessaire d'organiser les sources de manière à ce que l'ensemble reste lisible et maintenable. Pour cela, Express peut nous rendre service en créant automatiquement une belle arborescence. Cela nous fait gagner du temps, mais permet surtout de comprendre les bonnes pratiques concernant l'organisation d'une application constituée de plusieurs scripts, templates, etc.

Pour cela, il est d'abord nécessaire d'installer le module express, mais de manière globale, c'est-à-dire de sorte à rendre ce module utilisable par n'importe quelle application Node.js sur le système, et non juste pour l'application du répertoire courant. Cela se fait par la commande :

npm install -g express

En tapant ensuite la commande express, vous pourrez vérifier si le module a bien été installé.

Pour créer ensuite un projet Express, rendez-vous en ligne de commande dans le répertoire parent qui accueillera votre répertoire projet, puis tapez la commande :

express express03

(express03 est ici le nom à donner au projet). Express a donc créé un répertoire express03, dont l'arborescence contient des sources et plusieurs répertoires :

• public/ : contient les fichiers 'ressources' de l'application web : CSS, JavaScript client, images, etc. ;
• routes/ : contient les routes, c'est-à-dire les sous-modules de notre application ;
• views/ : contient les vues de notre application, c'est-à-dire les modèles Jade ;
• app.js : le point d'entrée de l'application ;
• package.json : fichier contenant les métadonnées de l'application, les dépendances, etc.

Premier fichier intéressant, le fichier package.json.

{
    "name": "application-name",
    "version": "0.0.1",
    "private": true,
    "scripts": {
        "start": "node app.js"
    },
    "dependencies": {
        "express": "3.4.0",
        "jade": "*"
    }
}

Il permet d'y placer les métadonnées concernant notre application : le nom, l'auteur, la version, etc. Cela peut être très utile si vous décidez de distribuer votre application. Mais ces données ne servent pas « qu'à faire joli » : le bloc dependencies permet d'indiquer les dépendances de votre application, autrement dit les modules requis pour la faire fonctionner. Ici, nous avons besoin du module express en version 3.4.0, et du module jade, dans la dernière version disponible.

Afin d'installer automatiquement les dépendances de l'application en se basant sur les informations du package.json, tapez la commande :

$ npm install

Nous reviendrons en détail sur les possibilités offertes par ce fichier dans le chapitre 5Créez et diffusez vos modules.

Analysons à présent le contenu du fichier principal : app.js.

var express = require('express');
var routes = require('./routes');
var user = require('./routes/user');
var http = require('http');
var path = require('path');

var app = express();
app.set('port', process.env.PORT || 3000);
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
app.use(express.static(path.join(__dirname, 'public')));

app.get('/', routes.index);
app.get('/users', user.list);

http.createServer(app).listen(app.get('port'), function() {
    console.log('Express server listening on port ' + app.get('port'));
});

J'ai volontairement retiré quelques lignes du fichier afin de faciliter l'explication. Globalement peu de nouveautés dans ce fichier. On initialise un objet application (app) dont on configure le port à écouter (app.set('port',...)), le moteur de templates (Jade) ainsi que le répertoire où ces templates sont stockés (le sous-répertoire views), et enfin le répertoire des ressources « statiques » (le sous-répertoire public).

Les trois dernières lignes sont une méthode un peu différente de lancer le serveur par rapport à ce que nous avions vu, mais cela revient globalement au même.

La nouveauté réside ici dans les lignes suivantes :

var routes = require('./routes');
var user = require('./routes/user');

app.get('/',routes.index);
app.get('/users',user.list);

En réalité, nous ne faisons qu'appeler la fonction get comme nous le faisions déjà, mais plutôt que de lui donner la fonction directement lors de l'appel, nous lui donnons une référence vers la fonction déclarée ailleurs. Les fonctions routes.index et user.list sont définies respectivement dans les fichiers routes/index.js et routes/user.js.

La syntaxe permettant d'inclure des fichiers comme cela est fait ci-dessous sera détaillée dans le chapitre 5Créez et diffusez vos modules consacré à la création de modules. Le contenu des fichiers inclus est très simple :

// routes/index.js
exports.index = function(req, res){
    res.render('index', { title: 'Express' });
};

// routes/user.js
exports.list = function(req, res){
    res.send("respond with a resource");
};

Dans le premier cas, nous appelons le modèle index (situé dans _views/index.jade), et dans le deuxième nous renvoyons un message texte.

La nouveauté dans cette application réside dans le modèle index.jade :

extends layout

block content
    h1= title
    p Welcome to #{title}

Pas de structure HTML classique ici, seulement deux instructions principales :

• extends layout : on déclare que notre modèle index hérite en quelques sortes du modèle layout. Autrement dit, la page sera basée sur le modèle layout ;
• block content : partant du template layout, on remplira le bloc "content" par le contenu inscrit ici (un titre h1 et une ligne de texte p).

Si l'on observe le template layout, on remarque la présence du bloc content (block content) : c'est lui qui sera rempli avec le code contenu dans index.jade :

doctype 5
html
    head
        title= title
        link(rel='stylesheet',href='/stylesheets/style.css')
    body
        block content

Nous aurions pu regrouper le tout dans un seul fichier sans faire appel aux blocks de Jade en plaçant le h1 et le p directement dans la balise body ; l'intérêt est que lorsqu'on a plusieurs pages, on peut utiliser le même layout, c'est-à-dire la même architecture, le même design, le même en-tête, etc. de page.

Afin de mettre en pratique ce que nous venons de voir, je vous propose l'exercice suivant :

• reprendre l'exemple que nous venons de voir ;
• ajouter une page accessible à l'adresse /hello et ayant en commun avec la page d'accueil une barre de menu contenant deux liens : un vers la page d'accueil et un vers la nouvelle page ;
• sur la nouvelle page, ajouter le formulaire que nous avons vu au début du chapitre demandant son nom à l'utilisateur ;
• au clic sur le bouton OK du formulaire, l'application effectuera un appel AJAX à l'URL /hello/sayHello/?name=LePrenomSaisi qui renverra au format JSON un message de salutation, qui sera affiché sur la page.

Nous avons vu dans ce chapitre comment créer une application web bien structurée. Encore une fois, l'objectif d'Express (et de Node en général) n'est pas de concurrencer des frameworks comme Symfony ou Ruby on Rails, qui seront beaucoup plus adaptés pour créer des applications complexes.

Express se montrera en revanche parfaitement adapté pour créer une application proposant des webservices REST, ou encore un petit site vitrine disposant de quelques fonctionnalités dynamiques (formulaire de contact, catalogue de produits, etc.).

L'un des avantages d'Express est qu'il permet de s'adapter à plusieurs modules de gestion de templates, mais aussi à des modules de test unitaire ou test web, d'accès à des bases de données, etc. Et il faut bien le reconnaître, sa mise en place est tout de même beaucoup plus facile que celle de Symfony !

IV-A-1. Présentation▲

IV-A-2. Premier exemple▲

var sqlite3 = require('sqlite3');

var db = new sqlite3.Database(':memory:');

db.serialize(function() {
    db.run("create table users (login, name)");

    var stmt = db.prepare("insert into users values (?, ?)");
    var users = [ { login: 'pierre',  name: 'Pierre' },
                  { login: 'paul',    name: 'Paul' },
                  { login: 'jacques', name: 'Jacques' } ];

    for (var i in users) {
        stmt.run(users[i].login, users[i].name);
    }

    db.each("select login, name from users", function(err, row) {
        console.log(row.login + ": " + row.name);
    });
});

var db = new sqlite3.Database(':memory:');

db.serialize(function() {
    ...
});

db.run("create table users (login, name)");

var stmt = db.prepare("insert into users values (?, ?)");
var users = [ { login: 'pierre',  name: 'Pierre' },
              { login: 'paul',    name: 'Paul' },
              { login: 'jacques', name: 'Jacques' } ];

for (var i in users) {
    stmt.run(users[i].login,users[i].name);
}

db.each("select login, name from users", function(err, row) {
    console.log(row.login + ": " + row.name);
});

$ node sqlite01.js
pierre: Pierre
paul: Paul
jacques: Jacques

IV-A-3. Deuxième exemple▲

var sqlite3 = require('sqlite3');
var db = new sqlite3.Database('sqlite02.db');

db.serialize(function() {
    db.run("create table if not exists log (date)");
    db.all("select date from log", function(err, rows) {
        if( rows.length == 0 )
        {
            console.log("Première exécution !");
        }
        else
        {
            for( var i in rows )
            {
                console.log(rows[i].date);
            }
        }
    });

    var date = new Date().toLocaleString();
    var stmt = db.prepare("insert into log values (?)");
    stmt.run(date);
});

$ node sqlite02.js
Première exécution !

$ node sqlite02.js
Fri Sep 13 2013 13:10:40 GMT+0200 (Paris, Madrid (heure d′été))

$ node sqlite02.js
Fri Sep 13 2013 13:10:40 GMT+0200 (Paris, Madrid (heure d′été))
Fri Sep 13 2013 13:10:55 GMT+0200 (Paris, Madrid (heure d′été))

IV-A-4. Aller plus loin avec un ORM▲

var User = sequelize.define('User', {
    login: { type: Sequelize.STRING, primaryKey: true },
    name:Sequelize.STRING
});

User.sync();

User.find('pierre').success(function(user) {
    console.log(user.values.name);
});

MongoDB se distingue des systèmes de gestion de base de données traditionnels par le type d'objets qu'il peut stocker et sa manière de les stocker. Ici pas de tables et de relations (comme des clés étrangères). Vous stockez des objets constitués de propriétés, dont les valeurs peuvent être d'autres objets. Cela vous rappelle quelque chose ? Oui, c'est ouvertement inspiré des objets JavaScript auxquels vous devez commencer à être habitués !

IV-B-1. Le shell de MongoDB▲

> use mabase;
switched to db mabase

> db
mabase

> db.utilisateurs.save({ nom: 'Pierre', adresse: { voie: 'Avenue des Rues',
ville: 'Rennes' } });

> db.utilisateurs.save({ nom: 'Jacques', adresse: { voie: 'Rue des Avenues',
ville: 'Paris' } });

> db.utilisateurs.save({ nom: 'Paul' });

> db.utilisateurs.find();
{ "_id" : ObjectId("5238b1c15fe1afba9cec2027"), "nom" : "Pierre", "adresse" : { "voie" : "Avenue des Rues", "ville" : "Rennes" } }
{ "_id" : ObjectId("5238b1c95fe1afba9cec2028"), "nom" : "Jacques", "adresse" : { "voie" : "Rue des Avenues", "ville" : "Paris" } }
{ "_id" : ObjectId("5238b1d05fe1afba9cec2029"), "nom" : "Paul" }

> db.utilisateurs.find({ nom: 'Pierre' });
{ "_id" : ObjectId("5238b1c15fe1afba9cec2027"), "nom" : "Pierre", "adresse" : { "voie" : "Avenue des Rues", "ville" : "Rennes" } }

> db.utilisateurs.find({ 'adresse.ville': 'Paris' });
{ "_id" : ObjectId("5238b1c95fe1afba9cec2028"), "nom" : "Jacques", "adresse" : { "voie" : "Rue des Avenues", "ville" : "Paris" } }

> db.utilisateurs.update( { nom: 'Paul' }, { nom: 'Paul', nb: 3 } );

> db.utilisateurs.find( { nom: 'Paul' } );
{ "_id" :ObjectId("5238b1d05fe1afba9cec2029"), "nom" : "Paul", "nb" : 3 }

IV-B-2. MongoDB avec Node.js : Mongoose▲

var mongoose = require('mongoose');

// 1- Déclaration du modèle
var utilisateurSchema = mongoose.Schema({
    nom: String,
    nb: Number,
    adresse: {
        voie: String,
        ville: String
    }
});
utilisateurSchema.methods.hello = function() {
    console.log("Bonjour, je m'appelle " +this.nom + " !");
};
var Utilisateur = mongoose.model('utilisateurs', utilisateurSchema);

// 2- Opérations sur les données
var db = mongoose.connection;
db.once('open', function() {
    var pierre = new Utilisateur({
        nom: 'Pierre',
        adresse: {
            voie: 'Avenue des Rues',
            ville: 'Rennes'
        }
    });
    pierre.save(function(err, utilisateur) {
        utilisateur.hello();
        mongoose.disconnect();
    });
});

mongoose.connect('mongodb://localhost/mabase2');

$ node mongoose01.js
Bonjour, je m′appelle Pierre !

IV-B-3. Conclusion sur MongoDB▲

Notre module, que j'ai choisi d'appeler sobrement google-geocoding, disposera d'une seule méthode : geocode. Celle-ci prendra deux paramètres :

• l'adresse dont on souhaite avoir les coordonnées ;
• la fonction à appeler une fois l'appel effectué, elle-même prenant deux paramètres :
• l'erreur éventuelle en cas de problème d'appel à l'API (null sinon) ;
• le résultat du geocoding sous forme d'objet { lat: 48.1091828,lng : -1.6839106 }, ou null si Google n'a pas trouvé notre adresse.

Voici un exemple d'utilisation de notre futur module :

var google_geocoding = require('./google-geocoding');

google_geocoding.geocode('Place de Bretagne, Rennes', function(err, location) {
    if( err ) {
        console.log('Erreur : ' + err);
    } else if( !location ) {
        console.log('Aucun résultat.');
    } else {
        console.log('Latitude : ' + location.lat + ' ; Longitude : ' + location.lng);
    }
});

Si vous exécutez ce code, vous obtiendrez naturellement une erreur : notre module n'existe pas encore. Notez que l'instruction require fait appel au module par ./google-geocoding, car le module se situera dans le fichier google-geocoding.js situé dans le même répertoire.

Créons ce fichier avec le contenu suivant :

module.exports.geocode = function(address, callback) {
    callback('Not implemented', null);
};

Il ne fait rien pour l'instant, mais cela va nous permettre de l'utiliser sans avoir d'exception déclenchée par Node.

Et là, vous cherchez si vous n'avez pas oublié de lire un chapitre. Et bien non : nous allons bien tester notre module google-geocoding avant même de l'écrire. En réalité, nous n'allons qu'écrire les tests unitaires, autrement dit nous allons appliquer la méthode bien connue et très en vogue de développement des TDD, pour test-driven development. Le principe est simple : écrire les tests en fonction des spécifications et non du code testé. Idéalement, ces tests sont mêmes écrits par un autre développeur que celui écrivant le code testé.

Entrons dans le vif du sujet : Mocha. Il s'agit d'un module (qui s'installe avec npm install -g mocha) permettant de réaliser très simplement des tests unitaires sur du code JavaScript, et plus particulièrement avec Node.js. En complément de Mocha, nous utiliserons également le module Should (npm install should) facilitant l'écriture des tests unitaires.

Une fois le module Mocha installé, la commande mocha peut être exécutée en ligne de commande afin de lancer les tests. Par défaut, Mocha va chercher les tests dans le fichier test/test.js. Créons donc ce fichier, avec le contenu suivant :

var should = require('should');
var google_geocoding = require('../google-geocoding');

describe('Google geocoding', function() {
    describe('#geocode()', function() {
        it('should return null on incorrect address', function(done) {
            google_geocoding.geocode('tototititutu', function(err, location) {
                should.not.exist(err);
                should.not.exist(location);
                done();
            });
        });

        it('should return non null on correct address', function(done){
            google_geocoding.geocode('Place de Bretagne, Rennes', function(err, location) {
                should.not.exist(err);
                location.should.have.property('lat');
                location.should.have.property('lng');
                done();
            });
        });
    });
});

Mocha permet d'écrire les tests avec une syntaxe très intuitive (tout en restant du vrai code JavaScript) au moyen de fonctions comme describe ou it. Ces deux fonctions ne servent qu'à organiser les tests. Ici, comme nous n'avons qu'une seule méthode à tester, l'organisation reste relativement simple.

Nous déclarons ici deux cas de test : un pour une adresse incorrecte (auquel cas notre méthode geocode ne renvoie pas d'erreur et un résultat null) et un pour une adresse correcte.

Le module should nous permet d'écrire des assertions, comme « location doit avoir une propriété lat ». Cela s'écrit : location.should.have.property('lat');. Facile non ?

Pour déclarer qu'un objet (ici err) doit être nul, on utilisera should.not.exist(err). On ne peut pas utiliser la syntaxe err.should.not.exist,car par définition si err est nul, alors il ne peut pas disposer de la propriété should.

À présent lançons nos tests ! Dans le répertoire du module, tapez la commande mocha -R spec et observez le résultat : l'option -R spec ne sert qu'à avoir un affichage plus détaillé.

$ mocha -R spec

Google geocoding
#geocode()
    1) should return null on incorrect address
    2) should return non null on correct address

0 passing (8ms)
2 failing

(...)

Sans surprise, les tests ne passent pas. Notez tout de même que l'affichage généré par Mocha rend le résultat facilement compréhensible, avec le détail et la trace de chaque erreur (que je n'ai pas reproduits ici).

Maintenant que notre module est testable, il est temps d'en écrire le contenu.

Voici le code de notre module, à placer dans notre fichier google-geocoding.js :

var http = require("http");

module.exports.geocode = function(address, callback) {
    var url = "http://maps.googleapis.com/maps/api/geocode/json?address="
        + encodeURIComponent(address) + "&sensor=false";
    http.get(url, function(res) {
        if( res.statusCode != 200 ) {
            callback("Statut HTTP = " + res.statusCode, null);
        } else {
            var output = '';
            res.setEncoding('utf8');

            res.on('data', function (chunk) {
                output += chunk;
            });

            res.on('end', function() {
                var response =JSON.parse(output);
                if(response.status == "OK" ) {
                    var location =response.results[0].geometry.location;
                    callback(null, location);
                } else if(response.status == "ZERO_RESULTS" ) {
                    callback(null, null);
                } else {
                    callback("Status = " +response.status, null);
                }
            });
        }
    }).on('error', function(e) {
        callback(e.message, null);
    });
};

Rien de vraiment nouveau ici par rapport à ce que nous avons vu. Notez l'utilisation de la méthode get du module http, qui permet non pas de créer un serveur, mais de lancer une requête HTTP GET sur un serveur, ici le serveur de l'API Google. La particularité ici est qu'on lit le retour de cet appel par morceaux (chunks), grâce à res.on('data',...) et res.on('end',...).

Pour déclarer une méthode publique du module, on utilise l'objet module et sa propriété exports. Ainsi nous pourrions créer le module suivant :

var f = function() { ... };
var g = function() { ... f(); ... }

module.exports = {
    super_methode: function() { ... g(); ... }
};

La fonction g utilise la fonction f, et nous rendons une méthode publique, super_methode qui fait appel à g. Mais si nous utilisons notre module, nous ne pourrons utiliser ni f ni g, car celles-ci n'ont pas été exportées.

À présent, si nous exécutons à nouveau notre petit script d'exemple, nous obtenons l'affichage suivant :

$ node app.js
Latitude : 48.1091828 ; Longitude : -1.6839106

Et si nous lançons notre test avec mocha -R :

D:\Documents\nodejs\google_geocoding>mocha -R spec

Google geocoding
#geocode()
    V should return null on incorrect address (118ms)
    V should return non null on correct address (119ms)

2 passing (251ms)

Miracle, notre module vient de passer les tests unitaires avec succès !

Maintenant que nous sommes fiers de notre module, nous pouvons le diffuser afin qu'il soit utilisable par d'autres personnes, en utilisant le gestionnaire de paquets npm.

Pour cela, il est nécessaire d'effectuer quelques modifications. Tout d'abord, nous allons créer le fichier qui décrit notre module, le fichier package.json. Celui-ci contient les informations de base (nom, auteur…), mais aussi les modules requis par son installation.

Voici un exemple de package.json pour notre module :

{
    "author": "Votre nom <votre.email@example.com>",
    "name": "google-geocoding",
    "description": "Small Node module to use Google Geocoding API.",
    "version": "0.1.1",
    "repository": {
        "url": ""
    },
    "keywords": [
        "google",
        "geocoding",
        "latitude",
        "longitude",
        "coordinates"
    ],
    "main": "",
    "dependencies": {},
    "devDependencies": {
        "mocha": "*"
    },
    "optionalDependencies": {},
    "engines": {
        "node": "*"
    },
    "scripts": {
        "test": "mocha -R spec"
    }
}

De nombreuses options sont disponibles pour ce fichier ; je vous encourage à aller faire un tour du côté de la documentation (https://npmjs.org/doc/json.html) pour voir toutes les possibilités.

Nous avons également besoin d'un fichier README ; même si cela n'est pas forcément requis, cela est fortement conseillé pour les utilisateurs qui souhaiteraient utiliser notre module. Il décrit typiquement au moins la procédure d'installation et un exemple d'utilisation.

google-geocoding
=====================

This module allows you to use [Google geocoding
API](https://developers.google.com/maps/documentation/geocoding/) to get the
coordinates of a specific location.

Installation
------------  

npm install google-geocoding

Example
-------  

```javascript
var google_geocoding = require('google-geocoding');
google_geocoding.geocode('Place de Bretagne, Rennes, France', function(err, location) {
    if( err ) {
        console.log('Error: ' + err);
    } else if( !location ) {
        console.log('No result.');
    } else {
        console.log('Latitude: ' +location.lat + ' ; Longitude: ' +location.lng);
    }
});
```

Le plus simple pour le README est d'utiliser le format Markdown (http://fr.wikipedia.org/wiki/Markdown), très en vogue actuellement et s'affichant très bien sur npmjs.org où notre module sera disponible. Appelons donc le fichier README.md.

Par ailleurs, modifions le fichier de test test/test.js afin que le la ligne require de notre module devienne :

var google_geocoding = require('google-geocoding');

Je reviendrai un peu plus bas sur l'intérêt de cette modification.

La dernière manipulation à effectuer consiste à nettoyer un peu le contenu du répertoire du module. Commencez par supprimer (ou déplacer ailleurs) les fichiers autres que google-geocoding.js et test/test.js (et évidemment les fichiers README.md et package.json que nous venons de créer). Puis renommez le fichier google-geocoding.js en index.js ; ainsi il sera considéré comme le fichier par défaut du module, c'est lui qui sera appelé lorsque l'on écrira require('google-geocoding').

Nous obtenons donc l'arborescence suivante :

• test/

  • test.js
• README.md
• package.json
• index.js

Notre module est maintenant prêt à être diffusé. Tout d'abord, il est nécessaire de se créer un compte sur les dépôts de npm. Cela se fait à l'adresse http://npmjs.org/.

Deux commandes suffisent ensuite à rendre notre module public :

$ npm adduser
Username: <saisir votre login npmjs.org>
Password: <saisir votre mot de passe>
Email: <saisir votre e-mail>
npm http PUT https://registry.npmjs.org/-/user/org.couchdb.user:votrelogin
npm http 201 https://registry.npmjs.org/-/user/org.couchdb.user:votrelogin

$ npm publish
npm http PUT https://registry.npmjs.org/google-geocoding
npm http 201 https://registry.npmjs.org/google-geocoding
npm http GET https://registry.npmjs.org/google-geocoding
npm http 200 https://registry.npmjs.org/google-geocoding
npm http PUT https://registry.npmjs.org/google-geocoding/-/google-
geocoding-0.1.1.tgz/-rev/1-08931f6eef42fb88dc95f6dfc8f30b81
npm http 201 https://registry.npmjs.org/google-geocoding/-/google-
geocoding-0.1.1.tgz/-rev/1-08931f6eef42fb88dc95f6dfc8f30b81
npm http PUT https://registry.npmjs.org/google-geocoding/0.1.1/-tag/latest
npm http 201 https://registry.npmjs.org/google-geocoding/0.1.1/-tag/latest
+ google-geocoding@0.1.1

Et voilà, le module est diffusé. Vous pourrez constater sa présence en vous rendant sur la page de votre compte sur http://npmjs.org (quelques minutes sont parfois nécessaires pour le voir apparaître).

Pour tester l'installation, il nous suffit de reprendre le script d'exemple vu précédemment, en pensant à utiliser require('google-geocoding') et non require('./google-geocoding') :

var google_geocoding = require('google-geocoding');

google_geocoding.geocode('Place de Bretagne, Rennes',function(err, location) {
    if( err ) {
        console.log('Erreur : ' +err);
    } else if( !location ) {
        console.log('Aucun résultat.');
    } else {
        console.log('Latitude : ' +location.lat + ' ; Longitude : ' +location.lng);
    }
});

Penser à installer le module google-geocoding avant de lancer le programme :

$ npm install google-geocoding
npm http GET https://registry.npmjs.org/google-geocoding
npm http 200 https://registry.npmjs.org/google-geocoding
google-geocoding@0.1.1node_modules\google-geocoding

$ node test-geocoding.js
Latitude : 48.1091828 ; Longitude : -1.6839106

Il nous reste une dernière chose à tester. Nous avions créé un petit script permettant de tester unitairement notre module. Et bien npm peut lancer les tests pour nous. En effet nous avons indiqué dans le package.json :

"scripts": {
    "test": "mocha -R spec"
}

Cette option indique à npm qu'il peut lancer les tests en exécutant la commande mocha. À présent, si nous lançons la commande npm test google-geocoding, npm va exécuter la commande mocha sur notre module fraîchement installé.

$ npm test google-geocoding
> google-geocoding@0.1.1 test D:\Documents\nodejs\node_modules\google-
geocoding
> mocha -R spec

Google geocoding
#geocode()
    V should return null on incorrect address (188ms)
    V should return non null on correct address (133ms)

2 passing (332ms)

Les modules sont incontestablement l'une des plus grandes forces de NodeJS. De la même manière que le monde du logiciel libre, Node a progressé grâce à tout l'écosystème qui lui gravite autour, grâce à la simplicité pour créer des modules supplémentaires et les diffuser.

Avant de vous lancer dans le développement d'un nouveau module, cherchez s'il n'en existe pas déjà un qui accomplit ce que vous souhaitez. Peut-être en trouverez-vous un qui s'en approche, et s'il est sous licence libre, il pourra être très intéressant et très formateur de le faire évoluer à votre convenance. npmjs.org et GitHub (http://github.com) sont parfaitement adaptés pour ça !