Explication détaillée d'express dans nodejs

Cet article vous présentera Express dans node. 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 sera utile à tout le monde.

Recommandations associées : "tutoriel nodejs"

Avant cela, permettez-moi de parler d'un tutoriel très utile - nodemon -> ; Une fois la compilation automatique

npm install nodemon -D

terminée, modifiez le champ "start" dans l'option "script" du fichier de configuration json comme suit :

"start":"nodemon js路径+名",
//增加一行
"start:node":"node js路径+名",
...

Mais maintenant nous trouvons un problème : peu importe quel fichier est utilisé, toute modification redémarrera le nœud.

On précise simplement : Surveiller les fichiers js :

Nouveau nodemon.json

{
	"watch":["./src/**/*.js"]
}

(src est au même niveau que json (où js est situé) Nom du répertoire)

Après cela, le serveur peut automatiquement npm start.

Retour aux affaires, Express passe à l'action

Notre première connaissance d'express : un framework web en node.

Comme suit : utilisez express pour créer une application Web

npm install express -S       # "-S"：在生产环境中搭载
npm install nodemon -D

Définissez app.js sous le répertoire src (dossier auto-construit) :

const express=require('express');
//一个express实例
const app=express();
//app.use((req,res)=>{
//	res.json({
//	name:"张上"
//	})
//})
app.get('/name',(req,res)=>{
	let {age}=req.params;
	res.send('tom');
});
app.post('/name',(req,res)=>{
	res.send('tom post');
});

app.listen(8081,()=>{
	console.log('启动成功');
});

Voir le code Ligne 3, avez-vous pensé à http ?
const server=http.createServer((req,res)=>{...});
Le serveur ici est le même que l'application ci-dessus. Mais les deux requêtes sont différentes, car la requête de l'application est encapsulée par express, et elle a des fonctions plus riches !

Modifier dans package.json (fichier de configuration généré) :

// "script"选项下第一个——"start"值中加一个“nodemon”字样：
"start":"nodemon ./src/app.js",
...

Comment passer des paramètres dans le code ci-dessus ?

// get方式传参
app.get('/name/:age',(req,res)=>{
	let {age}=req.params;
	res.json({
		name:'tom',
		age
	})
})

Présentation et utilisation du routeur

Comment le service Web gère une demande
url --> réseau --> ---> Comment le serveur cible

• répond-il à cette requête - routage ! (Règles)

• Comment distinguer - méthode de requête (get/post), uri (chemin)

const express=require('express');
const app=express();
//1.请求方法判断 ——测试工具：postman
app.get('/demo',(req,res)=>{
	res.json({
		message:'hello get mxc'
	})
});
app.post('/demo',(req,res)=>{
	res.json({
		message:'hello post mxc'
	})
});

//2.通过URI ——postman上测试：http://127.0.0.1:8081/user/byname?name=mxc
//或：http://127.0.0.1:8081/user/byid?id=123
app.get('/user/byname',(req,res)=>{
	let {name}=req.query;
	res.json({
		name
	})
});
app.get('/user/byid',(req,res)=>{
	let {id}=req.query;
	res.json({
		id
	})
});

app.listen(8081,()=>{
	console.log('server已启动');
});

API de routage

Définir une API qui doit satisfaire le client pour obtenir une réponse quelle que soit la demande qu'il fait

app.all('/demo',(req,res)=>{
	res.json({
		message:'demo',
		method:req.method
	})
});

Quel que soit l'URI utilisé par le client, notre service peut répondre (log)

app.all('*',(req,res)=>{
	res.json({
		message:'demo',
		method:req.method,
		uri:req.path
	})
});

app.use ---> Middleware

app.use('/demo',(req,res)=>{
	res.json({
		message:'from use demo',
		method:req.method
	})
});

app.use((req,res)=>{
	res.json({
		message:'demo',
		method:req.method,
		uri:req.path
	})
});

Comment diviser le routage ? —— express.Router

Dans le fichier member.router.js :

const express=require('express');
const router=express.Router();
//router.[method]//(get/post)
//router.all
//router.use
router.get('/list',(req,res)=>{
	res.json({
		list:[
			id:001,
			name:'mxc'
		]
	})
});
module.exports=router;

Dans app.js "Enregistrer l'itinéraire":

const memberRouter=require('./member.router.js');app.use(memberRouter);

Maintenant, nous écrivons une autre route pour skuRouter, qui a également "/list" dans son URI.
Après inscription. Nous constatons que nous ne pouvons pas le trouver (impossible de l’imprimer), que devons-nous faire ?

En fait, nous pouvons ajouter un "préfixe" - c'est-à-dire la "racine" - à la route utilisée pour la distinguer :

const memberRouter=require('./member.router.js');
app.use(memberRouter);

Middleware

middleware express

Utilisation :

