Node.js教程

Posted 薛帅

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Node.js教程相关的知识，希望对你有一定的参考价值。

目录

 

第一章 认识Node.js

1.1 安装node

 1.2 node示例

 1.3 第一个node程序

1.4 Supervisor介绍

 1.5 nrm和nvm介绍

 第二章 Node.js基础知识

2.1 web应用和第一个express应用

 2.2 Route介绍和使用

 2.3 express路由演示

2.4 express路由API使用(一)

2.5 express路由API使用(二)

 2.6 路由拆分

 2.7 中间件

 2.8 异常处理

 2.9 MySQL

 2.10 Sequelize介绍和使用

 第三章 从实战中熟悉操作

 3.1 需求分析

 3.2 API设计

 3.3 模型创建

 3.4 API里面具体使用ORM模型

 3.5 运维和发布

 第四章：总结与问题归纳

 4.1 总结

 4.2 问题归纳

 

第一章 认识Node.js

1.1 安装node

http://nodejs.cn/download/

检验是否安装完成

打开终端输入以下命令，是否出现版本号

  1. node -v
  2. npm -v

 1.2 node示例

  1. const os = require(‘os‘);
  2.  
  3. // 读取系统的cpu的信息
  4. const cpus = os.cpus();  //获取当前系统的cpu的数量
  5. console.log(cpus.length);
  6.  
  7. //获取内存信息
  8. const total = os.totalmem();//bytes
  9. console.log(total/1024/1024/1024);//GB
  10.  
  11. //获取剩余内存信息
  12. const free = os.freemem();
  13. console.log(free/1024/1024/1024);//GB

 运行程序

终端输入

node demo.js(文件名)

 1.3 第一个node程序

  1. const http = require(‘http‘);//创建http模块
  2. const hostname = ‘127.0.0.1‘;//主机地址
  3. const port = 3000;//端口号
  4.  
  5. //创建一个server实例
  6. const server = http.createServer((req,res)=>{
  7.     //req:请求对象
  8.     //res:响应对象
  9.     res.statusCode = 200;
  10.     res.setHeader(‘Content-Type‘,‘text/plain‘);
  11.     res.end(‘hello World‘);//返回到页面
  12. })
  13. server.listen(port,hostname,()=>{
  14.     //回调
  15.     console.log(`服务启动成功,监听端口:${port}`)
  16. })

 页面上返回如下

 技术图片

 终端打印如下

技术图片

1.4 Supervisor介绍

我们一般都是编写代码边调试，这个过程很繁琐，Supervisor是个工具，可以帮我们自动检测代码的变化，重启服务

 全局安装supervisor

npm install supervisor -g

 安装完成启动项目使用

supervisor base.js(文件名)

 1.5 nrm和nvm介绍

nrm管理npm源 

  1. nrm ls //查看所有的源
  2. nrm current //当前使用的源
  3. nrm use <源名称> //切换源
  4. nrm add <registry> <url> [home]  //添加自定义源

安装nrm

npm install nrm -g

 nvm管理node.js版本

nvm ls  //查看电脑上所有的node版本

 第二章 Node.js基础知识

2.1 web应用和第一个express应用

web应用

ajax,websockt --> 服务器(web应用) --> 缓存/数据库

通过ajax或者其他方法请求web应用获取数据

 express框架

express

接收 req,处理 res

是node中的一种web框架

 首先需要先安装express

  1. npm install express -S  //生产环境下安装express
  2. 或者使用 npm install   //安装所有依赖
  1. const express = require(‘express‘);
  2.  
  3. //是一个express实例
  4. const app = express();
  5.  
  6. //get请求
  7. //请求/name接口的时候需要跟个参数。例：/name/123
  8. //返回 {name:tom,age:123}
  9. app.get(‘/name/:age‘,(req,res)=>{
  10.     let {age} = req.params;
  11.     res.json({
  12.         name:‘tom‘,
  13.         age
  14.     })
  15. })
  16.  
  17. //post请求
  18. app.post(‘/name‘,(req,res)=>{
  19.     res.send(‘tom post‘)
  20. })
  21.  
  22. //所有请求
  23. app.all(‘/name‘,(req,res)=>{
  24.     res.send(‘tom all methods‘)
  25. })
  26.  
  27. app.listen(3000,()=>{
  28.     console.log(‘server 启动成功‘)
  29. })

 2.2 Route介绍和使用

