1.Installation
$ npm install express
ou utilisez-le n'importe où Installation de l'exécutable express(1) :
# Note de traduction : Cette méthode est fortement recommandée
$ npm install - g express
2. Commencez vite
Le moyen le plus rapide de démarrer avec Express est d'utiliser l'exécutable express(1) pour générer une application, comme indiqué ci-dessous :
Créer une application :
$ npm install -g express
$ express /tmp/foo && cd /tmp/foo
Installer les packages de dépendances :
$ npm install -d
Démarrez le serveur :
$ node app.js
3. Créer un serveur
Pour créer une instance express.HTTPServer, appelez simplement la méthode createServer(). Commun à cet exemple d'application, nous pouvons définir un routage basé sur des actions HTTP (Verbes HTTP), en prenant comme exemple app.get() :
var app = require('express').createServer();
app.get('/', function(req, res){
res.send('hello world');
});
app.listen(3000);
4. Créez un serveur HTTPS
Initialisez une instance express.HTTPServer comme ci-dessus. Ensuite, nous lui transmettons un objet de configuration qui accepte les clés, certificats et autres (propriétés/méthodes) mentionnés dans la documentation https.
var app = require('express') .createServer( { clé : ... });
5.Configuration
Express prend en charge n'importe quel environnement, tel que la production et le développement. Les développeurs peuvent utiliser la méthode configure() pour définir l'environnement actuellement requis. Si l'appel à configure() n'inclut aucun nom d'environnement, il exécutera les rappels spécifiés dans tous les environnements.
Annotation : les alias tels que production/développement/étape peuvent être choisis par vous-même, comme indiqué dans app.configure dans application.js. Voir l'exemple ci-dessous pour une utilisation réelle.
L'exemple suivant ne dumpExceptions (génère une erreur) pendant la phase de développement et renvoie une exception de pile. Mais dans les deux environnements, nous utilisons methodOverride et bodyParser. Faites attention à l'utilisation de app.router. Il peut (facultatif) être utilisé pour charger (monter) la route du programme. De plus, le premier appel à app.get(), app.post(), etc. charger également l'itinéraire.
app.configure(function(){
app .use(express.methodOverride());
app.use(express.bodyParser());
app.use(app.router);
});
app.configure('development', function(){
app.use(express.static(__dirname '/public'));
app.use(express.errorHandler({ dumpExceptions : true, showStack : vrai }));
});
app.configure('production', function(){
var oneYear = 31557600000;
app.use(express.static(__dirname '/public', { maxAge: oneYear }));
app.use(express.errorHandler());
});
Pour des environnements similaires, vous pouvez transmettre plusieurs chaînes d'environnement :
app.configure('stage', 'prod', function(){
// config
});
Pour tout paramètre interne (#), Express fournit les méthodes set(key[, val]), activate(key) et Disable(key) :
Annotation : Pour plus de détails sur les paramètres, voir : app.set dans application.js.
app.configure(function(){
app .set('views', __dirname '/views');
app.set('views');
// => "/absolute/path/to/views"
app.enable('some feature');
// Équivalent à : app.set('some feature', true);
app.disable('some feature');
// Équivalent à : app.set('some feature', false);
app.enabled('some feature')
// => false
});
Pour changer l'environnement, nous pouvons définir la variable d'environnement NODE_ENV, telle que :
$ NODE_ENV=production node app.js
Ceci est très important, car la plupart des mécanismes de mise en cache ne sont activés que pendant la phase de production.
6. Paramètres
Express prend en charge les paramètres prêts à l'emploi suivants :
1.basepath Le chemin de base de l'application utilisé pour res.redirect(), gérant explicitement les applications montées
2.view Le répertoire racine par défaut de View For CWD/views
3.view engine Le moteur par défaut. Le traitement du moteur de visualisation (afficher les fichiers) n'a pas besoin d'utiliser le suffixe
4.view cache Activer le cache de visualisation (activé au stade de la production)
5.charet Changer l'encodage, La valeur par défaut est utf-8
6 Les routes sensibles à la casse sont sensibles à la casse dans le routage
7.strit routage Après avoir activé (dans le routage) le / de fin ne sera pas ignoré (Annotation : app.get('/sofish ') et app.get('/sofish/ ') sera différent)
Le rappel 8.json permet le support explicite de res.send() / res.json() (support jsonp transparent)
7. Routage
Express fournit un ensemble d'API de routage informatives et expressives utilisant des actions HTTP. Par exemple, si nous voulons traiter un compte avec le chemin /user/12, nous pouvons définir la route comme suit. Les valeurs associées aux espaces réservés nommés sont accessibles à l'aide de req.params.
app.get('/user/ : id', function(req, res){
res.send('user ' req.params.id);
});
La route est une chaîne compilée en interne dans un chaîne régulière. Par exemple, lorsque /user/:id est compilé, une version simplifiée de l'expression régulière ressemble à ceci :
// Modifier la chaîne officielle
//user/([^/] )/?/
Les expressions régulières peuvent être transmises à s'applique à une scène complexe. Étant donné que les groupes de contenu capturés via des expressions régulières littérales sont anonymes, nous pouvons y accéder directement via req.params. Par conséquent, le premier ensemble de contenu que nous capturons sera req.params[0], tandis que le deuxième ensemble suivra immédiatement req.params[1].
app.get(/^/users? (?: /(d )(?:..(d ))????/, function(req, res){
res.send(req.params);
});
Curl Pour la demande du parcours défini ci-dessus :
$ curl http://dev:3000/user
[null,null]
$ curl http://dev:3000/users
[null,null]
$ curl http://dev:3000/users /1
["1",null]
$ curl http://dev:3000/users/1..15
["1","15 "]
ci-dessous Ce sont des instances de certains itinéraires, associés aux chemins qu'ils peuvent emprunter :
"/user/:id"
/user/12
"/users/:id?"
/users/5
/users
"/files/*"
/files/jquery.js
/files/javascripts/jquery.js
"/file/*.*"
/files/jquery.js
/files/javascripts/jquery.js
"/user/:id/:operation?"
/user/1
/user/1/edit
"/products.:format"
/products.json
/products.xml
"/products.:format?"
/products.json
/products.xml
/products
"/user/:id.:format?"
/user/12
/user/12.json
Par exemple, nous pouvons utiliser POST pour envoyer des données json via bodyParser. le middleware peut analyser le contenu de la requête JSON (ou tout autre contenu) pour renvoyer des données et stocker le résultat du retour dans req.body :
var express = require('express')
, app = express.createServer();
app.use(express.bodyParser());
app.post('/', function(req, res){
res.send(req.body);
});
app.listen(3000);
Habituellement, nous pouvons utiliser un espace réservé "insensé" comme user/:id qui n'a aucune restriction (de dénomination). Cependant, par exemple, si nous souhaitons limiter l'ID utilisateur aux seuls chiffres, nous pourrions alors utiliser /user/:id([0-9]), qui ne prendra effet que lorsque l'espace réservé contient au moins un chiffre (adaptation , correspondre).
8. Contrôle de la route de dépassement
Nous pouvons contrôler le prochain itinéraire adapté en appelant le troisième paramètre, la fonction next(). Si aucun adaptateur n'est trouvé, le contrôle sera rendu à Connect et le middleware sera appelé dans l'ordre ajouté dans use(). Le même principe s'applique à plusieurs routes définies sur le même chemin. Elles seront appelées en séquence jusqu'à ce que l'une d'entre elles décide de répondre à la requête sans appeler next().
app.get('/users/ : id?' , function(req, res, next){
var id = req.params.id;
if (id) {
// faire quelque chose
} else {
suivant ();
}
});
app.get('/users', function(req, res){
// faire autre chose
});
la méthode app.all() doit uniquement être appelée once Appliquez facilement la même logique à toutes les actions HTTP. Ci-dessous, nous l'utilisons pour extraire un utilisateur des données factices et l'attribuer à req.user.
var express = require('express')
, app = express.createServer();
var utilisateurs = [{ nom : 'tj' }];
app.all('/user/:id/:op?', function(req, res, next){
req.user = users[req.params.id];
if (req .user) {
next();
} else {
next(new Error('impossible de trouver l'utilisateur ' req.params.id));
}
});
app.get('/user/:id', function(req, res){
res.send('viewing ' req.user.name);
});
app.get('/user/:id/edit', function(req, res){
res.send('editing ' req.user.name);
});
app.put('/user/:id', function(req, res){
res.send('updating ' req.user.name);
});
app.get('*', function(req, res){
res.send(404, 'quoi???');
});
app.listen(3000);
9. Intergiciel
Le middleware Connect (propriétés) utilisé accompagne généralement l'un de vos serveurs Connect habituels, transmis à express.createServer() . Par exemple :
var express = require(' exprimer');
var app = express.createServer(
express.logger()
, express.bodyParser()
);
De plus, dans le bloc configure() - ce progressif De manière progressive, on peut aussi facilement utiliser use() pour ajouter du middleware.
app.use(express.logger({ format : ' :method :url' }));
Habituellement, lorsque vous utilisez le middleware de connexion, vous pouvez utiliser require('connect'), comme ceci :
var connect = require('connect');
app.use(connect.logger());
app.use(connect.bodyParser()) ;
C'est quelque peu ennuyeux, donc express réexporte ces propriétés du middleware, même si elles sont les mêmes :
app.use(express.logger());
app.use(express.bodyParser());
L'ordre du middleware est très important. Lorsque Connect reçoit une requête, le premier middleware que nous transmettons à createServer() ou use() pour l'exécution sera accompagné de trois paramètres, requête, réponse et une fonction de rappel (généralement suivante). Lorsque next() sera appelé, ce sera le tour du deuxième middleware, et ainsi de suite. Ceci est remarquable car de nombreux middlewares dépendent les uns des autres. Par exemple, methodOverride() interroge la méthode req.body pour détecter les surcharges de la méthode HTTP, tandis que bodyParser() analyse le contenu de la requête et le stocke dans le corps de la requête. Un autre exemple est l'analyse des cookies et la prise en charge de la session, nous devons d'abord utiliser() cookieParser() suivi de session().
De nombreuses applications Express contiennent une ligne comme app.use(app.router). Cela peut sembler un peu étrange, mais en fait, il s'agit simplement d'une ligne qui contient toutes les règles de routage définies et effectue une recherche d'itinéraire basée sur celles existantes. Requête URL et méthode HTTP. Une fonction middleware. Express permet de déterminer sa position, mais par défaut il est placé en bas. En changeant l'emplacement de la route, nous pouvons modifier la priorité du middleware. Par exemple, nous voulons signaler les erreurs du dernier middleware afin que toutes les exceptions transmises à next() puissent être gérées via celui-ci. la priorité du service est inférieure pour permettre à notre routeur d'écouter le nombre de téléchargements d'une seule demande de fichier statique, etc. Cela ressemble plus ou moins à ceci :
app.use( express.logger(...));
app.use(express.bodyParser(...));
app.use(express.cookieParser(...));
app.use (express.session(...));
app.use(app.router);
app.use(express.static(...));
app.use (express.errorHandler (...));
Nous ajoutons d'abord logger(), qui peut contenir la méthode req.end() du nœud pour nous fournir des données de temps de réponse. Le contenu de la requête suivante sera analysé (s'il y a des données), suivi de l'analyse des cookies et de la prise en charge de la session. En même temps, req.session sera défini lorsque la route dans app.router sera déclenchée. à ce moment-là, next(), donc le middleware static() ne connaîtra pas cette requête. Si la route suivante a été définie, nous pouvons enregistrer divers statuts, refuser les téléchargements, consommer des points de téléchargement, etc.
var downloads = {};
app.use(app.router);
app.use(express.static(__dirname '/public'));
app.get('/*', function(req, res, next){
var file = req.params[0];
downloads[file] = downloads[file] || 0;
téléchargements[fichier] ;
suivant();
});
10. Middleware de routage
Le routage peut utiliser le middleware du routeur pour transmettre plus d'une fonction de rappel (ou tableau) à sa méthode. Cette fonctionnalité est idéale pour restreindre l'accès, télécharger des données via le routage, etc.
Habituellement, la récupération de données asynchrone peut ressembler à l'exemple suivant, où nous utilisons le paramètre :id et essayons de charger un utilisateur :
app.get('/user/:id', function(req, res, next){
loadUser(req.params.id , function(err, user ){
if (err) return next(err);
res.send('Viewing user ' user.name);
});
});
est Pour garantir le principe DRY et améliorer la lisibilité, nous pouvons appliquer cette logique au sein d'un middleware. Comme indiqué ci-dessous, extraire cette logique dans un middleware vous permettra de la réutiliser tout en gardant notre routage simple.
function loadUser(req, res, next) {
// Vous récupéreriez votre utilisateur depuis la base de données
var user = users[req.params.id];
if (user ) {
req.user = user;
next();
} else {
next(new Error('Échec du chargement de l'utilisateur ' req.params.id));
}
}
app.get('/user/:id', loadUser, function(req, res){
res.send('Viewing user' req.user.name);
});
Plusieurs itinéraires peuvent être appliqués séquentiellement à une logique plus profonde, comme la restriction de l'accès à un compte utilisateur. L'exemple ci-dessous permet uniquement aux utilisateurs authentifiés de modifier son compte.
function andRestrictToSelf(req, res, next) {
req.authenticatedUser.id == req.user.id
? next()
: next(new Error('Unauthorized'));
}
app.get('/user/:id/edit',loadUser etRestrictToSelf, function(req, res){
res.send('Modification de l'utilisateur ' req.user.name);
} );
N'oubliez pas que les routes ne sont que des fonctions simples, comme indiqué ci-dessous, nous pouvons définir des fonctions qui renvoient un middleware pour créer une solution plus expressive et flexible.
function andRestrictTo(role) {
return function( req, res, next) {
req.authenticatedUser.role == role
next()
: next(new Error('Unauthorized'));
}
>
app.del('/user/:id', loadUser, andRestrictTo('admin'), function(req, res){
res.send('Utilisateur supprimé ' req.user.name);
});
Les "piles" de middleware couramment utilisées peuvent être transmises à travers un tableau (sera appliqué de manière récursive), qui peut être mélangé et adapté à n'importe quel niveau (qui peut être mélangé et associé à n'importe quel degré) .
var a = [middleware1, middleware2]
, b = [middleware3, middleware4]
, tout = [a, b];
app.get('/foo', a, function(){});
app.get('/bar', a, function(){});
app.get('/', a, middleware3, middleware4, function(){});
app.get('/', a, b, function(){});
app .get('/', all, function(){});
Pour le code complet de cet exemple, veuillez consulter le référentiel d'exemples de middleware de route.
Nous souhaiterons peut-être « sauter » le middleware de routage restant plusieurs fois et continuer à faire correspondre les itinéraires suivants. Pour ce faire, nous appelons simplement next() avec la chaîne 'route' - next('route'). Si aucun itinéraire restant ne correspond à l’URL demandée, Express renverra 404 Not Found.
11. Méthode HTTP
J'ai rencontré app.get() plusieurs fois jusqu'à présent. De plus, Express propose également d'autres actions HTTP courantes, telles que app.post(), app.del(), etc.
Un exemple courant d'utilisation du POST consiste à soumettre un formulaire. Ensuite, nous définissons simplement l'attribut méthode du formulaire pour qu'il soit publié en HTML, et le contrôle sera attribué à l'itinéraire défini ci-dessous.
Par défaut, Express ne sait pas comment gérer le contenu de cette demande, nous doit ajouter le middleware bodyParser, il analysera le contenu demandé par application/x-www-form-urlencoded et application/json, et stockera les variables dans req.body. On peut utiliser ce middleware comme l'exemple suivant :
app.use(express.bodyParser());
Comme indiqué ci-dessous, notre route aura accès à l'objet req.body.user, qui contiendra le nom et l'email une fois défini (Annotation : Si le contenu envoyé par le formulaire n'est pas vide).
app.post('/', function (req, res){
console.log(req.body.user);
res.redirect('back');
});
Quand vous souhaitez utiliser quelque chose comme PUT dans un formulaire De cette façon, nous pouvons utiliser une entrée cachée nommée _method, qui peut être utilisée pour modifier la méthode HTTP. Pour ce faire, nous avons d'abord besoin du middleware methodOverride, qui doit apparaître après le bodyParser afin d'utiliser les valeurs du formulaire contenues dans son req.body.
app.use(express.bodyParser() );
app.use(express.methodOverride());
Quant à savoir pourquoi ces méthodes ne sont pas disponibles par défaut, simplement parce qu'elles ne sont pas requises pour la fonctionnalité complète requise par Express. L'utilisation des méthodes dépend de votre application, vous n'en aurez peut-être pas besoin, le client peut toujours utiliser des méthodes comme PUT et DELETE, vous pouvez les utiliser directement, car methodOverride fournit une très bonne solution pour les formulaires. Ce qui suit montre comment utiliser la méthode PUT, qui peut ressembler à :
app.put('/', function(){
console.log(req.body.user);
res.redirect('back');
});
12. Gestion des erreurs
Express fournit la méthode app.error() afin que l'exception reçue puisse être levée dans une route ou transmise à next(err). L'exemple suivant gérera différentes pages en fonction d'une exception NotFound spécifique :
function NotFound(msg){
this.name = 'NotFound';
Error.call(this, msg);
Error.captureStackTrace(this, arguments.callee);
}
NotFound.prototype.__proto__ = Erreur.prototype;
app.get('/404', function(req, res){
throw new NotFound;
});
app.get('/500', function(req, res){
throw new Error('keyboard cat!');
});
Comme suit, nous pouvons Appel de app.error() plusieurs fois. Ici, nous détectons les instances de NotFound et affichons une page 404 ou la transmettons au gestionnaire d'erreurs suivant. Il est à noter que ces gestionnaires peuvent être définis n'importe où, car ils seront placés sous le gestionnaire de route lors de l'écoute (). Il autorise les définitions dans le bloc configure() afin que nous puissions utiliser différentes méthodes de gestion des exceptions en fonction de l'environnement.
app.error(function(err, req , res, suivant){
if (err instanceof NotFound) {
res.render('404.jade');
} else {
next(err);
}
}) ;
Par souci de simplicité, nous supposons ici que toutes les erreurs dans cette démo sont de 500. Bien sûr, vous pouvez choisir celle que vous aimez. Lorsque le nœud exécute un appel système sur le système de fichiers, vous pouvez recevoir un code d'erreur avec ENOENT, ce qui signifie une erreur "aucun fichier ou répertoire de ce type n'existe". Nous pouvons l'utiliser dans le gestionnaire d'erreurs, ou lorsqu'il existe une page spécifiée. être affiché en cas de besoin.
app.error(function(err, req , res) {
res.render('500.jade', {
erreur : err
});
});
Notre application peut également utiliser le middleware errorHandler de Connect pour signaler les exceptions. Par exemple, lorsque nous voulons générer des exceptions stderr dans l'environnement "développement", nous pouvons utiliser :
app.use(express.errorHandler({ dumpExceptions: true }));
En même temps pendant la phase de développement nous pouvons avoir besoin d'afficher les exceptions nous passons et lançons des pages HTML sophistiquées. Pour cela, nous pouvons définir showStack sur true.
app.use(express.errorHandler({ showStack: true , dumpExceptions: true }));
errorHandler middleware peut également renvoyer json lorsque Accept: application/json existe, ce qui est très utile pour développer des applications qui s'appuient fortement sur Javascript côté client.
13. Prétraitement des paramètres d'itinéraire
Le prétraitement des paramètres d'itinéraire, grâce au chargement implicite des données et à la vérification des demandes, peut grandement améliorer la lisibilité de votre programme. Par exemple, vous devez souvent obtenir en permanence des données de base provenant de plusieurs itinéraires. Comme pour charger un utilisateur avec /user/:id, nous pouvons généralement le faire comme ceci :
app.get('/user/:userId', function(req, res, next){
User.get(req.params.userId, function(err, user) {
if (err) return next(err);
res.send('user ' user.name);
});
});
Grâce au prétraitement, Les paramètres we peuvent être mappés à des rappels qui effectuent une validation, un contrôle (coercition) ou même chargent des données à partir de la base de données. Comme suit, nous appelons app.param() avec le nom du paramètre, dans l'espoir de le mapper à un middleware. Comme vous pouvez le voir, nous acceptons le paramètre id qui représente la valeur de l'espace réservé. En utilisant cela, nous chargeons l'utilisateur et traitons les erreurs comme d'habitude, et appelons simplement next() pour passer le contrôle au prochain préprocesseur ou gestionnaire de route.
app.param('userId', function (req, res, next, id){
User.get(id, function(err, user){
if (err) return next(err);
if (!user) return next( new Error( 'failed to find user'));
req.user = user;
next();
});
});
Une fois cela fait , ce qui précède améliorera considérablement la lisibilité du routage et nous permettra de partager facilement la logique tout au long du programme :
app.get('/user/:userId', function(req, res){
res.send('user ' req.user.name);
} );
14. Afficher le traitement
Afficher les fichiers utilise le format ., où est le nom du module requis. Par exemple, layout.ejs indiquera au système de visualisation de require('ejs'), le module chargé doit (exporter) la méthode exports.compile(str, options) et renvoyer une fonction pour s'adapter à Express. app.register() peut être utilisé pour modifier ce comportement par défaut et mapper les extensions de fichier à un moteur spécifique. Par exemple, "foo.html" peut être traité par ejs.
L'exemple suivant utilise Jade pour traiter index.html. Parce que nous n'utilisons pas layout: false, le contenu traité par index.jade sera transmis dans une variable locale nommée body dans layout.jade.
app.get('/', function (req, res){
res.render('index.jade', { title: 'My Site' });
});
Le nouveau paramètre du moteur d'affichage nous permet de spécifier le moteur de modèle par défaut, par exemple, lorsque nous utilisons jade, nous pouvons le définir comme ceci :
app .set('view engine', 'jade');
nous permet de faire cela :
res.render('index');
correspond à :
res.render('index.jade');
Lorsque le moteur de visualisation est défini, l'extension est facultative, mais on peut toujours mélanger et match Moteur de modèle :
res.render(' another-page.ejs');
Express fournit également des paramètres d'options d'affichage, qui seront appliqués à chaque rendu d'une vue. Par exemple, vous pouvez le faire si vous ne souhaitez pas utiliser de mises en page :
app.set('view options', {
layout : false
});
Ceci peut être surchargé dans l'appel res.render() si nécessaire :
res.render('myview.ejs', { layout: true });
Quand il y a un devez modifier une mise en page, nous devons généralement spécifier un autre chemin. Par exemple, lorsque nous avons défini le moteur de visualisation sur jade et que le fichier est nommé ./views/mylayout.jade, nous pouvons simplement transmettre les paramètres comme ceci :
res.render('page', { layout: 'mylayout' });
Sinon (Annotation : Non Lorsque le moteur de visualisation est réglé sur jade ou autres moteurs), il faut préciser une extension :
res.render('page', { layout: 'mylayout.jade' });
Ils peuvent aussi être des chemins absolus :
res.render('page', { layout: __dirname '/../../mylayout.jade ' });
Il existe un bon exemple pour cela : personnaliser les balises d'ouverture et de fermeture des ejs :
app.set('view options', {
open: '{{',
fermer : '}}'
})
15. Afficher le composant
Le système de vue d'Express prend en charge les partiels et les collections, ce qui équivaut à remplacer un fragment de document par une vue « mini ». Par exemple, pour afficher des commentaires de manière répétée dans une vue, on peut utiliser le jeu de widgets :
partial('comment', { collection: comments });
Si aucune autre option ou variable locale n'est nécessaire, nous pouvons omettre l'objet entier et simplement transmettre un array, qui est le même que Les ci-dessus sont équivalents :
partial('commentaire', commentaires);
En cours d'utilisation, l'ensemble de widgets prend en charge gratuitement certaines variables locales « magiques » :
1.firstInCollection true, lorsqu'il s'agit du premier objet
2.indexInCollection index dans l'objet collecteur
3.lastInCollection true, lorsqu'il s'agit du dernier objet
4 .collectionLength La longueur du collecteur objet
Le transfert (génération) des variables locales a une priorité plus élevée. Dans le même temps, les variables locales transmises à la vue parent sont également adaptées à la vue enfant. Par exemple, lorsque nous utilisons partial('blog/post', post) pour afficher un article de blog, cela générera une variable locale de publication. Il y a une variable locale user dans la vue qui appelle cette fonction, et elle sera également valide. pour le blog/article. (Annotation : partial ici ressemble plus à la méthode include en php).
Remarque : veuillez utiliser les collecteurs de widgets avec prudence. Le rendu d'un tableau de collection de widgets d'une longueur de 100 équivaut à devoir traiter 100 vues. Pour les collections simples, il est préférable de répéter le processus intégré plutôt que d'utiliser un collecteur de widgets pour éviter une surcharge excessive.
16. Afficher la recherche
La recherche de vue est effectuée par rapport à la vue parent (chemin). Par exemple, si nous avons une page de vue appelée views/user/list.jade et que partial('edit') est écrit à l'intérieur, il essaiera de le faire. charger vues/utilisateur/edit.jade, de même partiel('../messages') chargera vues/messages.jade.
Le système View prend également en charge l'indexation des modèles, vous permettant d'utiliser un répertoire portant le même nom que la vue. Par exemple, dans une route, res.render('users') renvoie vues/users.jade, qui est vues/users/index.jade. (Annotation : gérez d'abord le cas ., puis gérez le cas /. Pour plus de détails, voir view.js.)
Lors de l'utilisation de l'index de vue ci-dessus, nous utilisons partial('users') pour référencer vues/users/index.jade dans le même répertoire que la vue. En même temps, le système de vue essaiera d'indexer ../. users/index. Sans que nous appelions partial('users').
17. Moteurs de modèles
Voici les moteurs de modèles les plus couramment utilisés pour Express :
1.Haml : implémentation de haml
2.Jade : successeur de haml.js
3.EJS : JavaScript intégré
4.CoffeeKup : modèle basé sur CoffeeScript
5.Modèles jQuery
18. Prise en charge des sessions
La prise en charge de la session peut être obtenue en utilisant le middleware de session de Connect. Pour cela, nous devons généralement ajouter le middleware cookieParser devant celui-ci, qui analysera et stockera les données des cookies dans req.cookies.
app.use(express.cookieParser() );
app.use(express.session({ secret: "keyboard cat" }));
Par défaut, le middleware de session utilise le stockage mémoire intégré de Connect, mais il existe de nombreuses autres implémentations . Par exemple, connect-redis fournit un stockage de session Redis, qui peut être utilisé comme suit :
var RedisStore = require('connect-redis')(express);
app.use(express.cookieParser());
app.use(express.session( { secret : "keyboard cat", store : new RedisStore }));
À ce stade, les propriétés req.session et req.sessionStore seront disponibles pour toutes les routes et middleware ultérieurs. Toutes les propriétés sur req.session seront automatiquement enregistrées dans une réponse, par exemple lorsque nous souhaitons ajouter des données au panier :
var RedisStore = require('connect-redis')(express);
app.use(express.bodyParser());
app .use(express.cookieParser());
app.use(express.session({ secret: "keyboard cat", store: new RedisStore }));
app.post('/add-to-cart', function(req, res){
// Nous pouvons POSTER plusieurs éléments via un formulaire
// (utilisez bodyParser() dans certains cas Middleware )
var items = req.body.items;
req.session.items = items;
res.redirect('back');
});
app.get('/add-to-cart', function(req, res){
// Une fois renvoyée, la page GET /add-to-cart
// Nous pouvons vérifier req. session.items && req.session.items.length
// Pour imprimer l'invite
if (req.session.items && req.session.items.length) {
req.notify('info ' , 'Vous avez %s articles dans votre panier', req.session.items.length);
}
res.render('shopping-cart');
});
Pour req.session, il dispose également de méthodes comme Session#touch(), Session#destroy(), Session#regenerate(), etc. pour maintenir et faire fonctionner la session. Consultez la documentation de la session Connect pour plus de détails.
19. Guide de mise à niveau
Pour les étudiants utilisant Express 1.x, si vous avez des programmes importants qui doivent être mis à niveau vers 2.x pour un meilleur support, veuillez consulter le guide de migration officiel très détaillé : http:/ /expressjs. com/guide.html#migration-guide
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
