Apprentissage de nodejs : entrée express et bases

Ce chapitre vous présente l'introduction et les connaissances de base de l'apprentissage de nodejs : express. Alors, qu'est-ce qu'Express ? Express est un framework de développement Web avec des fonctions minimales et composé entièrement de routage et de middleware : essentiellement, une application express appelle divers middleware. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Initialisation

Créer un nouveau répertoire myapp, initialisation du projet

$ npm init

Installer express

$ npm install express --save

Créez une instance hello world

Entrez dans le répertoire myapp et créez une instance nommée app.js

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

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

var server = app.listen(3000, function() {
	var host = server.address().address;
	var port = server.address().port;

	console.log('Example app listening at http://%s:%s', host, port);
});

Le code ci-dessus démarre un serveur et écoute toutes les demandes de connexion provenant du port 3000. Il renverra la chaîne "Hello World!" à toutes les URL ou routes (/). Tous les autres chemins renvoient 404 Not Found.

Démarrez via la ligne de commande suivante

$ node app.js

générateur express

Peut être rapidement créé via l'outil générateur d'application express Le squelette d'une application.

1. Installez la commande suivante

$ npm install express-generator -g

2. Créez l'application myapp dans le répertoire actuel et exécutez la commande suivante

$ express myapp
$ cd myapp 
$ npm install> set DEBUG=myapp & npm start

Application créée via Express. générateur d'application Généralement, on a la structure de répertoire suivante :

├── app.js
├── bin
│   └── www
├── package.json
├── public
│   ├── images
│   ├── javascripts
│   └── stylesheets
│       └── style.css
├── routes
│   ├── index.js
│   └── users.js
└── views
    ├── error.jade
    ├── index.jade
    └── layout.jade

7 directories, 9 files

routage express

Le routage est composé d'un URI (ou chemin) et Il s'agit d'une méthode HTTP spécifique (GET, POST, etc.) qui implique la manière dont l'application répond à l'accès du client à un certain nœud de site Web. Chaque route peut avoir une ou plusieurs fonctions de processeur lorsqu'une route est mise en correspondance, ces fonctions/fonctions seront exécutées.

La définition de l'itinéraire se compose de la structure suivante : app.METHOD(PATH, HANDLER). Parmi eux, app est une instance express ; METHOD est l'une des méthodes de requête HTTP ; PATH est le chemin côté serveur ; HANDLER est la fonction qui doit être exécutée lorsque la route correspond.

Voici quelques codes de routage courants :

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

// respond with "hello world" when a GET request is made to the homepage
app.get('/', function(req, res) {
  res.send('hello world');
});

// POST method route
app.post('/', function (req, res) {
  res.send('POST request to the homepage');
});
//app.all() 是一个特殊的路由方法，没有任何 HTTP 方法与其对应，它的作用是对于一个路径上的所有请求加载中间件。
app.all('/secret', function (req, res, next) {
  console.log('Accessing the secret section ...');
  next(); // pass control to the next handler
});

Exemple de chemin de routage utilisant un modèle de chaîne : Les caractères ?, +, * et () sont un sous-ensemble d'expressions régulières, - et . sont interprétés littéralement dans des chemins basés sur des chaînes.

// 匹配 acd 和 abcd
app.get('/ab?cd', function(req, res) {
  res.send('ab?cd');
});

// 匹配 abcd、abbcd、abbbcd等
app.get('/ab+cd', function(req, res) {
  res.send('ab+cd');
});

// 匹配 abcd、abxcd、abRABDOMcd、ab123cd等
app.get('/ab*cd', function(req, res) {
  res.send('ab*cd');
});

// 匹配 /abe 和 /abcde
app.get('/ab(cd)?e', function(req, res) {
 res.send('ab(cd)?e');
});

//使用正则表达式的路由路径示例：
// 匹配任何路径中含有 a 的路径：
app.get(/a/, function(req, res) {
  res.send('/a/');
});

// 匹配 butterfly、dragonfly，不匹配 butterflyman、dragonfly man等
app.get(/.*fly$/, function(req, res) {
  res.send('/.*fly$/');
});

Route handle

peut fournir plusieurs fonctions de rappel pour le traitement des requêtes, qui se comportent comme un middleware. La seule différence est que ces fonctions de rappel peuvent appeler la méthode next('route') et ignorer d'autres fonctions de rappel d'itinéraire.

Les poignées d'itinéraire se présentent sous de nombreuses formes, elles peuvent être une fonction, un tableau de fonctions ou un mélange des deux, comme indiqué ci-dessous :

//使用多个回调函数处理路由（记得指定 next 对象）：
app.get('/example/b', function (req, res, next) {
  console.log('response will be sent by the next function ...');
  next();
}, function (req, res) {
  res.send('Hello from B!');
});

