Quand on utilise Javascript on utilise forcément node.js qui est devenu incontournable, déjà côté serveur mais aussi pour le développement côté client.
Introduction
Node.js est apparu en 2009. C’est un environnement d’exécution JavaScript construit sur le moteur JavaScript V8 de Chrome qui est basé sur ES6, on peut donc utiliser toutes les innovations de cette version de Javascript.
Pour l’utiliser il faut l’installer, vous trouvez tout ce qu’il faut ici pour le faire. Si vous n’êtes pas trop sûr de l’avoir vérifiez à partir de votre console :
node -v v12.13.1
Quand on installe Node on installe également npm qui est son gestionnaire de modules :
npm -v 6.11.3
Pendant longtemps Javascript s’est cantonné à la dynamisation des pages côté client, avec Node.js on peut maintenant utiliser Javascript aussi côté serveur et envisager ainsi une application web complète totalement écrite en Javascript.
Node.js fonctionne avec une boucle et un thread unique en attendant des événements. Il y a une file d’attente pour le traitement des événements. On pourrait se dire que ça finit par se bousculer dans la file et créer un temps d’attente très long ! En fait Node va déléguer les longues tâches et attendre qu’on lui notifie la fin de l’exécution.
Node fonctionne avec des fichiers Javascript, la première commande à connaître est node. Il suffit d’avoir un fichier Javascript et de le lancer. Donc créez un fichier, par exemple coucou.js avec ce code :
console.log('Coucou Node')
Et dans la console :
node coucou.js Coucou Node
Le suffixe js est optionnel.
Bravo ! Vous avez exécuté votre premier programme avec node !
Les modules
Le code avec Node est organisé en modules, chaque module étant assigné à une tâche particulière. Un module peut ainsi être appelé (require) quand on en a besoin.
Comme rien ne vaut un exemple créez un fichier textes.js avec ce code :
exports.mots = ['un', 'deux', 'trois']
On crée ainsi un module qui exporte (exports) un tableau de mots.
Et un fichier test.js avec ce code :
const monModule = require('./textes.js')
for(const m of monModule.mots) {
console.log(m)
}
Ici on charge (require) le module qu’on a créé juste avant et on traite le tableau. Attention au chemin du module ! Ici avec « ./ » on vise le même dossier que le fichier test.js.
Ensuite lancez avec Node :
node test un deux trois
Allez un autre petit exemple avec ce fichier helpers.js pour un peu généraliser :
const helpers = module.exports = {}
helpers.ajoute = (a, b) => a + b
Et le fichier test.js pour utiliser notre module :
const helpers = require('./helpers.js')
console.log(helpers.ajoute(2, 3)) // 5
Une application Node.js
J’ai dit plus haut qu’on dispose de npm pour gérer les modules.
Une application Node.js doit comporter un fichier package.json à la racine du projet pour définir les propriétés de l’application. C’est là qu’on définit le numéro de version, le nom, le fichier principal…
On va créer une application Node. Créez un dossier et appelez-le par exemple test. dans la console positionnez-vous sur ce dossier et là entrez cette commande et répondez aux questions :
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.
See `npm help json` for definitive documentation on these fields
and exactly what they do.
Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.
Press ^C at any time to quit.
package name: (test)
version: (1.0.0)
description: Ma première application Node
entry point: (index.js) main.js
test command:
git repository:
keywords:
author: moi
license: (ISC)
About to write to E:\nodetest\test\package.json:
{
"name": "test",
"version": "1.0.0",
"description": "Ma première application Node",
"main": "main.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "moi",
"license": "ISC"
}
Is this OK? (yes)
On se retrouve maintenant avec le fichier package.json dans le dossier. On peut maintenant charger des packages avec npm. Sur le site on a une zone de recherche pour les packages :
Ici j’ai fait une recherche pour lodash qui est un célèbre librairie Javascript. On va choisir la première occurrence :
On va l’installer :
npm i --save lodash npm notice created a lockfile as package-lock.json. You should commit this file. npm WARN test@1.0.0 No repository field. + lodash@4.17.15 added 1 package from 2 contributors and audited 1 package in 1.102s found 0 vulnerabilities
Si on regarde maintenant package.json on trouve une dépendance :
{
...
"dependencies": {
"lodash": "^4.17.15"
}
}
D’autre part il y a eu création d’un nouveau dossier dans notre projet :
Tous les packages utilisés vont aller dans ce dossier node_modules.
On va maintenant voir si ça fonctionne en utilisant lodash. Créez un fichier main.js avec ce code :
const _ = require('lodash')
console.log(_.max([4, 2, 8]))
On lance l’application :
node main 8
Ça fonctionne !
Filesystem
Node permet aussi de gérer le système de fichier. Il suffit de charger le module fs qui fait partie du noyau de Node :
const fs = require('fs');
On dispose alors d’une très grande batterie de méthodes.
La plupart des méthodes existent en version synchrone (elles se terminent par sync) ou asynchrones.
Voici comment créer un fichier :
const fs = require('fs')
fs.writeFile('coucou.txt', 'Je sais créer des fichiers !', (err) => {
if(err) throw err
console.log('Le fichier a bien été créé !')
})
node test Le fichier a bien été créé !
Node utilise beaucoup les streams comme méthode de transfert de données. On peut par exemple créer un fichier de cette manière :
const fs = require('fs')
const stream = fs.createWriteStream('coucou.txt')
stream.write('un\n')
stream.write('deux\n')
stream.write('trois\n')
L’avantage de cette approche c’est qu’on peut modifier le stream à la chaîne, par exemple lire un fichier et le compresser :
const fs = require('fs')
const zlib = require('zlib')
const gzip = zlib.createGzip()
const stream = fs.createWriteStream('coucou.gz')
fs.createReadStream('./coucou.txt').pipe(gzip).pipe(stream);
Un serveur web
Voyons à présent la programmation coté serveur. Node propose un module nommé http pour gérer des requêtes web. C’est un module déjà intégré dans Node et on n’a pas besoin de le charger avec npm. Créez un fichier main.js avec ce code :
const http = require('http')
const hostname = '127.0.0.1'
const port = 3000
const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/html')
const message = "<h1>Coucou Node !</h1>"
res.write(message)
res.end()
})
server.listen(port, hostname, () => {
console.log(`Mon serveur ici : http://${hostname}:${port}/`)
})
Lancez l’application :
node main Mon serveur ici : http://127.0.0.1:3000/
Et ouvrez dans un navigateur :
L’argument de la méthode createServer est un callback qui est invoqué quand une requête arrive. L’avantage c’est qu’on a pas besoin d’attendre la fin de traitement pour gérer une nouvelle requête. C’est pour cette raison qu’un serveur avec Node est si rapide.
Ce serveur ne fait pas grand chose mais constitue déjà une base simple et efficace ! je parlerai dans un prochain article d’Express.js qui permet de coder facilement un serveur.
Les bases de données
Node sait tout faire, donc aussi se connecter à une base de données. Faisons un petit essai avec MySQL. Il faut commencer par installer le module :
npm install mysql
Après on peut le charger :
const MySQL = require('mysql')
Créez une base MySQL avec une table pour essayer la connexion. Je vais admettre que j’ai une base test avec une table users qui comporte les champs name et email. Voici un exemple de code :
MySQL = require('mysql')
const connection = MySQL.createConnection({
host: 'localhost',
user: 'root',
password: '',
database: 'test'
})
connection.connect((err) => {
if (err) throw err
console.log("Connecté avec l'id " + connection.threadId)
connection.query('SELECT name,email FROM users', (err, result) =>
{
if (err) throw err
console.log(result)
})
connection.end()
})
node test
Connecté avec l'id 30
[ RowDataPacket { name: 'Dupont', email: 'dupont@la.fr' } ]
Vous voyez que c’est tout simple ! Node sait se connecter à toutes sortes de bases, en particulier MongoDB mais j’en parlerai dans un autre article.
Electron
Node permet aussi de créer des application desktop complète extrêmement performantes, surtout avec Electron. Au départ Electron a servi au développement de l’éditeur Atom mais ensuite de nombreuses application ont été créées, en particulier Visual Studio Code qui est un des mes éditeurs préférés. J’ai écrit une série d’articles pour présenter ce framework mais ils commencent un peu à dater et je devrais les actualiser
Conclusion
Node est très riche et dans cet article je n’ai fait que l’effleurer. Dans le prochain je vous proposerai de voir le module Express.js qui permet de réaliser facilement un serveur.