Après avoir installé Node (télécharger), créez un répertoire sur votre machine et démarrez votre première application.
$ Mkdir Hello-World
Dans ce répertoire, vous définissez le "package" de l'application, qui n'est différent de tout autre package 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, que vous aimez faire, au lieu 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, "Dedérences": {"Express": "3.x"}}Maintenant, vous avez un colis. Dans ce répertoire, vous pouvez utiliser NPM (1) pour installer cette dépendance, dans ce cas, vous n'avez qu'à entrer:
$ d'installation de NPM
Une fois le NPM terminé, vous aurez un Express 3.x sur lequel vous dépendez dans le répertoire / node_modules. Vous pouvez le vérifier avec NPM LS, tout comme l'arbre express et ses propres dépendances indiquées dans l'extrait de code suivant.
$ npm [email protected] / private / tmp└fique @3.0.0beta7 ├fique └fiques [email protected] ├fiques [email protected] └── [email protected]
Créez maintenant l'application elle-même! Créez un fichier appelé app.js ou server.js, peu importe celui que vous aimez, introduisez 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 itinéraires via app.verb (), auquel cas, répondez à la demande "get /" via 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', rappel) et d'autres choses que vous feriez qui n'auraient rien à voir avec Express.
Express améliore ces objets pour vous fournir des interfaces de niveau supérieur telles que res.send (), en plus de vous ajouter la longueur du contenu:
app.get ('/ hello.txt', function (req, res) {res.send ('hello world');});Appelez maintenant la méthode app.listten () pour la connexion à lier et à écouter, en acceptant les mêmes paramètres que le net.server #Liste () du nœud:
var server = app.Listen (3000, function () {console.log ('écoute sur le port% d', server.address (). port);});Utiliser 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 le générateur express globalement avec NPM, vous pouvez y accéder depuis n'importe où sur votre ordinateur:
$ npm install -g express-generator
Cet outil fournit un moyen facile d'obtenir un cadre d'application, mais avec une portée limitée, par exemple, il ne prend en charge que quelques moteurs de modèle et Express lui-même prend en charge la création de modèles de cadre de site Web pour Node. Vous pouvez le voir via l'aide:
Utilisation: Express [Options] Options: -H, - - help de sortie Informations d'utilisation -v, - Version de la version Le numéro de version -e, --ejs Ajouter la prise en charge du moteur EJS (par défaut à Jade) -H, - Hogan Ajouter Hogan.js Prise en charge du moteur -C, --CSS Ajouter la prise en charge de Stylesheet (moins | Stylus | Compass) (Par défaut vers CSS) -f, -force Force sur la compasse) Directy
Si vous souhaitez générer une application prise en charge dans tous les cas, vous devez simplement exécuter ::
$ Express --CSS Stylus MyAppcreate: MyAppcreate: MyApp / Package.jsonCreate: MyApp / App.jscreate: MyApp / PublicCreate: MyApp / Public / StyleSheetScreate: MyApp / Public / StyleSheets / Style.styLcreate: MyApp / Routes / index.jscreate: myApp / Views / index.jadecreate: MyApp / View
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 obtenir une application simple en cours d'exécution. N'oubliez pas que Express n'est lié à aucune structure de répertoire spécifique, ce ne sont qu'un guide pour vous. La sélection de la structure de l'application peut être consultée dans le référentiel GitHub.
Gestion des erreurs
Les définitions de middleware des erreurs sont comme des middleware ordinaires, mais 4 paramètres doivent être définis, qui est la signature de la fonction (err, req, res, suivant):
app.use (function (err, req, res, suivant) {console.error (err.stack); res.send (500, 'quelque chose cassé!');});Bien que la gestion des erreurs forcée du middleware ne soit généralement pas définie à la fin, après autre app.use (), son appel ressemble à ceci:
var bodyParser = require ('body-parser'); var methethoverride = require ('method-override'); app.use (bodyParser ()); app.use (methodoverride ()); app.use (app.router); app.use (function (err, req, res, suivant) {// logic});La réponse dans ces middleware est complètement arbitraire. Vous voudrez peut-être répondre à une page d'erreur HTML, à un message simple, à une chaîne JSON ou à toute autre réponse que vous aimez.
Pour construire un cadre organisé et de niveau supérieur, vous pouvez définir plusieurs de ces middleware de gestion des erreurs, tout comme vous définissez des middleware normaux. Par exemple, supposons que vous souhaitiez définir un gestionnaire d'erreurs pour une demande XHR, en plus de ceux-ci, ce que vous pourriez faire est le suivant:
var bodyParser = require ('body-parser'); var methodoverride = require ('méthode-override'); app.use (bodyParser ()); app.use (méthodoverride ()); app.use (app.router); app.use (Logerrors); app.use (clientErrorHandler); app.use (errorhandler);Dans des Logerrors plus généraux, vous pouvez écrire des demandes et des messages d'erreur à STDERR, LOGGLY ou SERVICES similaires:
fonction LogerRors (err, req, res, suivant) {Console.Error (err.stack); suivant (err);}La définition de ClientErrorHandler est indiquée ci-dessous, notez que cette erreur sera explicitement transmise à la suivante.
fonction clientErrorHandler (err, req, res, suivant) {if (req.xhr) {res.send (500, {error: 'quelque chose a fait exploser!'}); } else {next (err); }}L'implémentation "All-Round" suivante suivante peut être définie comme:
fonction errorHandler (err, req, res, suivant) {res.status (500); res.render ('error', {error: err});}Comptage des utilisateurs en ligne
Cette section explique en détail une (petite) application et utilise Redis pour suivre le nombre d'utilisateurs en ligne. Créez d'abord un package. Le fichier JSON contient deux pièces jointes, l'une pour le client redis et l'autre pour l'express lui-même. Assurez-vous également que vous avez enveloppé Redis et que vous passez à travers $ redis-server.
{"name": "app", "version": "0.0.1", "dépendances": {"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 middleware suivant suit les utilisateurs en ligne. Ici, nous utiliserons l'ensemble trié afin que nous puissions interroger les utilisateurs en ligne par Redis, qui ne prend que n millisecondes. Nous utilisons des horodatages comme «norme en ligne» pour les membres. Notez que nous utilisons ici la chaîne d'agent utilisateur au lieu de l'ID utilisateur habituel.
app.use (function (req, res, suivant) {var ua = req.heders ['user-agent']; db.zadd ('en ligne', date.now (), ua, suivant);});Le prochain middleware consiste à utiliser ZrevRangeByscore à la dernière minute pour obtenir le nombre maximal d'utilisateurs en ligne, nous obtenons toujours les utilisateurs en ligne les plus récents et sa limite supérieure est l'horodatage actuel moins 60000 millisecondes.
app.use (function (req, res, suivant) {var min = 60 * 1000; var ilgo = date.now () - min; db.zrevRangeBysCore ('en ligne', '+ inf', il y a, function (err, utilisateurs) {if (err) return (err); req.online = utilisateurs; Next ();});});Enfin, nous l'utilisons via une URL et le lions à un port! C'est tout, accéder à cette application dans un nouveau navigateur et vous verrez une augmentation du nombre de personnes en ligne.
app.get ('/', function (req, res) {res.send (req.online.length + 'utilisateurs en ligne');}); app.Listen (3000);Proxy inversé pour express
L'utilisation d'express derrière le proxy inverse, comme le vernis ou le nginx, est trivial, mais il nécessite une configuration. En permettant à l'application de réglage de "Proxy Trust" ("proxy de fiducie"), Express a quelques astuces pour la proxyation inverse, les champs d'en-tête X-Forwarded * peuvent être dignes de confiance, sinon ils peuvent être facilement trompés.
Activer ce paramètre a des effets subtils. Le premier est que X-Forwarded-proto peut être défini par proxy inverse, indiquant à l'application qu'il s'agit de HTTPS ou simplement d'un simple HTTP. Cette valeur est reflétée par req.protocol.
Le deuxième changement est que les valeurs req.ip et req.ips rempliront la liste des adresses X-Forwardée.
Débogage express
Express utilise le module de débogage en interne pour enregistrer des informations sur la correspondance du chemin et les modèles d'application. Pour voir ce message, définissez simplement la variable d'environnement de débogage pour exprimer: *, et après avoir démarré l'application, vous verrez les informations de débogage de la console.
$ Debug = express: * nœud ./bin/www
L'exécution de cet exemple Hello World imprimera ce qui suit:
Express: démarrage de l'application en mode développement + 0MSExpress: Routeur défini get /hello.txt + 0msexpress: routeur défini get /hello.txt + 1ms
De plus, le programme généré par l'expression exécutable (générateur) utilise également un module de débogage, et la portée par défaut est l'espace de noms de débogage de l'application.
Vous pouvez activer ces déclarations de débogage avec la commande suivante
$ Debug = My-Application Node ./bin/www
Pour plus d'informations sur le débogage, consultez le guide de débogage