• Node.js学习记录

    一、Node.js简介

            浏览器中JavaScript在浏览器中的运行环境（代码正常运行需要的环境），

             Node.js后端的运行环境，通过Node.js可以实现用JavaScript后端开发

            Node.js是一个基于Chrome V8引擎的JavaScript运行环境

    二、fs文件系统模块

         读取指定文件中的内容

                    fs.readFile()语法格式： fs.readFile(path[,options],callback)   

     代码：

    1. const { log } = require('console')
    2. //引入fs模块进行文件操作
    3. const fs = require('fs')
    4. // 1.参数路径
    5. // 2.输出格式
    6. // 3.会点函数，返回失败和成功的结果
    7. fs.readFile('./readFile/read.text','utf8',(err,dataStr)=>{
    8.     log(err)
    9.     log('======')
    10.     console.log(dataStr);
    11. })

       

     代码展示：

    1. const { log } = require('console')
    2. //引入fs模块进行文件操作
    3. const fs = require('fs')
    4. // 1.写入文件路径
    5. // 2.写入内容
    6. // 3.编码格式，默认是utf8,可以省略
    7. // 4.回调函数
    8. fs.writeFile('./readFile/read.text','55566665','utf8',(err,data)=>{
    9.     log(err)
    10.     console.log(data);
    11. })

    绝对路径和相对路径，代码运行时会以执行node命令时所在的目录，动态的拼接出被操作文件的完整路径。

    解决fs模块路径拼接的问题

     三、path模块

     

    ../   会抵消一层路径

     获取文件名

      移出文件扩展名

     

     四、HTTP模块

     代码：

    1. //引入http请求
    2. const http=require('http')
    3. //创建服务
    4. const server = http.createServer()
    5. //监听请求
    6. server.on('request',(req,res)=>{
    7.     console.log('触发了请求');
    8. })
    9. //启动服务
    10. server.listen(8080,()=>{
    11.     console.log('启动服务');
    12. })

     

     

     res.setHeader('Content-Type','text/html; charset=utf-8')

    五、模块化

    module.exports导出      require引入

    module.exports默认是空对象

     exports指向module.exports对象

    时刻谨记，使用require()模块时，得到的永远是module.export指向的对象

    六、包管理 

    指定下载包的版本   npm i 包@版本号

    npm uninstall 包名称     卸载包

    -D  将包记录到dev节点中，仅开发使用

    i5ting_toc

    i5ting_toc -f 要转换的md文件路径 -o

    require()引入包使用

     ...展开运算符

    npm包配置项

    1. {
    2.     "name": "xc-tools",
    3.     "version": "1.0.0",
    4.     "main": "index.js",
    5.     "description": "初次提交，用于提交测试，输入什么返回什么",
    6.     "keywords": [
    7.         "xc",
    8.         "tools"
    9.     ],
    10.     "license": "ISC"
    11. }

    七、模块加载机制

     

     八、express模块

    1. //1.导入express
    2. const express = require('express')
    3. //2.创建web服务器
    4. const app=express()
    5. //3.调用listen（端口号，启动成功后的回调函数），启动服务器
    6. app.listen(80,()=>{
    7.     console.log('服务启动成功');
    8. })

     监听客户端请求，实现数据传递

    1. //1.导入express
    2. const express = require('express')
    3. //2.创建web服务器
    4. const app=express()
    5. //4.监听客户端请求
    6. //监听get请求
    7. app.get('/user',(req,res)=>{
    8.     res.send({name:'zs',age:20})
    9. })
    10. //监听post请求
    11. app.post('/user',(req,res)=>{
    12.     res.send('请求成功')
    13. })
    14. //3.调用listen（端口号，启动成功后的回调函数），启动服务器
    15. app.listen(80,()=>{
    16.     console.log('服务启动成功');
    17. })

    获取url上面的query参数

    1. //1.导入express
    2. const express = require('express')
    3. //2.创建web服务器
    4. const app=express()
    5. //4.监听客户端请求
    6. //监听get请求
    7. app.get('/user',(req,res)=>{
    8.     res.send({name:'zs',age:20})
    9. })
    10. //监听post请求
    11. app.post('/user',(req,res)=>{
    12.     res.send('请求成功')
    13. })
    14. //5.通过req.query获取客户端发送过来的查询参数
    15. app.get('/',(req,res)=>{
    16.     //注意在默认情况下，req.query是一个空对象
    17.     console.log(req.query);
    18. })
    19. //3.调用listen（端口号，启动成功后的回调函数），启动服务器
    20. app.listen(80,()=>{
    21.     console.log('服务启动成功');
    22. })//1.导入express
    23. const express = require('express')
    24. //2.创建web服务器
    25. const app=express()
    26. //4.监听客户端请求
    27. //监听get请求
    28. app.get('/user',(req,res)=>{
    29.     res.send({name:'zs',age:20})
    30. })
    31. //监听post请求
    32. app.post('/user',(req,res)=>{
    33.     res.send('请求成功')
    34. })
    35. //5.通过req.query获取客户端发送过来的查询参数
    36. app.get('/',(req,res)=>{
    37.     //注意在默认情况下，req.query是一个空对象
    38.     console.log(req.query);
    39. })
    40. //3.调用listen（端口号，启动成功后的回调函数），启动服务器
    41. app.listen(80,()=>{
    42.     console.log('服务启动成功');
    43. })

    通过req.params获取:匹配到的动态参数（params参数）  /use:id/:name传递两个参数也是可以的

    1. //1.导入express
    2. const express = require('express')
    3. //2.创建web服务器
    4. const app=express()
    5. //4.监听客户端请求
    6. //监听get请求
    7. app.get('/user',(req,res)=>{
    8.     res.send({name:'zs',age:20})
    9. })
    10. //监听post请求
    11. app.post('/user',(req,res)=>{
    12.     res.send('请求成功')
    13. })
    14. //5.通过req.query获取客户端发送过来的查询参数
    15. app.get('/',(req,res)=>{
    16.     //注意在默认情况下，req.query是一个空对象
    17.     console.log(req.query);
    18. })
    19. //6.获取:id动态参数
    20. app.get('/user/:id',(req,res)=>{
    21.     console.log(req.params);
    22.     res.send(req.params)
    23. })
    24. //3.调用listen（端口号，启动成功后的回调函数），启动服务器
    25. app.listen(80,()=>{
    26.     console.log('服务启动成功');
    27. })

    express.static()托管静态资源

    1. //7.通过express.static()托管静态资源
    2. app.use(express.static('./无用'))

      

     

      nodemon实现自动重启项目的效果，nodemon 文件名

    express路由

     

        创建路由模块

    1. //这是路由模块
    2. //1.导入express
    3. const express = require('express')
    4. //2.创建路由对象
    5. const router = express.Router()
    6. //3.挂载具体的路由
    7. router.get('user/list',(req,res)=>{
    8.     res.send('调用了list接口')
    9. })
    10. //4.导出路由对象
    11. module.exports=router

    注册路由模块

    1. const express = require('express')
    2. const app=express()
    3. const router=require('./路由模块')
    4. app.use(router)
    5. app.listen('80',()=>{
    6.     console.log('服务启动成功');
    7. })

    app.use()函数的作用，就是用来注册全局中间件

    app.use('/api',routre) 给路由添加前缀

    九、express中间件

     

     

     定义中间件函数

    1. const express = require('express')
    2. const app = express()
    3. //定义一个最简单的中间件函数
    4. const mv = (req,res,next)=>{
    5.     console.log('这是最简单的中间件');
    6.     //把流转关系，转交给下一个中间件或路由
    7.     next()
    8. }
    9. app.listen(80,()=>{
    10.     console.log('服务启动成功');
    11. })

     全局express中间件

    1. const express = require('express')
    2. const app = express()
    3. //定义一个最简单的中间件函数
    4. const mv = (req,res,next)=>{
    5.     console.log('这是最简单的中间件');
    6.     //把流转关系，转交给下一个中间件或路由
    7.     next()
    8. }
    9. //将mv注册为全局生效的中间件
    10. app.use(mv)
    11. app.listen(80,()=>{
    12.     console.log('服务启动成功');
    13. })

    全局中间件的简写形式

    1. const express = require('express')
    2. const app = express()
    3. //定义全局中间件的简写形式
    4. app.use((req,res,next)=>{
    5.     console.log('这是最简单的中间件');
    6.     //把流转关系，转交给下一个中间件或路由
    7.     next()
    8. })
    9. app.listen(80,()=>{
    10.     console.log('服务启动成功');
    11. })

    中间件的作用

    1. const express = require('express')
    2. const app = express()
    3. //定义全局中间件的简写形式
    4. app.use((req,res,next)=>{
    5.     // 获取到请求的时间
    6.     const time = Date.now()
    7.     //为req对象，挂载自定义属性，从而把事件共享给后面所有的路由
    8.     req.startTime=time
    9.     next()
    10. })
    11. app.get('/',(req,res)=>{
    12.     res.send('获取到请求的时间：'+req.startTime)
    13. })
    14. app.listen(80,()=>{
    15.     console.log('服务启动成功');
    16. })

     定义多个全局中间件，连续定义，依次执行

     局部中间件的使用

    1. const express= require('express')
    2. const app = express()
    3. const mv=(req,res,next)=>{
    4.     console.log('我是局部中间件');
    5.     next()
    6. }
    7. //第二个参数传入对应的局部中间件
    8. app.get('/',mv,(req,res,)=>{
    9.  
    10. })
    11. app.listen(80,()=>{
    12.     console.log('服务器启动成功');
    13. })

    数组形式或者依次添加

     依次执行，局部中间件需要放到路由前面

     中间件的5大分类

     应用级别的中间件

     

     错误级别的中间件要放在所有路由之后

    1. const express= require('express')
    2. const app = express()
    3. //演示错误中间件
    4. app.get('/',(req,res)=>{
    5.     //人为的制造错误
    6.     throw new Error('服务器内部发生错误')
    7.     res.send('5555')
    8. })
    9. //定义错误级别的中间件，捕获整个项目的异常错误，从而防止程序的崩溃。
    10. app.use((err,req,res,next)=>{
    11.     res.send('错误信息：'+err.message)
    12. })
    13. app.listen(80,()=>{
    14.     console.log('服务器启动成功');
    15. })

     express.json解析body参数

    1. const express= require('express')
    2. const app = express()
    3.  
    4. //注意：除了错误级别的中间件，其他的中间件，必须在路由之前配置
    5.  
    6. //通过express.json() 这个中间件，解析表单中的JSON格式的数据
    7. app.use(express.json())
    8.  
    9. app.post('/',(req,res)=>{
    10.     //在服务端可以通过req.body来接收客户端发来的请求体
    11.     //默认情况下，如果不配置解析表单数据的中间件，则req.body默认等于undefined
    12.     // console.log(req.body);//undefined
    13.     res.send(req.body)
    14. })
    15. app.listen(80,()=>{
    16.     console.log('服务器启动成功');
    17. })

     express.urlencoded()解析urlencoded格式的参数值

    1. const express= require('express')
    2. const app = express()
    3.  
    4. //注意：除了错误级别的中间件，其他的中间件，必须在路由之前配置
    5.  
    6. //通过express.json() 这个中间件，解析表单中的JSON格式的数据
    7. app.use(express.json())
    8. app.use(express.urlencoded({extended:false}))
    9.  
    10. app.post('/',(req,res)=>{
    11.     //在服务端可以通过req.body来接收客户端发来的请求体
    12.     //默认情况下，如果不配置解析表单数据的中间件，则req.body默认等于undefined
    13.     // console.log(req.body);//undefined
    14.     res.send(req.body)
    15. })
    16. app.post('/book',(req,res)=>{
    17.     //在服务器端，可以通过req.body来获取JSON格式的表单数据和url-encoded格式的数据
    18.     console.log(req.body);
    19.     res.send('111')
    20. })
    21. app.listen(80,()=>{
    22.     console.log('服务器启动成功');
    23. })

     自定义中间件

     

     

     

    1. const express = require('express')
    2. const qs= require('querystring')
    3. const app = express()
    4. //自定义解析表单的中间件
    5. app.use((req, res, next) => {
    6.     //定义中间件具体业务逻辑
    7.     //1.定义一个str字符串，专门用来存储客户端发送过来的请求体数据
    8.     let str = ''
    9.     //2.监听req的data事件
    10.     req.on('data', (chunk) => {
    11.         str += chunk
    12.     })
    13.     //3.监听req的end事件
    14.     req.on('end',()=>{
    15.         //打印完整的请求数据
    16.         console.log(str);
    17.         //把字符串格式的请求数据，解析成对象格式
    18.         const body = qs.parse(str)
    19.         // console.log(body);
    20.         req.body=body
    21.         next()
    22.     })
    23.    
    24. })
    25. app.post('/book',(req,res)=>{
    26.     res.send(req.body)
    27. })
    28. app.listen(80, () => {
    29.     console.log('服务器启动成功');
    30. })

     

     使用express开发接口

    进行接口的开发

    服务器文件

    1. const express = require('express')
    2. //引入路由模块
    3. const apiRouter = require('./路由模块化')
    4. const app = express()
    5. app.use(express.json())
    6. app.use('/api', apiRouter)
    7. //创建服务
    8. app.listen(80, () => {
    9.     console.log('服务器启动完成');
    10. })

    模块化文件

    1. const express = require('express')
    2. const apiRouter = express.Router()
    3. //编写get接口
    4. apiRouter.get('/', (req, res) => {
    5.     //通过req.query获取客户端发送过来的数据
    6.     const query = req.query
    7.     res.send({
    8.         code: 200,
    9.         msg: '请求成功',
    10.         data: query
    11.     })
    12. })
    13. //编写post接口
    14. apiRouter.post('/', (req, res) => {
    15.     //获取客户端传递过来的数据
    16.     const body=req.body
    17.     //将数据返回
    18.     res.send({
    19.         code: 200,
    20.         msg: '请求成功',
    21.         data: body
    22.     })
    23. })
    24. module.exports = apiRouter

    基于CORS解决接口跨域的问题

     

     通过CORS解决跨域问题（回去实验下）

    1. const express = require('express')
    2.  
    3. const app = express()
    4. //一定要在路由之前，配置CORS这个中间件，从而解决接口跨域的问题
    5. const cors = require('cors')   //使用const cors=require(’cors‘)导入中间件
    6. app.use(cors()) 
    7. app.use(express.json())
    8. //引入路由模块
    9. const apiRouter = require('./路由模块化')
    10.  
    11.  
    12. app.use('/api', apiRouter)
    13. //创建服务
    14. app.listen(80, () => {
    15.     console.log('服务器启动完成');
    16. })

    什么是CORS

     

     

     

     简单请求

    预检请求

      

     JSONP接口

     

     

     十、MySQL的使用

      

     安装MySQL

    主要组成部分 

     基本使用

  • 相关阅读:
    SSM教学网站毕业设计-附源码211611
    《HelloGitHub》第 80 期
    Django 入门学习总结5
    Hawkeye
    有趣的23000----整理（10）G词根
    STM32Cube高效开发教程＜基础篇＞(四)----GPIO输入/输出
    编程面试_数组
    Linux软链接妙用（硬链接妙用）
    slam数学补充
    数据结构面试整理
  • 原文地址：https://blog.csdn.net/ct5211314/article/details/127515609