web服务如何处理一个请求？

 url --> 网络 --> dns解析 --> 目标服务器

如何响应这个请求 --> 路由//规则

 1. 请求方法来区分

  1. get --> 响应
  2. post --> 响应

2.通过uri --> 路径区分(域名后面的路径)

www.baidu.com/a/b/c.html

 2.3 express路由演示

路由的区分实例

 请求方法区分

  1. app.get(‘/demo‘,(req,res)=>{
  2.     //req:请求对象
  3.     //res:服务器响应对象
  4.     res.json({
  5.         message:‘hello express route from get demo‘
  6.     })
  7. })
  8. app.post(‘/demo‘,(req,res)=>{
  9.     //req:请求对象
  10.     //res:服务器响应对象
  11.     res.json({
  12.         message:‘hello express route from post demo‘
  13.     })
  14. })

 uri 区分

  1. app.get(‘/user/byname‘,(req,res)=>{
  2.     let {name} = req.query;
  3.     res.json({
  4.         name
  5.     })
  6. })
  7. app.get(‘/user/byid‘,(req,res)=>{
  8.     let {id} = req.query;
  9.     res.json({
  10.         id
  11.     })
  12. })

2.4 express路由API使用(一)

1：需要定义一个api/路由，需要满足客户端无论使用什么请求方式都可以得到响应

  1. app.all(‘/demo‘,(req,res)=>{
  2.     res.json({
  3.         message:‘demo‘,
  4.         method:req.method
  5.     })
  6. })

 2：无论客户端使用任何的uri，我们的服务器都可以响应--> 日志

  1. app.all(‘*‘,(req,res)=>{
  2.     res.json({
  3.         message:‘demo‘,
  4.         method:req.method,
  5.         uri:req.path
  6.     })
  7. })

2.5 express路由API使用(二)

app.use --> 使用中间件(可以用来写路由,但是尽量写中间件,因为路由也属于中间件)

  1. app.use(‘/demo‘,(req,res)=>{
  2.     res.json({
  3.         message:‘demo‘,
  4.         method:req.method
  5.     })
  6. })
  1. app.use(‘/demo‘,(req,res)=>{
  2.     res.json({
  3.         message:‘demo‘,
  4.         method:req.method,
  5.         uri:req.path
  6.     })
  7. })

 2.6 路由拆分

member

sku

order

这三个路由都有一个子路由list

  1.  定义一个文件 
member.router.js

    2.  在该文件中写入所要处理的子路由(包括express框架)

  1. 和app中的路由写法一致
  2. router.[method] //get post ...
  3. router.all
  4. router.use
  5.  
  6. const router = express.Router(); //引入路由
  7. router.get(‘/list‘,(req,res)=>{
  8.     res.json({
  9.         {
  10.             id:001,
  11.             name:‘张三‘
  12.         }
  13.     })
  14. })
  15. module.exports = router; //将该路由暴露出去

     3.  进入入口文件(app.js)注册路由

  1. const memberRouter = require(‘./member.router‘); //引入刚才写好的member路由文件
  2. const skuRouter = require(‘./sku.router‘); //引入刚才写好的sku路由文件
  3. //注册路由
  4. app.use(‘/member‘,memberRouter) // /member作为父级
  5. app.use(‘/sku‘,memberRouter) //  /sku作为父级

 2.7 中间件

 什么是express中间件

  1. 是一个函数
  2. 有四个参数(err,req,res,next),next是个回调
  1. function demo_middleware(err,req,res,next){
  2.     //1. 异常
  3.     //2. 处理业务功能，然后转交控制权--next
  4.     //3. 处理响应--结束响应-->当作路由的处理函数
  5. }
  1. app.all(‘*‘,valid_name_middleware)
  2.  
  3. //当调这个接口的时候，会先进入到all方法,然后执行中间件
  4. //判断是否有name参数，如果没有则执行中间件中返回的东西
  5. //如果有则进入next回调,执行该执行的东西
  6. app.get(‘/test‘,(req,res)=>{
  7.     res.json({
  8.         message:‘test‘
  9.     })
  10. })
  11.  
  12. //中间件,检验是否有name参数
  13. function valid_name_middleware(req,res,next){
  14.     let {name} = req.query;
  15.     if(!name || !name.length){
  16.         res.json({
  17.             message:‘缺少name参数‘
  18.         })
  19.     }else{
  20.         next();
  21.     }
  22. }

 内置中间件和第三方中间件介绍

