Un guide de démarrage pour utiliser Express Framework pour Node.js_node.js

Introduction à Express
npm fournit un grand nombre de modules tiers, dont de nombreux frameworks web, comme Express, un framework web léger dont nous parlerons dans ce chapitre.

Express est un framework de développement d'applications Web node.js simple et flexible. Il fournit une série de fonctions puissantes, telles que : l'analyse de modèles, le service de fichiers statiques, le middleware, le contrôle de routage, etc., et peut également utiliser des plug-ins. ou intégrations D'autres modules vous aident à créer diverses applications Web et pour appareils mobiles. Il s'agit actuellement du framework de développement Web le plus populaire basé sur Node.js et prend en charge Ejs, jade et d'autres modèles, afin que vous puissiez créer rapidement un site Web avec des fonctions complètes.

D'accord, commençons !

1.Installation NPM

npm install express

2. Obtenez et citez

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

Grâce à la variable « app », nous pouvons appeler diverses méthodes d'expression. Le plaisir ne fait que commencer, continuez votre bon travail !

Créer une application
Après avoir pris connaissance du framework Express, nous avons commencé à créer notre première application express.

Ajoutez le contenu suivant au fichier principal de notre projet par défaut app.js :

var express = require('express');
var app = express();
app.get('/', function (request, response) {
　　response.send('Hello World!');
});

app.listen(80);

Remarque : Dans les cours suivants, nous utiliserons le port 80 pour écouter les demandes.

Après l'avoir ajouté, vérifiez le contenu du navigateur via « Adresse de test » dans la colonne de droite. Lorsque vous voyez le contenu « Hello World ! », cela signifie qu'une simple application express a été créée avec succès.

obtenir la demande
Auparavant, nous avons implémenté une application express simple. Nous allons maintenant commencer à décrire en détail son implémentation spécifique. Tout d'abord, apprenons les méthodes courantes d'Express.

méthode get - gère les requêtes GET émises par le client en fonction du chemin de la requête.

Format :

app.get(path,function(request, response));

path est le chemin de la requête, et le deuxième paramètre est la fonction de rappel pour traiter la requête. Il existe deux paramètres, request et réponse, qui représentent les informations de requête et les informations de réponse.

Exemple ci-dessous :

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

app.get('/', function(request, response) {
　　response.send('Welcome to the homepage!');
});
app.get('/about', function(request, response) {
　　response.send('Welcome to the about page!');
});
app.get("*", function(request, response) {
　　response.send("404 error!");
});
app.listen(80);

Dans l'exemple ci-dessus, la méthode de traitement du chemin d'accès à la page, du chemin racine et de tous les chemins est spécifiée. Et dans la fonction de rappel, utilisez la méthode send de la réponse HTTP pour envoyer une chaîne au navigateur.

Référez-vous au code ci-dessus, essayez de définir vous-même un chemin de demande d'obtention, puis accédez à l'adresse via le navigateur pour voir si la demande peut aboutir.

Middleware41c11716550b4594cd05d1f9a396284b
1. Qu'est-ce qu'un middleware ?

Le middleware est une fonction qui traite les requêtes HTTP et est utilisée pour effectuer diverses tâches spécifiques, telles que vérifier si l'utilisateur est connecté, analyser les données et d'autres tâches qui doivent être effectuées avant que les données ne soient finalement envoyées à l'utilisateur. . Sa plus grande caractéristique est qu'après qu'un middleware l'a traitée, les données correspondantes peuvent être transmises au middleware suivant.

2. Un middleware qui n'effectue aucune opération et ne transmet que l'objet requête, probablement comme ceci :

function Middleware(request, response, next) {
　　next();
}

Le suivant dans le code ci-dessus est la fonction de rappel du middleware. S'il prend un paramètre, cela signifie générer une erreur, et le paramètre est le texte de l'erreur.

function Middleware(request, response, next) {
　　next('出错了！');
}

Après la génération d'une erreur, le middleware suivant ne sera plus exécuté jusqu'à ce qu'une fonction de gestion des erreurs soit trouvée. Si la méthode suivante n'est pas appelée, les fonctions enregistrées ultérieurement ne seront pas exécutées.

Utilisation de base de toutes les fonctions
Contrairement à la fonction get, la fonction app.all() peut correspondre à tous les verbes HTTP, ce qui signifie qu'elle peut filtrer les requêtes de tous les chemins. Si vous utilisez la fonction all pour définir le middleware, cela signifie que toutes les requêtes doivent passer par. ceci en premier.

Format :

app.all(path,function(request, response));

Comme indiqué ci-dessous, nous utilisons la fonction all pour définir les attributs d'en-tête de réponse avant la requête.

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

app.all("*", function(request, response, next) {
　　response.writeHead(200, { "Content-Type": "text/html;charset=utf-8" }); //设置响应头属性值
next();
});

app.get("/", function(request, response) {
　　response.end("欢迎来到首页!");
});

app.get("/about", function(request, response) {
　　response.end("欢迎来到about页面!");
});

app.get("*", function(request, response) {
　　response.end("404 - 未找到!");
});

app.listen(80);

Le "*" dans les paramètres de code ci-dessus signifie qu'il est valable pour tous les chemins. Cette méthode est particulièrement utile lors du traitement d'un chemin de préfixe spécifique ou de n'importe quel chemin. Peu importe que nous demandions un chemin, elle passera par la fonction all. à l'avance.

Si cela s'affiche, que se passera-t-il si nous ignorons toutes les fonctions ? Essayez-le vous-même ?

utiliser l'utilisation de base 1
use est la méthode express d’appel du middleware, et elle renvoie une fonction.

Format :

app.use([path], function(request, response, next){});

