1. Installation
Copiez le code comme suit: $ npm install express
Ou utilisez Exécutable Express (1) n'importe où pour installer:
Copiez le code comme suit: / # Traducteur Remarque: Cette méthode est fortement recommandée
$ npm install -g express
2. Commencez rapidement
Le moyen le plus rapide de commencer avec Express est d'utiliser Executable Express (1) pour générer une application, comme indiqué ci-dessous:
Créer une application:
La copie de code est la suivante:
$ npm install -g express
$ express / tmp / foo && cd / tmp / foo
Installer le package de dépendance:
La copie de code est la suivante:
$ npm install -d
Démarrez le serveur:
La copie de code est la suivante:
$ node app.js
3. Créer un serveur
Pour créer une instance express.httpServer, appelez simplement la méthode CreateServer (). Pour cet exemple d'application, nous pouvons définir un itinéraire basé sur les actions HTTP (Verbes HTTP), en prenant app.get () comme exemple:
La copie de code est la suivante:
var app = require ('express'). CreateServer ();
app.get ('/', fonction (req, res) {
res.send ('Hello World');
});
app.Listen (3000);
4. Créer un serveur HTTPS
Initialisez une instance express.httpsServer comme ci-dessus. Ensuite, nous lui transmettons un objet de configuration, en acceptant la clé, le certificat et d'autres (propriétés / méthodes) mentionnées dans la documentation HTTPS.
La copie de code est la suivante:
var app = require ('express'). CreateServer ({key: ...});
V. Configuration
Express soutient tout environnement, tel que le stade du produit et le stade de développement. Les développeurs peuvent utiliser la méthode configure () pour définir l'environnement requis actuel. Si l'appel à configurer () ne contient aucun nom d'environnement, il s'exécutera sur le rappel spécifié dans tous les environnements.
Note du traducteur: les alias comme la production / développement / étape peuvent être pris par eux-mêmes, comme indiqué dans app.configure dans application.js. Voir l'exemple suivant pour l'utilisation réelle.
L'exemple suivant uniquement les conceptions de vidage (lancer des erreurs) à l'étape de développement et renvoie une exception de pile. Cependant, dans les deux environnements, nous utilisons Methodoverride et BodyParser. Faites attention à l'utilisation d'App.Router, qui peut (facultatif) être utilisé pour charger l'itinéraire du programme. De plus, l'itinéraire sera également chargé en appelant App.get (), app.post (), etc. pour la première fois.
La copie de code est la suivante:
app.configure (function () {
app.use (express.methodoverride ());
app.use (express.bodyParser ());
app.use (app.router);
});
app.configure ('développement', function () {
app.use (express.static (__ dirname + '/ public'));
app.use (express.errorhandler ({dynamisexceptions: true, showStack: true}));
});
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 passer plusieurs chaînes d'environnement:
La copie de code est la suivante:
app.configure ('scénise', 'prod', function () {
// Config
});
Pour tous les paramètres internes (#), Express fournit des méthodes SET (Key [, Val]), activer (clé) et désactiver (clé):
Remarque du traducteur: Pour plus de détails, veuillez vous référer à: application.js app.set.
La copie de code est la suivante:
app.configure (function () {
app.set ('vues', __dirname + '/ vues');
app.set («vues»);
// => "/ Absolute / Path / to / Views"
app.enable ('une fonctionnalité');
// équivalent à: app.set («une fonctionnalité», true);
app.disable ('une fonctionnalité');
// équivalent à: app.set («une fonctionnalité», false);
app.enabled ('une fonctionnalité')
// => false
});
Pour modifier l'environnement, nous pouvons définir des variables d'environnement Node_env, telles que:
La copie de code est la suivante:
$ Node_env = nœud de production app.js
Ceci est très important car la plupart des mécanismes de mise en cache ne sont allumés que pendant la phase du produit.
6. Paramètres
Express prend en charge les paramètres de raccourci suivants (hors de la boîte):
1.BasePath est utilisé pour le chemin de base d'application de res.redirect (), qui gère explicitement les applications montées.
2.View Affichage Le répertoire racine par défaut est CWD / Vues
3.View Engine Le traitement du moteur de vue par défaut (Afficher les fichiers) ne nécessite pas l'utilisation de suffixes
4.View Cache permet le cache de vue (activé à l'étape du produit)
5.Charet modifie le codage, la valeur par défaut est UTF-8
6. Routes sensibles de cases Routes sensibles
7. Une fois le routage à l'état, le routage est activé (dans l'itinéraire) la fin / ne sera pas ignorée (Remarque de traduction: c'est-à-dire app.get ('/ sofish') et app.get ('/ sofish /') sera différent)
8.JSON Rappel Activer Res.Send () / Res.json () Support JSONP explicite (support JSONP transparent)
7. routage
Express utilise des actions HTTP pour fournir un ensemble d'API de routage rapide et expressive. Par exemple, si vous souhaitez gérer un compte avec un chemin d'accès / utilisateur / 12, nous pouvons définir l'itinéraire comme suit. La valeur associée aux espaces réservés nommés est accessible par req.params.
La copie de code est la suivante:
app.get ('/ user /: id', fonction (req, res) {
res.send ('utilisateur' + req.params.id);
});
Un itinéraire est une chaîne qui est compilée en interne en régulière. Par exemple, quand / user /: id est compilé, une version simplifiée de l'expression régulière est à peu près la suivante:
La copie de code est la suivante:
// modifie la chaîne officielle
/// utilisateur // ([^ //] +) //? /
Des expressions régulières peuvent être transmises et appliquées à des scénarios complexes. Étant donné que les groupes de contenu capturés par des expressions régulières littérales sont anonymes, nous pouvons y accéder directement via des req.params. Par conséquent, le premier ensemble de contenu que nous captions sera req.params [0], tandis que le deuxième ensemble est immédiatement suivi de req.params [1].
La copie de code est la suivante:
app.get (/ ^ // utilisateurs? (?: // (/ d +) (?: /./. (/ d +))?)? /, function (req, res) {
res.send (req.params);
});
Curl Demandes de l'itinéraire défini ci-dessus:
La copie de code est la suivante:
$ curl http: // dev: 3000 / utilisateur
[NULL, NULL]
$ curl http: // dev: 3000 / utilisateurs
[NULL, NULL]
$ curl http: // dev: 3000 / utilisateurs / 1
["1", null]
$ curl http: // dev: 3000 / utilisateurs / 1..15
["1", "15"]
Voici quelques exemples de routes associées aux chemins qu'ils peuvent utiliser:
La copie de code est la suivante:
"/ID de l'utilisateur"
/ utilisateur / 12
"/ utilisateurs /: id?"
/ utilisateurs / 5
/ utilisateurs
"/ fichiers / *"
/files/jquery.js
/files/javascripts/jquery.js
"/déposer/*.*"
/files/jquery.js
/files/javascripts/jquery.js
"/ user /: id /: opération?"
/ utilisateur / 1
/ utilisateur / 1 / Modifier
"/products. :format"
/ Product.json
/producs.xml
"/products.:Format?"
/ Product.json
/producs.xml
/ produits
"/User/:id.:Format?"
/ utilisateur / 12
/User/12.json
Par exemple, nous pouvons utiliser la publication pour envoyer des données JSON et utiliser BodyParser, un middleware qui peut analyser le contenu de la demande JSON (ou un autre contenu) pour renvoyer les données et stocker le résultat de retour en req.body:
La copie de code est la suivante:
var express = require ('express')
, app = express.createServer ();
app.use (express.bodyParser ());
app.post ('/', fonction (req, res) {
res.send (req.body);
});
app.Listen (3000);
Habituellement, nous pouvons utiliser un espace réservé de style "idiot" comme l'utilisateur /: ID, sans (nom) restrictions. Cependant, par exemple, si nous voulons limiter l'ID utilisateur pour ne qu'un nombre, nous pouvons utiliser / user /: id ([0-9] +), qui ne prendra effet que si l'espace réservé contient au moins un numéro (adaptation, correspondance).
8. Contrôle de l'itinéraire passant
Nous pouvons contrôler l'itinéraire adapté suivant en appelant le troisième paramètre, Suivant () Fonction. Si l'adaptation n'est pas trouvée, le contrôle sera transmis pour se connecter et le middleware sera appelé en séquence dans l'ordre ajouté dans use (). Le principe s'applique également à plusieurs itinéraires définis au même chemin, et ils seront appelés à leur tour jusqu'à ce que l'un d'eux n'appelle pas ensuite () et décide de faire une réponse de demande.
La copie de code est la suivante:
app.get ('/ utilisateurs /: id?', fonction (req, res, suivant) {
var id = req.params.id;
if (id) {
// faire quelque chose
} autre {
suivant();
}
});
app.get ('/ utilisateurs', fonction (req, res) {
// faire autre chose
});
La méthode app.all () peut facilement transférer la même logique vers toutes les actions HTTP en l'appelant une fois. Ensuite, nous l'utilisons pour extraire un utilisateur de la pseudo-données et l'attribuer à req.User.
La copie de code est la suivante:
var express = require ('express')
, app = express.createServer ();
var utilisateurs = [{name: 'tj'}];
app.all ('/ user /: id /: op?', fonction (req, res, suivant) {
req.user = utilisateurs [req.params.id];
if (req.user) {
suivant();
} autre {
Next (nouvelle erreur ('Impossible de trouver l'utilisateur' + req.params.id));
}
});
app.get ('/ user /: id', fonction (req, res) {
res.send ('vision' + req.user.name);
});
app.get ('/ user /: id / edit', function (req, res) {
res.send ('édition' + req.user.name);
});
app.put ('/ user /: id', fonction (req, res) {
res.send ('mise à jour' + req.user.name);
});
app.get ('*', fonction (req, res) {
res.send (404, «quoi ???»);
});
app.Listen (3000);
9. Middleware
Les middleware (propriétés) de connexion utilisés sont généralement accompagnés d'un serveur de connexion régulier qui est passé à express.createServer (). comme:
La copie de code est la suivante:
var express = require ('express');
var app = express.createServer (
Express.Logger ()
, express.bodyParser ()
));
De plus, dans le bloc Configure () - ce palais progressif (Note du traducteur: Laugh ^^, de manière progressive), nous pouvons également utiliser usage use () pour ajouter du middleware.
La copie de code est la suivante:
app.use (express.logger ({format: ': méthode: url'}));
Habituellement, en utilisant le middleware Connect que vous pouvez utiliser besoin («connect»), comme ceci:
La copie de code est la suivante:
var connect = require ('connect');
app.use (connect.logger ());
app.use (connect.bodyParser ());
Ceci est quelque peu désagréable dans une certaine mesure, alors Express réexporte ces propriétés du middleware, bien qu'elles soient les mêmes:
La copie de code est la suivante:
app.use (express.logger ());
app.use (express.bodyParser ());
L'ordre du middleware est très important. Lorsque Connect reçoit une demande, le premier middleware que nous passons à CreateServer () ou use () sera accompagné de trois paramètres, de la demande, de la réponse et d'une fonction de rappel (généralement suivant). Lorsque la prochaine () est appelée, ce sera le deuxième tour de middleware, et ainsi de suite. Cela vaut la peine d'être noté car de nombreuses femmes intermédiaires dépendent les unes des autres. Par exemple, Methodoverride () interroge la méthode req.body pour détecter la surcharge de méthode http. D'un autre côté, BodyParser () analyse le contenu demandé et le stocke dans req.body. Un autre exemple est l'analyse des cookies et le support de session. Nous devons d'abord utiliser () cookieParser () puis session ().
De nombreuses applications Express incluent une telle gamme d'applications app.use (App.Router), qui peut sembler un peu étrange. En fait, ce n'est qu'une fonction middleware qui contient toutes les règles de routage définies et effectue des recherches de routage en fonction des demandes d'URL existantes et des méthodes HTTP. Express vous permet de décider de sa position, mais par défaut, il est placé en bas. En modifiant l'emplacement de l'itinéraire, nous pouvons modifier la priorité du middleware, par exemple, nous voulons utiliser le rapport d'erreur comme dernier middleware afin que toute exception transmise à next () puisse être gérée par l'intermédiaire; Ou nous voulons que le service de fichiers statique soit une priorité inférieure pour permettre à notre itinéraire d'écouter les téléchargements d'une seule demande de fichier statique, etc. Cela ressemble à ceci:
La copie de code est la suivante:
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, fournissant des données sur notre temps de réponse. Le contenu de la demande sera analysé (en cas de données), suivi de la résolution des cookies et du support de session. Dans le même temps, la session sera définie lorsque l'itinéraire de l'application est déclenché. Pour le moment, nous n'appelons pas Next (), donc le middleware statique () ne connaîtra pas cette demande. Si la route suivante a été définie, nous pouvons enregistrer divers États, refuser les téléchargements et consommer des points de téléchargement, etc.
La copie de code est la suivante:
var downloads = {};
app.use (app.router);
app.use (express.static (__ dirname + '/ public'));
app.get ('/ *', fonction (req, res, suivant) {
var file = req.params [0];
Téléchargements [fichier] = téléchargements [fichier] || 0;
Téléchargements [Fichier] ++;
suivant();
});
10. routage middleware
Le routage peut utiliser le middleware du routeur pour passer plus d'une fonction (ou un tableau) de rappel dans ses méthodes. Cette fonctionnalité est très bénéfique pour restreindre l'accès, le téléchargement des données via le routage, etc.
Habituellement, la récupération des données asynchrones peut ressembler à l'exemple suivant, nous utilisons le paramètre: ID et essayons de charger un utilisateur:
La copie de code est la suivante:
app.get ('/ user /: id', fonction (req, res, suivant) {
loadUser (req.params.id, fonction (err, utilisateur) {
if (err) return suivant (err);
res.send ('Affichage de l'utilisateur' + user.name);
});
});
Pour assurer les principes secs et améliorer la lisibilité, nous pouvons appliquer cette logique à un middleware. Comme indiqué ci-dessous, l'abstraction de cette logique dans le middleware vous permettra de le réutiliser tout en garantissant la simplicité de notre routage.
La copie de code est la suivante:
fonction chargeUser (req, res, suivant) {
// vous allez chercher votre utilisateur à partir de la base de données
var user = utilisateurs [req.params.id];
if (user) {
req.user = utilisateur;
suivant();
} autre {
Next (nouvelle erreur («Échec du chargement de l'utilisateur» + req.params.id));
}
}
app.get ('/ user /: id', loadUser, function (req, res) {
res.send ('Affichage de l'utilisateur' + req.user.name);
});
Le routage multiple peut être appliqué à une couche de logique plus profonde dans l'ordre, tel que la restriction de l'accès à un compte utilisateur. L'exemple suivant permet uniquement aux utilisateurs qui ont réussi l'authentification pour modifier leurs (ses) comptes.
La copie de code est la suivante:
fonction andrestrictToSelf (req, res, suivant) {
req.authenticatedUser.id == req.user.id
? suivant()
: suivant (nouvelle erreur («non autorisée»));
}
app.get ('/ user /: id / edit', loadUser, andrestrictToSelf, function (req, res) {
res.send ('édition de l'utilisateur' + req.user.name);
});
N'oubliez pas que le routage n'est qu'une fonction simple, comme indiqué ci-dessous, nous pouvons définir des fonctions qui renvoient le middleware pour créer une solution plus expressive et flexible.
La copie de code est la suivante:
fonction andrestrictTo (rôle) {
return function (req, res, suivant) {
req.authenticatedUser.role == Rôle
? suivant()
: suivant (nouvelle erreur («non autorisée»));
}
}
app.del ('/ user /: id', loadUser, andrestrictTo ('admin'), function (req, res) {
res.send ('supprimé utilisateur' + req.user.name);
});
Le middleware "pile" couramment utilisé peut être passé par un tableau (qui sera appliqué récursivement), qui peut être mélangé et apparié à n'importe quelle mesure.
La copie de code est la suivante:
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 cette instance, veuillez consulter le référentiel d'exemple de middleware Route.
Nous pouvons avoir plusieurs fois pour "sauter" le middleware de routage restant et continuer à faire correspondre les itinéraires ultérieurs. Pour ce faire, nous avons juste besoin d'appeler Next () avec la chaîne 'Route' - Suivant ('Route'). Si aucun itinéraire restant ne correspond à l'URL demandée, Express retournera 404 non trouvé.
11. Méthode HTTP
Jusqu'à présent, j'ai été exposé à plusieurs fois à app.get (). De plus, Express fournit également d'autres actions HTTP courantes, telles que App.Post (), App.del (), etc.
Un exemple courant d'utilisation de la poste est la soumission d'un formulaire. Ensuite, nous définissons simplement l'attribut de méthode du formulaire à publier dans HTML, et le contrôle sera attribué à l'itinéraire défini ci-dessous.
La copie de code est la suivante:
<form mode méthode = "post" action = "/">
<input type = "text" name = "user [name]" />
<input type = "text" name = "utilisateur [e-mail]" />
<input type = "soumi" value = "soumi" />
</ form>
Par défaut, Express ne sait pas comment gérer le contenu de cette demande, nous devons donc ajouter le middleware BodyParser, qui analysera le contenu de l'application / x-www-for-urlencoded et des demandes d'application / JSON et stockera les variables de req.body. Nous pouvons utiliser ce middleware comme l'exemple suivant:
La copie de code est la suivante:
app.use (express.bodyParser ());
Comme suit, notre itinéraire aura accès à l'objet req.body.User, et lorsque le nom et le courrier électronique seront définis, il contiendra ces deux propriétés (Remarque de traduction: Si le contenu envoyé par le formulaire n'est pas vide).
La copie de code est la suivante:
app.post ('/', fonction (req, res) {
console.log (req.body.user);
res.redirect ('back');
});
Lorsque vous souhaitez utiliser une méthode comme Put sous un formulaire, nous pouvons utiliser une entrée cachée nommée _Method, qui peut être utilisée pour modifier les méthodes HTTP. Pour ce faire, nous avons d'abord besoin du middleware Methodoverride, qui doit apparaître après BodyParser afin d'utiliser la valeur de formulaire contenue dans son req.body.
La copie de code est la suivante:
app.use (express.bodyParser ());
app.use (express.methodoverride ());
Pourquoi ces méthodes ne sont pas détenues par défaut? Autrement dit, c'est simplement parce qu'il n'est pas nécessaire pour les fonctionnalités complètes requises par Express. L'utilisation des méthodes dépend de votre application, vous n'en avez peut-être pas besoin et le client peut toujours utiliser des méthodes comme Put and Supprimer, et vous pouvez les utiliser directement car MethodOverride fournit une très bonne solution pour le formulaire. Voici une démonstration de la façon d'utiliser PUT, qui peut ressembler:
La copie de code est la suivante:
<form mode méthode = "post" action = "/">
<input type = "Hidden" name = "_ Method" value = "put" />
<input type = "text" name = "user [name]" />
<input type = "text" name = "utilisateur [e-mail]" />
<input type = "soumi" value = "soumi" />
</ form>
app.put ('/', fonction () {
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 soit lancée dans un itinéraire ou transmise à Suivant (ERR). L'exemple suivant gérera différentes pages en fonction d'une exception spécifique notfound:
La copie de code est la suivante:
fonction notfound (msg) {
this.name = 'notfound';
Error.call (this, msg);
Error.CaptureStackTrace (this, arguments.callee);
}
Notfound.prototype .__ proto__ = error.prototype;
app.get ('/ 404', fonction (req, res) {
Jetez un nouveau Notfound;
});
app.get ('/ 500', fonction (req, res) {
Jetez une nouvelle erreur («Clavier Cat!»);
});
Comme décrit ci-dessous, nous pouvons appeler App.Error () plusieurs fois. Ici, nous détectons l'instance Notfound et affichons une page 404, ou passons au gestionnaire d'erreur suivant. Il convient de noter que ces processeurs peuvent être définis n'importe où, car ils seront placés sous le processeur de routage lorsque l'écoute () est écoutée. Il permet des définitions dans le bloc configure () afin que nous puissions utiliser différentes méthodes de traitement des exceptions en fonction de l'environnement.
La copie de code est la suivante:
app.Error (fonction (err, req, res, suivant) {
if (err instanceof notfound) {
res.render ('404.jade');
} autre {
suivant (err);
}
});
Pour la simplicité, nous supposons ici que toutes les erreurs de cette démo sont de 500, et bien sûr, vous pouvez choisir ce que vous aimez. Lorsque vous exécutez des appels système vers un système de fichiers comme le nœud, vous pouvez recevoir une erreur.code avec Enoent, ce qui signifie "il n'y a pas un tel fichier ou un tel répertoire", que nous pouvons utiliser dans le gestionnaire d'erreurs, ou afficher une page spécifiée en cas de besoin.
La copie de code est la suivante:
app.Error (fonction (err, req, res) {
res.render ('500.jade', {
Erreur: euh
});
});
Notre application peut également utiliser le middleware ErrorHandler de Connect pour signaler les exceptions. Par exemple, lorsque nous voulons sortir une exception STDERR dans l'environnement "de développement", nous pouvons utiliser:
La copie de code est la suivante:
app.use (express.errorhandler ({dynamisexceptions: true}));
Dans le même temps, pendant la phase de développement, nous devrons peut-être afficher les exceptions que nous passons et jetons la page HTML fantaisie, pour laquelle nous pouvons définir Showstack sur true.
La copie de code est la suivante:
app.use (express.errorhandler ({showStack: true, dynamisexceptions: true}));
Le middleware ErrorHandler peut également renvoyer JSON lors de l'acceptation: Application / JSON existe, ce qui est très utile pour développer des applications qui reposent fortement sur le JavaScript client.
13. Prétraitement des paramètres d'itinéraire
Le prétraitement des paramètres de routage, grâce à la charge implicite des données et à la vérification des demandes, peut améliorer considérablement la lisibilité de votre programme. Par exemple, vous devez généralement obtenir des données de base en continu à partir de plusieurs itinéraires. Par exemple, le chargement d'un utilisateur avec / utilisateur /: ID, nous pourrions le faire:
La copie de code est la suivante:
app.get ('/ user /: userid', fonction (req, res, suivant) {
User.get (req.params.userid, fonction (err, user) {
if (err) return suivant (err);
res.send ('utilisateur' + user.name);
});
});
Grâce au prétraitement, nos paramètres peuvent être mappés aux rappels qui effectuent la validation, le contrôle et même le chargement des données de la base de données. Comme suit, nous appelons app.param () avec des noms de paramètres et espérons le cartographier à un middleware. Comme vous pouvez le voir, nous acceptons le paramètre ID représentant la valeur d'espace réservé. En utilisant cela, nous chargeons l'utilisateur comme d'habitude et gérons l'erreur, et appelons simplement Next () pour remettre le contrôle au prochain préprocesseur ou processeur de routage.
La copie de code est la suivante:
app.param ('utilisateur', fonction (req, res, suivant, id) {
User.get (id, fonction (err, utilisateur) {
if (err) return suivant (err);
if (! utilisateur) renvoie ensuite (nouvelle erreur («Échec de la recherche de l'utilisateur»));
req.user = utilisateur;
suivant();
});
});
Une fois cela fait, ce qui précède améliorera considérablement la lisibilité de l'itinéraire et nous permettra de partager facilement la logique tout au long du programme:
La copie de code est la suivante:
app.get ('/ user /: userid', fonction (req, res) {
res.send ('utilisateur' + req.user.name);
});
14. Voir le traitement
Le fichier d'affichage utilise le format <nom>. <Deger>, où <poile le moteur est le nom du module requis. Par exemple, la mise en page.ejs indiquera au système de vue pour exiger («ejs»), et le module chargé doit (exporter) la méthode export.compile (str, options) et renvoyer une fonction à adapter à Express. App.register () peut être utilisé pour modifier ce comportement par défaut pour mapper les extensions de fichiers vers des moteurs spécifiques. Par exemple, "foo.html" peut être traité par EJS.
L'exemple suivant utilise Jade pour traiter l'index.html. Parce que nous n'utilisons pas la mise en page: false, le contenu traité par index.jade sera transmis dans une variable locale appelée corps dans la mise en page.jade.
La copie de code est la suivante:
app.get ('/', fonction (req, res) {
res.render ('index.jade', {title: 'mon site'});
});
Le nouveau paramètre de moteur de vue nous permet de spécifier le moteur de modèle par défaut, par exemple, lorsque nous utilisons Jade, vous pouvez le définir comme ceci:
La copie de code est la suivante:
app.set («Voir le moteur», «jade»);
Permettez-nous de gérer ceci:
La copie de code est la suivante:
res.render ('index');
Correspondant à:
La copie de code est la suivante:
res.render ('index.jade');
Lorsque le moteur Afficher est défini, l'extension est facultative, mais nous pouvons toujours mélanger le moteur de modèle correspondant:
La copie de code est la suivante:
res.render («une autre page.ejs»);
Express fournit également des paramètres d'options de vue, qui seront appliqués à une vue à chaque fois qu'il est rendu, par exemple, si vous ne souhaitez pas utiliser la disposition:
La copie de code est la suivante:
app.set ('Afficher les options', {
Disposition: Faux
});
Cela peut être surchargé à l'intérieur de l'appel res.render () si nécessaire:
La copie de code est la suivante:
res.render ('myView.ejs', {Layout: true});
Lorsqu'il est nécessaire de modifier une disposition, nous devons généralement spécifier un autre chemin. Par exemple, lorsque nous avons réglé View Engine sur Jade et que le fichier est nommé ./views/mylayout.jade, nous pouvons simplement passer les paramètres:
La copie de code est la suivante:
res.render ('page', {Layout: 'mylayout'});
Sinon (Remarque du traducteur: lorsque le moteur Affichage n'est pas réglé sur Jade ou un autre moteur), nous devons spécifier une extension:
La copie de code est la suivante:
res.render ('page', {Layout: 'mylayout.jade'});
Ils peuvent également être des chemins absolus:
La copie de code est la suivante:
res.render ('page', {Layout: __dirname + '/../../mylayout.jade'});
Il y en a un bon exemple - personnalisez les balises de début et de fermeture des EJ:
La copie de code est la suivante:
app.set ('Afficher les options', {
ouvrir: '{{',
fermer: '}}'
})
15. Voir les pièces
Le système View d'Express a une prise en charge intégrée pour les pièces et les collections, ce qui équivaut à remplacer un fragment de document par une vue "mini". Exemple, rendant à plusieurs reprises dans une vue pour afficher les commentaires, nous pouvons utiliser l'ensemble de pièces:
La copie de code est la suivante:
partiel ('comment', {collection: commentaires});
Si aucune autre option ou variable locale n'est nécessaire, nous pouvons omettre l'objet entier et le passer simplement dans un tableau, ce qui équivaut à ce qui précède:
La copie de code est la suivante:
partiel («commentaire», commentaires);
Dans l'utilisation, l'ensemble de composants fournit gratuitement une prise en charge "magique" pour les variables locales:
1.Firstincollection vraie, quand c'est le premier objet
2. INDEXINCOLLECTION dans l'objet de collecte
3.Lastincollection vraie, quand c'est le dernier objet
4. Longueur de la collection de la collection de l'objet de collection
Le transfert (générant) des variables locales a une priorité plus élevée. Dans le même temps, les variables locales transmises à la vue des parents conviennent également aux enfants. Par exemple, lorsque nous utilisons partiel («blog / post», post) pour rendre un article de blog, il générera une variable locale publique. Il existe un utilisateur variable local dans la vue qui appelle cette fonction, qui sera également valable pour le blog / post. (Note du traducteur: ici partiel ressemble plus à la méthode inclue en php).
Remarque: Utilisez soigneusement la collection de pièces, en rendant un tableau de pièces de collection de parties de la longueur 100 équivaut à 100 vues que nous devons traiter. Pour des collections simples, il est préférable de répéter l'intégration plutôt que d'utiliser un collecteur de composants pour éviter les frais généraux excessifs.
16. Afficher la recherche
La recherche de vue est exécutée par rapport à la vue parent (chemin). Si nous avons une page de vue appelée vues / user / list.jade, et partiel ('edit') est écrite à l'intérieur, il essaiera de charger des vues / user / edit.jade et partiel ('../ messages') chargera des vues / messages.jade.
Le système View prend également en charge l'indexation des modèles, vous permettant d'utiliser un répertoire avec le même nom que la vue. Par exemple, dans un itinéraire, res.render («utilisateurs») obtient des non-vies / users.jade, c'est-à-dire des vues / utilisateurs / index.jade. (Remarque du traducteur: gérez d'abord la situation de <AmmEn>. <Deuse>, puis gérez la situation de <Athath> / <index. <Deuvre>. Pour plus de détails, voir View.js.)
Lorsque nous utilisons l'index de vue ci-dessus, nous utilisons partiel («utilisateurs») pour nous référer à des vues / utilisateurs / index.jade dans le même répertoire que la vue. Dans le même temps, le système View essaiera d'indexer ../ utilisateurs / index sans nous appeler partiel («utilisateurs»).
17. moteurs de modèle
Voici les moteurs de modèle les plus couramment utilisés pour Express:
1.Haml: implémentation HAML
2.Jade: successeur haml.js
3.EJS: JavaScript intégré
4.Coffeekup: modèle basé sur CoffeeScript
Modèles 5.JQUERY
18. Prise en charge de la session
Le support de session peut être obtenu en utilisant le middleware de session de Connect. Pour cette raison, nous devons généralement le préfacer avec le middleware CookieParser, qui analysera et stockera les données des cookies dans les cookies.
La copie de code est la suivante:
app.use (express.cookieParser ());
app.use (express.Session ({secret: "clavier cat"}));
Par défaut, la session Middleware utilise le stockage de 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 ce qui suit:
La copie de code est la suivante:
var redisstore = require ('connect-redis') (express);
app.use (express.cookieParser ());
app.use (express.Session ({secret: "clavier Cat", magasin: new redisstore}));
À ce stade, les propriétés de session et de req. Toutes les propriétés de la session seront enregistrées automatiquement dans une réponse, par exemple lorsque nous voulons ajouter des données au panier:
La copie de code est la suivante:
var redisstore = require ('connect-redis') (express);
app.use (express.bodyParser ());
app.use (express.cookieParser ());
app.use (express.Session ({secret: "clavier Cat", magasin: new redisstore}));
app.post ('/ add-to-cart', fonction (req, res) {
// Nous pouvons publier plusieurs éléments via un seul formulaire
// (dans certains cas, le middleware bodyParser () est utilisé)
var items = req.body.items;
req.Session.items = éléments;
res.redirect ('back');
});
app.get ('/ add-to-cart', fonction (req, res) {
// Lorsque vous retournez, Page Get / Add-to-Cart
// nous pouvons vérifier req.sesion.items && req.sesion.items.length
// imprime l'invite
if (req.Session.items && req.Session.items.length) {
req.notify ('info', 'vous avez% s des articles dans votre panier', req.sesion.items.length);
}
res.render («carter shopping»);
});
Pour la session de req, il dispose également de méthodes telles que la session # Touch (), la session # destrument (), la session # regenerate (), etc. pour maintenir et exploiter des séances. Pour plus de détails, veuillez consulter la documentation de la session Connect.
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 très détaillé officiel: http://expressjs.com/guide.html#migration-guide