使用方式：

  1. app级别

  • 注册的时候，一定在最顶级

  • app.use --> api去加载进来

  1. function log_middleware(req,res,next){
  2.     console.log(‘请求来了。。。‘);
  3.     next();
  4. }
  5. app.use(log_middleware); //注册app级别的中间件
  6.  
  7. //加载一个static的中间件(内置的),会去访问static下面的html文件
  8. app.use(express.static(‘static‘,{
  9.     extensions:[‘html‘,‘htm‘]
  10. }))

     2.router级别

  1. //1- 第一个场景
  2. router.use(function(req,res,next){
  3.     console.log(‘log from router‘);
  4.     next();
  5. })
  6. //2- 路由内部使用
  7. function vlaid_login_params(req,res,next){
  8.     let {name,password} = req.query;
  9.     if(!name || !password){
  10.         res.json({
  11.             message:‘参数校验失败‘
  12.         })
  13.     }else{
  14.         req.formdata = {
  15.             name,
  16.             password
  17.         }
  18.         next();
  19.     }
  20. }
  21. router.get(‘/login‘,[/** middleware */],(req,res)=>{
  22.     let {formdata} = req;
  23.     res.json({
  24.         message:‘login‘
  25.     })
  26. })

     3.异常处理-->app级别-->router级别

自定义中间件

 2.8 异常处理

异常捕获

express内置异常处理

自定义异常处理

  1. app.get(‘/demo‘,(req,res)=>{
  2.     throw new Error(‘测试异常功能‘)
  3. })
  4.  
  5. function demo_middleware(req,res,next){
  6.     try{
  7.         // mysql操作
  8.     }catch(error){
  9.         next(error);
  10.     }
  11.     
  12.     //Promise.then().catch(next) 
  13.     
  14.     //将异常抛到最终的异常处理器上
  15.     //异常处理一定是收口的
  16. }
  17.  
  18. //异常处理
  19. function error_handler_middleware(err,req,res,next){
  20.     if(err){
  21.         let {message} = err;
  22.         req.status(500)
  23.             .json({
  24.                 message:`${message || ‘服务器异常‘}`
  25.             })
  26.     }
  27. }
  28. //处理404
  29. function not_found_handler(req,res,next){
  30.     res.json({
  31.         message:‘api不存在‘
  32.     })
  33. }
  34. app.use(not_found_handler)//处理404异常
  35. app.use(error_handler_middleware) //异常处理放在最底部

 2.9 MySQL

 结构化数据库中的一种

是一个服务,提供了数据存放的服务

 mysql的安装

 2.10 Sequelize介绍和使用

 安装sequelize

  1. npm install sequelize -S //生产环境安装
  2. npm install sequelize-cli -S //安装scli-equelize-cli提高效率
  3. npx sequelize-cli init //初始化sequelize

 初始化完成会生成如下文件

 技术图片

  1. config 目录
  2. migrations 数据迁移文件
  3. modeules  ORM里面的每个模块会跟我们的项目关联
  4. seeders  初始化脚本

 修改config配置文件

  1.  "development": {
  2.     "username": "root",//用户名
  3.     "password": null,//密码
  4.     "database": "database_development",//数据库名
  5.     "host": "127.0.0.1",//主机地址
  6.     "dialect": "mysql"//方源
  7.   }
