Explication détaillée d'Express.JS usage_node.js

Après avoir installé node (téléchargement), créez un répertoire sur votre machine et démarrez votre première application.

$ mkdir hello-world

Dans ce répertoire, vous définirez des "packages" d'application, qui ne sont pas différents des autres packages de nœuds. Le fichier json dans le répertoire de fichiers définit clairement une dépendance. Vous pouvez utiliser la commande npm pour obtenir la dernière version d'express, selon votre préférence, plutôt que d'installer une version autre que "3.x" pour éviter toute surprise inconnue.

{
 
"name": "hello-world",
 
"description": "hello world test app",
 
"version": "0.0.1",
 
"private": true,
 
"dependencies": {
  "express": "3.x"
}
}

Maintenant, vous avez un colis. json dans ce répertoire, vous pouvez utiliser npm(1) pour installer cette dépendance, dans ce cas tapez simplement :

$ npm install

Une fois npm terminé, vous aurez une dépendance Express 3.x dans le répertoire /node_modules. Vous pouvez le vérifier avec npm ls, car l'extrait suivant montre l'arborescence Express et ses propres dépendances.

$ npm ls
hello-world@0.0.1 /private/tmp
└─┬ express@3.0.0beta7
 ├── commander@0.6.1
 ├─┬ connect@2.3.9
 │ ├── bytes@0.1.0
 │ ├── cookie@0.0.4
 │ ├── crc@0.2.0
 │ ├── formidable@1.0.11
 │ └── qs@0.4.2
 ├── cookie@0.0.3
 ├── debug@0.7.0
 ├── fresh@0.1.0
 ├── methods@0.0.1
 ├── mkdirp@0.3.3
 ├── range-parser@0.0.4
 ├─┬ response-send@0.0.1
 │ └── crc@0.2.0
 └─┬ send@0.0.3
  └── mime@1.2.6

Maintenant, créez l'application elle-même ! Créez un fichier appelé app.js ou server.js, selon votre préférence, importez express, puis utilisez express() pour créer une nouvelle application :

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

Les nouvelles instances d'application peuvent commencer à définir des routes via app.VERB(), en répondant dans ce cas à une requête "GET/" avec la chaîne "Hello World". req et res sont exactement les mêmes objets de nœud qui vous sont fournis, vous pouvez donc appeler res.pipe(), req.on('data', callback) et d'autres choses que vous feriez et qui n'ont rien à voir avec Express.

Express améliore ces objets pour vous fournir des interfaces de niveau supérieur telles que res.send(), en plus d'ajouter de la longueur au contenu pour vous :

app.get('/hello.txt', function(req, res){
 res.send('Hello World');
});

Appelez maintenant la méthode app.listen() pour que la connexion se lie et écoute, en acceptant les mêmes paramètres que le net.Server du nœud #listen() :

var server = app.listen(3000, function() {
  console.log('Listening on port %d', server.address().port);
});

Utilisez express(1) pour générer l'application

L'équipe Express maintient un générateur de projet pratique nommé express-generator(1). Si vous installez express-generator globalement à l'aide de npm, vous pouvez y accéder depuis n'importe où sur votre ordinateur :

$ npm install -g express-generator

Cet outil fournit un moyen simple d'obtenir un cadre d'application, mais sa portée est limitée, par exemple, il ne prend en charge que quelques moteurs de modèles, tandis qu'Express lui-même prend en charge la création de n'importe quel modèle de cadre de site Web pour nœud. Peut être consulté via l'aide :

Usage: express [options]
Options:
 -h, --help     output usage information
 -V, --version    output the version number
 -e, --ejs      add ejs engine support (defaults to jade)
 -H, --hogan     add hogan.js engine support
 -c, --css  add stylesheet support (less|stylus|compass) (defaults to plain css)
 -f, --force     force on non-empty directory

Si vous souhaitez générer une application qui prend en charge n'importe quelle situation, il vous suffit d'exécuter ::

$ express --css stylus myapp
create : myapp
create : myapp/package.json
create : myapp/app.js
create : myapp/public
create : myapp/public/javascripts
create : myapp/public/images
create : myapp/public/stylesheets
create : myapp/public/stylesheets/style.styl
create : myapp/routes
create : myapp/routes/index.js
create : myapp/views
create : myapp/views/index.jade
create : myapp/views/layout.jade

install dependencies:
$ cd myapp && npm install

run the app:
$ DEBUG=myapp node app

Comme toute autre application de nœud, vous devez installer les dépendances suivantes :

Alors commençons.

$ npm start

C'est tout ce dont vous avez besoin pour qu'une application simple soit opérationnelle. N'oubliez pas qu'Express n'est lié à aucune structure de répertoires spécifique, ceux-ci sont simplement destinés à vous donner un guide. Les choix de structures d'application peuvent être consultés dans les exemples du référentiel github.

Gestion des erreurs

Le middleware de gestion des erreurs est défini comme un middleware ordinaire, mais il doit définir le nombre de 4 paramètres. Il s'agit de la signature de la fonction (err, req, res, next) :