//可选参数path默认为"/"。

1. Utiliser un middleware

app.use(express.static(path.join(__dirname, '/')));

Comme ci-dessus, nous utilisons la fonction use pour appeler le middleware express afin de définir le chemin d'accès au répertoire de fichiers statique (supposé être le chemin racine ici).

2. Comment appeler deux middlewares en continu, comme le montre l'exemple suivant :

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

app.use(function(request, response, next){
 console.log("method："+request.method+" ==== "+"url："+request.url);
 next();
});

app.use(function(request, response){
 response.writeHead(200, { "Content-Type": "text/html;charset=utf-8" });
 response.end('示例：连续调用两个中间件');
});

app.listen(80);

回调函数的next参数，表示接受其他中间件的调用，函数体中的next()，表示将请求数据传递给下一个中间件。

上面代码先调用第一个中间件，在控制台输出一行信息，然后通过next()，调用第二个中间件，输出HTTP回应。由于第二个中间件没有调用next方法，所以req对象就不再向后传递了。

use基本用法2
use方法不仅可以调用中间件，还可以根据请求的网址，返回不同的网页内容，如下示例：

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

app.use(function(request, response, next) {
　　if(request.url == "/") {
　　　　response.send("Welcome to the homepage!");
　　}else {
　　　　next();
　　}
});

app.use(function(request, response, next) {
　　if(request.url == "/about") {
　　　　response.send("Welcome to the about page!");
　　}else {
　　　　next();
　　}
});
app.use(function(request, response) {
　　response.send("404 error!");
});
app.listen(80);

上面代码通过request.url属性，判断请求的网址，从而返回不同的内容。

回调函数
Express回调函数有两个参数，分别是request(简称req)和response(简称res)，request代表客户端发来的HTTP请求，request代表发向客户端的HTTP回应，这两个参数都是对象。示例如下:

function(req, res) {
});

在后面的学习中，我们会经常和它打交道，牢牢记住它的格式吧！

获取主机名、路径名
今天我们就先来学习如何使用req对象来处理客户端发来的HTTP请求。

req.host返回请求头里取的主机名(不包含端口号)。

req.path返回请求的URL的路径名。

如下示例：

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

app.get("*", function(req, res) {
　　console.log(req.path);
　　res.send("req.host获取主机名，req.path获取请求路径名!");
});

app.listen(80);

试一试在浏览器中输入任意一个请求路径，通过req查看主机名或请求路径。

query基本用法
query是一个可获取客户端get请求路径参数的对象属性，包含着被解析过的请求参数对象，默认为{}。

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

app.get("*", function(req, res) {
　　console.log(req.query.参数名);
　　res.send("测试query属性!");
});

app.listen(80);

通过req.query获取get请求路径的对象参数值。

格式：req.query.参数名；请求路径如下示例：

例1： /search?n=Lenka

req.query.n // "Lenka"

例2： /shoes?order=desc&shoe[color]=blue&shoe[type]=converse

req.query.order // "desc"

req.query.shoe.color // "blue"

req.query.shoe.type // "converse"

试一试get请求一个带参数路径，使用“req.query.参数名”方法获取请求参数值。

param基本用法
和属性query一样，通过req.param我们也可以获取被解析过的请求参数对象的值。

格式：req.param("参数名")；请求路径如下示例：

例1： 获取请求根路径的参数值，如/?n=Lenka，方法如下：

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

app.get("/", function(req, res) {

　　console.log(req.param("n")); //Lenka

　　res.send("使用req.param属性获取请求根路径的参数对象值!");

});
app.listen(80);

例2：我们也可以获取具有相应路由规则的请求对象，假设路由规则为 /user/:name/，请求路径/user/mike,如下：

app.get("/user/:name/", function(req, res) {
　　console.log(req.param("name")); //mike
　　res.send("使用req.param属性获取具有路由规则的参数对象值!");
});

PS：所谓“路由”，就是指为不同的访问路径，指定不同的处理方法。

看了上面的示例，试一试使用req.param属性解析一个请求路径对象，并获取请求参数值。

params基本用法
和param相似，但params是一个可以解析包含着有复杂命名路由规则的请求对象的属性。

格式：req.params.参数名；

例1. 如上课时请求根路径的例子，我们就可以这样获取，如下：

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

app.get("/user/:name/", function(req, res) {
　　console.log(req.params.name); //mike
　　res.send("使用req.params属性获取具有路由规则的参数对象值!");
});

app.listen(80);

查看运行结果，和param属性功能是一样的，同样获取name参数值。

例2：当然我们也可以请求复杂的路由规则，如/user/:name/:id，假设请求地址为：/user/mike/123，如下：

app.get("/user/:name/:id", function(req, res) {
　　console.log(req.params.id); //"123"
　　res.send("使用req.params属性复杂路由规则的参数对象值!");
});

对于请求地址具有路由规则的路径来说，属性params比param属性是不是又强大了那么一点点呢！

send基本用法
send()方法向浏览器发送一个响应信息，并可以智能处理不同类型的数据。格式如下： res.send([body|status], [body]);

1.当参数为一个String时，Content-Type默认设置为"text/html"。

res.send('Hello World'); //Hello World

2.当参数为Array或Object时，Express会返回一个JSON。

res.send({ user: 'tobi' }); //{"user":"tobi"}
res.send([1,2,3]); //[1,2,3]

3.当参数为一个Number时，并且没有上面提到的任何一条在响应体里，Express会帮你设置一个响应体，比如：200会返回字符"OK"。

res.send(200); // OK
res.send(404); // Not Found
res.send(500); // Internal Server Error

send方法在输出响应时会自动进行一些设置，比如HEAD信息、HTTP缓存支持等等。