npx sequelize-cli model:generate --name User --attributes name:string

 完成之后

models目录下会多一个user.js文件

migrations目录下会多一个文件,这个文件就是用来创建表

  1. const models = require(‘../models/‘); //模型对象
  2. //models.User  //User模型
  3. //models.Sequlize //Sequlize类
  4. //models.sequlize //sequlize实例
  5.  
  6. npm install mysql2 -S //安装驱动连接MySQL
  7. npx sequelize-cli db:migrate --env=development //创建表

  1. //创建表中记录
  2. app.get(‘/create‘,async (req,res)=>{
  3.     let {name} = req.query;
  4.     // promise user --> sequlize对象
  5.     let user = await models.User.create({
  6.         name
  7.     })
  8.     res.json({
  9.         message:‘创建成功‘,
  10.        user
  11.     })
  12. })
  13. //查询表中所有的数据
  14. app.get(‘/list‘,async (req,res)=>{
  15.     let list = await models.User.findAll();
  16.     res.json({
  17.         list
  18.     })
  19. })
  20. //
  21. //查询表中id为传入id的数据
  22. app.get(‘/detail/:id‘,async (req,res)=>{
  23.     let {id} = req.params;
  24.     let user = await models.User.findOne({
  25.         where:{
  26.             id
  27.         }
  28.     })
  29.     res.json({
  30.         user
  31.     })
  32. })

 第三章 从实战中熟悉操作

 3.1 需求分析

 第一步根据用户所提出来的需求进行分析,这一步很重要,分析完成才可以设计你的API

主要分析需要传进来什么参数，实现什么功能

 3.2 API设计

  1. 创建项目目录
  2. 初始化npm
npm init

     3.安装依赖