//使用回调函数数组处理路由：
var cb0 = function (req, res, next) {
  console.log('CB0');
  next();
}
var cb1 = function (req, res, next) {
  console.log('CB1');
  next();
}
var cb2 = function (req, res) {
  res.send('Hello from C!');
}
app.get('/example/c', [cb0, cb1, cb2]);

Méthode de réponse

La méthode de l'objet de réponse (res) dans le tableau suivant renvoie une réponse au client, mettant fin au cycle demande-réponse. Si aucune méthode n’est appelée dans le handle de route, les requêtes du client seront suspendues.

Description de la méthode :
res.download() vous invite à télécharger le fichier.
res.end() termine le processus de traitement des réponses.
res.JSON() envoie une réponse au format JSON.
res.jsonp() envoie une réponse au format JSON prenant en charge JSONP.
res.redirect() redirige la requête.
res.render() restitue le modèle de vue.
res.send() envoie différents types de réponses.
res.sendFile envoie un fichier sous forme de flux d'octets.
res.sendStatus() définit le code d'état de la réponse et l'envoie sous forme de chaîne dans le corps de la réponse.

app.route()

Vous pouvez utiliser app.route() pour créer des poignées d'itinéraire chaînées pour les chemins de routage. Étant donné que le chemin est spécifié au même endroit, cela permet de créer un routage modulaire et de réduire la redondance du code et les fautes de frappe.

app.route('/book')
  .get(function(req, res) {    res.send('Get a random book');
  })
  .post(function(req, res) {    res.send('Add a book');
  })
  .put(function(req, res) {    res.send('Update the book');
  });

express.Router

Vous pouvez utiliser la classe express.Router pour créer des gestionnaires d'itinéraires modulaires et montables. Une instance de routeur est un système complet de middleware et de routage, c'est pourquoi elle est souvent appelée « mini-application ».

Créez un fichier nommé bird.js dans le répertoire de l'application avec le contenu suivant :

var express = require('express');
var router = express.Router();
// 该路由使用的中间件
router.use(
	function timeLog(req, res, next) {
		console.log('Time: ', Date.now());
		next();
	});
// 定义网站主页的路由
router.get('/', function(req, res) {
	res.send('Birds home page');
});
// 定义 about 页面的路由
router.get('/about', function(req, res) {
	res.send('About birds');
});
module.exports = router;

Chargez ensuite le module de routage dans l'application :

var birds = require('./birds');
...
app.use('/birds', birds);

Le L'application gère les requêtes de /birds et /birds/about et appelle le middleware timeLog spécifié pour cette route.

Utilisez Express pour héberger des fichiers statiques

Vous pouvez facilement héberger des fichiers statiques, tels que des images, des fichiers CSS et JavaScript, grâce aux fonctionnalités intégrées d'Express. -en attente express.static.

Passez le répertoire où se trouvent les fichiers de ressources statiques en tant que paramètre au middleware express.static pour donner accès aux fichiers de ressources statiques. Par exemple, en supposant que vous placez des fichiers images, CSS et JavaScript dans le répertoire public, vous pouvez :

app.use(express.static('public'));

Maintenant, les fichiers du répertoire public sont accessibles.

http://localhost:3000/images/kitten.jpg
http://localhost:3000/css/style.css
http://localhost:3000/js/app.js
http://localhost:3000/images/bg.png
http://localhost:3000/hello.html

Si vos ressources statiques sont stockées dans plusieurs répertoires, vous pouvez appeler le middleware express.static plusieurs fois :

app.use(express.static('public'));
app.use(express.static('files'));

如果你希望所有通过 express.static 访问的文件都存放在一个“虚拟（virtual）”目录（即目录根本不存在）下面，可以通过为静态资源目录指定一个挂载路径的方式来实现，如下所示：

app.use('/static', express.static('public'));

现在，你就爱可以通过带有 “/static” 前缀的地址来访问 public 目录下面的文件了。

http://localhost:3000/static/images/kitten.jpg
http://localhost:3000/static/css/style.css
http://localhost:3000/static/js/app.js
http://localhost:3000/static/images/bg.png
http://localhost:3000/static/hello.html

常见问题

如何处理 404 ？

在 Express 中，404 并不是一个错误（error）。因此，错误处理器中间件并不捕获 404。这是因为 404 只是意味着某些功能没有实现。也就是说，Express 执行了所有中间件、路由之后还是没有获取到任何输出。你所需要做的就是在其所有他中间件的后面添加一个处理 404 的中间件。如下：

app.use(function(req, res, next) {  
res.status(404).send('Sorry cant find that!');
});

Express 支持哪些模板引擎？

Express 支持任何符合 (path, locals, callback) 接口规范的模板引擎。

如何渲染纯 HTML 文件？

不需要！无需通过 res.render() 渲染 HTML。你可以通过 res.sendFile() 直接对外输出 HTML 文件。如果你需要对外提供的资源文件很多，可以使用 express.static() 中间件。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!