• Utilisation au niveau de l'application (lors de l'inscription, elle doit être au niveau supérieur/fin)

• Niveau du routeur

• Gestion des exceptions

Middleware (ordinaire)

Nous devons d'abord réfléchir à une question : pourquoi un « middleware » est-il nécessaire : le programme ne peut pas être « complété » en une seule étape.

Par exemple, prenons la démo suivante : Récupérez le contenu d'entrée :

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<form action="http://localhost:8081" method="post">
用户：<input type="text" name="user" /><br />
密码：<input type="password" name="pass" /><br />
<input type="submit" value="提交">
</form>
</body>
</html>

npm install body-parser

const express=require('express');
const bodyParser=require('body-parser');
var server=express();
server.listen(8081);
server.use(bodyParser,urlencoded({}));
// 上面一行有时也写为：server.use(bodyParser,urlencoded({extended:true}));
server.use('/',function(req,res){
	console.log(req.body);
});

Il ne fait aucun doute qu'il s'agit d'une ligne "extra" que d'habitude : server.use(bodyParser,urlencoded({})); C'est ce qu'on appelle "utilisation de middleware" .

Il est maintenant temps de réfléchir à une autre question : pourquoi le programme « ne peut-il être complété en une seule étape » ?
Comme dans le code ci-dessus, devrait-il y avoir « body » dans la requête du POST ?
Évidemment non. Le corps n’existe pas en premier lieu ! (Sinon, nous utilisons toujours des données pour ajax ?)

Mais nous en avons vraiment besoin maintenant. Ainsi la 2ème ligne const bodyParser=require('body-parser'); s'applique pour le "module middleware", et la 5ème ligne "installe" un corps pour l'ensemble du "fonctionnement en chaîne" (deux usages sont connectés).

De manière générale, en combat réel, nous écrirons 3 middlewares pour former une méthode d'analyse de paramètres "complète":
app.use(express.json());
app.use(express.urlencoded());
app.use(bodyParser,urlencoded({extended:true}));
//然后再get/post操作

Bien sûr, si la soumission précédente est en mode GET, utilisez simplement req.query directement dans le nœud, il n'y a donc pas besoin de middleware.

Alors puisque le middleware est si "utile", pourquoi ne pas en encapsuler un vous-même ?
fichier mxc-body-parser.js

// 仿body-parser中间件
const querystring=require('querystring');
module.exports=function(req,res,next){
	var str='';
	req.on('data',function(data){
		str+=data;
	});
	req.on('end',function(){
		req.body=querystring.parser(str);
		next();
	});
}

puis référencez-le dans d'autres fichiers :

const express=require('express');
const mxcParser=require('./lib/mxc-body-parser');
var server=express();
server.listen(8081);
server.use(mxcParser);
server.use('/',function(req,res){
	console.log(req.body);
});

Gestion des exceptions

——Visualisation
Habituellement, la gestion des exceptions se fait globalement.

Approche générale : throw new Error('测试功能异常');
Gestion des exceptions intégrée à node-express :

function error_handler_middleware(err,req,res,next){
	if(err){
		let {message}=err;
		res.status(500).json({
			message:`${message || '服务器异常'}`
		})
	}else{
		//其余操作
	}
}
...
app.use(error_handler_middleware);   //放在所有Router最后，做中间件用

Création de modèle ORM en combat réel

Parlons d'abord de l'initialisation de la base de données

Après avoir créé MySQL, nous devons connecter le nœud à MySQL. Les outils utilisés :

npm install express mysql2 sequelize nodemon sequelize-cli -S

连接成功后会生成config.json配置文件，我们在development选项中修改和添加：

"database":"数据库表名",
"timezone":"+08:00"

持久化模型对应的数据库表：

npx sequelize db:migrate

前端数据如何往mysql中写？

调用todo.js模块：

use strict' ;
module. exports = (sequelize, DataTypes) => {
	const Todo = sequelize.define( 'Todo', {
		name: DataTypes. STRING,
		deadLine: DataTypes .DATE,
		content: DataTypes. STRING
	}，{
		timestamps:false
	}) ;
	Todo. associate = function(models) {
		// associations can be def ined here
	};	
	return Todo;
};

使用：创建第一个todo：（初始时）

app.post('/create',async (req,res,next)=>{
	try{
		let {name,deadline,content}=req.body;
		//持久化到数据库
		let todo=await models.Todo.create({
			name,
			deadline,
			content
		})
		res.json({
			todo,
			message:'任务创建成功'
		})
	}catch(err){
		next(error)
	}
})

最后的next传给谁？

我们之前说，在全局最后创建一个use，用于错误处理：

app.use((err,req,res,next)=>{
	if(err){
		res.status(500).json({
			message:err.message
		})
	}
})

更多编程相关知识，请访问：编程入门！！

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!