npm install express mysql2 sequelize supervisor sequelize-cli body-parser -S

    4.先把框架写出来

  1. >> app.js
  2. const express = require(‘express‘);
  3. const bodyParser = require(‘body-parser‘);//post请求需要该中间件
  4. const app = express();
  5.  
  6. app.use(express.json());
  7. app.use(express.urlencoded());
  8. app.use(bodyParser.urlencoded({extended: true}));
  9.  
  10. app.listen(3000,()=>{
  11.     console.log(‘服务启动成功‘)
  12. })

   5.异常处理,所有的错误，http status == 500

  1. app.use((err,req,res,next)=>{
  2.     if(err){
  3.         res.status(500).json({
  4.             message:err.message
  5.         })
  6.     }
  7. })

    6.API的设计

  1. app.get(‘/list/:status/:page‘,async (req,res,next)=>{
  2.     res.json({
  3.         list:[]
  4.     })
  5. })
  6. /*创建一个任务*/
  7. app.post(‘/create‘,async (req,res,next)=>{
  8.     let { name,deadline,content } = req.body;
  9.     res.json({
  10.         todo:{},
  11.         name,
  12.         deadline,
  13.         content
  14.     })
  15. })
  16. /*修改一个任务*/
  17. app.post(‘/update‘,async (req,res,next)=>{
  18.     let { name,deadline,content,id } = req.body;
  19.     res.json({
  20.         todo:{},
  21.         name,
  22.         deadline,
  23.         content,
  24.         id
  25.     })
  26. })
  27. /*修改一个todo,删除*/
  28. app.post(‘/update_status‘,async (req,res,next)=>{
  29.     let { id,status } = req.body;
  30.     res.json({
  31.         todo:{},
  32.         id,
  33.         status
  34.     })
  35. })

 3.3 模型创建

     1.数据库的初始化

  1. 创建数据库
  2. 使用`sequelize-cli`初始化项目的数据库配置信息 `npx sequelize init`(建议新建一个目录)
  3. 生成模型文件
  4.     1.migrate 文件
  5.     2.model 文件
  6.     `npx sequelize model:generate --name Todo --attributes name:string,deadline:date,conten:string`
  7. 持久化,模型对应的[数据库表]  (生成数据库表)
  8.     `npx sequelize db:migrate`

     2.API里面具体使用ORM模型

 3.4 API里面具体使用ORM模型

  1. const models = require(‘../db/models‘);  //导入模型
  2.  
  3. /*创建一个todo*/
  4. app.post(‘/create‘,async (req,res,next)=>{
  5.     try{
  6.         let { name,deadline,content } = req.body;
  7.         /**数据持久化到数据库**/
  8.         let todo = await models.Todo.create({
  9.             name,
  10.            deadline,
  11.            content 
  12.         })
  13.         res.json({
  14.             todo:{},
  15.             name,
  16.             deadline,
  17.             content
  18.         })
  19.     }catch (error){
  20.         next(error);
  21.     }
  22. })
  23. /*修改一个todo*/
  24. app.post(‘/update‘,async (req,res,next)=>{
  25.     try{
  26.         let { name,deadline,content,id } = req.body;
  27.         let todo = await models.Todo.findOne({
  28.             where:{
  29.                 id
  30.             }
  31.         });
  32.         if(todo){
  33.             //执行更新功能
  34.             todo = await todo.update({
  35.                 name,
  36.                 deadline,
  37.                 content,
  38.                 id
  39.             })
  40.         }
  41.         res.json({
  42.             todo
  43.         })
  44.     }catch(error){
  45.         next(error);
  46.     }
  47. })
  48. /*修改一个todo,删除*/
  49. app.post(‘/update_status‘,async (req,res,next)=>{
  50.     try{
  51.         let { id,status } = req.body;
  52.         let todo = await models.Todo.findOne({
  53.             where:{
  54.                 id
  55.             }
  56.         });
  57.         if(todo && status != todo.status){
  58.             //执行更新功能
  59.             todo = await todo.update({
  60.                 status
  61.             })
  62.         }
  63.         res.json({
  64.             todo
  65.         })
  66.     }catch(error){
  67.         next(error);
  68.     }
  69. })

 3.5 运维和发布

 服务要启动在后台,不能在窗口

 pm2工具

  1. npm install pm2 -g  //全局安装pm2
  2. pm2 init   //初始化pm2 生成ecosystem.config.js文件
  3. ecosystem.config.js文件中apps可以有多个应用

 第四章：总结与问题归纳

 4.1 总结

  1. 1.技术栈
  2.     node --> http,异常
  3.     web框架,express、hapi、koa、egg
  4.     参数校验
  5.     mysql的使用，了解
  6.     ORM,sequelize使用
  7. 2.技术关键点
  8.     api设计
  9.     web-->webserver-->router-->hander-->orm--db
  10. 3.注意事项
  11.     需要做详细的 模型设计-->模型之间的关系
  12.     api的使用文档-->api文档的实用工具
  13.     测试

 4.2 问题归纳

注意：一旦删除了自带的createdAt和updatedAt两个字段，需要做出如下设置

  1. >> models >> user.js
  2. module.exports = (sequelize, DataTypes) => {
  3.   const User = sequelize.define(‘User‘, {
  4.     name: DataTypes.STRING
  5.   }, {
  6.     timestamps:false //添加这行代码,改变sequelize的默认字段为false
  7.   });
  8.   User.associate = function(models) {
  9.     // associations can be defined here
  10.   };
  11.   return User;
  12. };

修改字段默认值

  1. >> models >> user.js
  2. const User = sequelize.define(‘User‘, {
  3.     name: DataTypes.STRING,
  4.     status:{
  5.       type:DataTypes.InTEGER,
  6.       defaultValue:1   //可以在这里修改默认值
  7.     }
  8. }, {
  9.     timestamps:false
  10. });

 

 

以上是关于Node.js教程的主要内容，如果未能解决你的问题，请参考以下文章

Node.js 原生开发入门完全教程（上）

node.js零基础详细教程：node.js操作mongodb，及操作方法的封装

HTTP 状态代码 200 但页面未加载 Node.js Socket.io -- 使用 Socket.io 的 Node.js 教程，Daniel Nill，fs.readFile()，socket

node.js教程基础：第一个node.js程序

Node.js下载安装图文教程

Node.js 入门教程 ：模块