app.use(function(err, req, res, next){
 console.error(err.stack);
 res.send(500, 'Something broke!');
});

Bien que le middleware obligatoire de gestion des erreurs ne soit généralement pas défini à la fin, après les autres app.use(), son appel est le suivant :

var bodyParser = require('body-parser');
var methodOverride = require('method-override');
app.use(bodyParser());
app.use(methodOverride());
app.use(app.router);
app.use(function(err, req, res, next){
 // logic
});

Les réponses dans ces middlewares sont complètement arbitraires. Vous souhaiterez peut-être répondre avec une page d'erreur HTML, un simple message, une chaîne JSON ou toute autre réponse de votre choix.

Pour créer un framework organisé et de niveau supérieur, vous pouvez définir plusieurs de ces middlewares de gestion des erreurs, tout comme vous définiriez un middleware ordinaire. Par exemple, supposons que vous souhaitiez définir un gestionnaire d'erreurs pour les requêtes XHR. En plus de cela, vous pouvez effectuer les opérations suivantes :

.

var bodyParser = require('body-parser');
var methodOverride = require('method-override'); 

app.use(bodyParser());
app.use(methodOverride());
app.use(app.router);
app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);

Dans logErrors plus général, vous pouvez écrire des messages de requête et d'erreur sur stderr, loggly ou des services similaires :

function logErrors(err, req, res, next) {
 console.error(err.stack);
 next(err);
}

La définition de clientErrorHandler est la suivante, notez que cette erreur sera transmise explicitement à la suivante.

function clientErrorHandler(err, req, res, next) {
 if (req.xhr) {
  res.send(500, { error: 'Something blew up!' });
 } else {
  next(err);
 }
}

L'implémentation « complète » suivante de errorHandler peut être définie comme :

function errorHandler(err, req, res, next) {
 res.status(500);
 res.render('error', { error: err });
}

Nombre d'utilisateurs en ligne

Cette section explique en détail une (petite) application qui utilise Redis pour suivre le nombre d'utilisateurs en ligne. Créez d’abord un package. Le fichier json contient deux pièces jointes, une pour le client Redis et l'autre pour Express lui-même. Assurez-vous également que Redis est encapsulé et exécuté via $redis-server.

{
 "name": "app",
 "version": "0.0.1",
 "dependencies": {
  "express": "3.x",
  "redis": "*"
 }
}

Ensuite, vous devez créer une application et une connexion à redis :

var express = require('express');
var redis = require('redis');
var db = redis.createClient();
var app = express();

Le prochain middleware suit les utilisateurs en ligne. Ici, nous utiliserons un ensemble trié, afin de pouvoir interroger les utilisateurs en ligne via Redis, ce qui ne prend que N millisecondes. Nous utilisons les horodatages comme « standard en ligne » pour les membres. Notez qu'ici nous utilisons la chaîne user-agent au lieu de l'identifiant utilisateur habituel.

app.use(function(req, res, next){
 var ua = req.headers['user-agent'];
 db.zadd('online', Date.now(), ua, next);
});

Le middleware suivant consiste à utiliser zrevrangebyscore pour obtenir le nombre maximum d'utilisateurs en ligne au dernier moment. Nous obtenons toujours l'utilisateur en ligne le plus récent, et sa limite supérieure est l'horodatage actuel moins 60 000 millisecondes.

app.use(function(req, res, next){
 var min = 60 * 1000;
 var ago = Date.now() - min;
 db.zrevrangebyscore('online', '+inf', ago, function(err, users){
  if (err) return next(err);
  req.online = users;
  next();
 });
});

最后,我们通过一个url使用它,并绑定到一个端口!这就完了,在一个新浏览器访问这个应用程序,您会看到在线人数增加。

app.get('/', function(req, res){
 res.send(req.online.length + ' users online');
});

app.listen(3000);

Expree的反向代理

在反向代理背后使用Expree,如Varnish 或Nginx是微不足道的,然而它需要配置。通过启用“信任代理”设置app.enable(“trust proxy”),Express有一些反向代理的技巧，X-Forwarded - *头字段可能是可信的,否则他们可能很容易被欺骗。

启用该设置有一些微妙的影响。第一个是X-Forwarded-Proto可能被反向代理设定，告诉app那是https或者只是简单的http。这个值由req.protocol反射。

第二个变化是req.ip和req.ips值将填充X-Forwarded-For地址的列表。

调试Express

Express内部使用调试模块记录路径匹配和应用程序模式的信息。要看到这条信息,只要简单设置调试环境变量为express:*,当启动应用程序后，你将在控制台看以调试信息。

$ DEBUG=express:* node ./bin/www

运行这个hello world示例将打印以下内容：

express:application booting in development mode +0ms
express:router defined get /hello.txt +0ms
express:router defined get /hello.txt +1ms

另外, 表达可执行(生成器)生成的程序也使用调试模块,默认作用域是my-application调试命名空间。

你可以用以下命令启用这些调试语句

$ DEBUG=my-application node ./bin/www

关于调试的更多信息,请参见调试 指南