Node

Node后端路由基本原理

• 后端路由其实就是一个web服务器
• 路：url路径
• 单页面 会将另外的页面做成模板 ，替换主页面里面的内容
  • ejs 、pug(jade) Node.js专用
    • ejs e-effective 高效 模板语言帮你利用普通的 JavaScript 代码生成 HTML 页面
    • 官网
    • Pug 是一款健壮、灵活、功能丰富的模板引擎,专门为 Node.js 平台开发。Pug 是由 Jade 改名而来。
  • art-template 后端使用
• 服务器 （http）通过switch条件判断请求的url
  读取相关文件 静态服务器发送至前端
• 读取js文件 在HTML中将js文件引入 路径引入为case中的url
  读取文件 前端响应
• 读取图片文件 HTML中img引入 src为为case中的url 返回数据需要设置其binary response.write(data,'binary)
• 路由：路径的变化 渲染不同的内容
• 后端框架express 的路由的原理

npm脚本（npm scripts）

• npm脚本指的是package.json中的scripts字段
• npm 允许在package.json文件里面，使用scripts字段定义脚本命令。
• package.json是记录项目依赖包信息和nom脚本命令的一个配置文件
  • dependencies 生产环境的依赖包
  • devDependencies 开发环境使用的依赖包
• 脚本命令 在命令行执行的脚本命令

[外链图片转存失败(img-tuQLDArj-1563364726943)(C:\Users\Administrator\Desktop\npmscripts.bmp)]

• & vs &&
  • npm run dev & npm run app 全部执行完命令 最后输出结果
  • npm run dev && npm runn app 依次执行

前端异步流程工具

1. 为什么要进行异步操作

   • javascripts是单线程，而我们依次执行 一个任务，要想让任务能够顺利执行，需要排队，异步就是将任务放入异步队列，在主线程执行结束之后再去执行

     • 前端异步的操作方式：
       • 传统方式：回调函数 事件
     • 前端异步流程工具
       • es6 Promise
       • es6 Generator 函数
       • es6—es8 async 函数
       • Node中的异步处理工具
         • nextTick
         • setImmediate
       • 第三方类库 async.js

     promise

     const p1=new Promise((resolve,reject)=>{
          resolve('p1')
     }).then(data=>
         console.log(data);//success
     }).catch(error=>{
         if(error)throw error//throw抛错 这个时候会终止进程
     })
     const p2=new Promise((resolve,reject)=>{
          resolve('p2')
     }).then(data=>
         console.log(data);//success
     }).catch(error=>{
         if(error)throw error//throw抛错 这个时候会中断进程
     })
     //成功状态  resolve
     //失败状态 reject
     //Promise.all([p1,p2]).then(data=>{
     //数组中的都完成（resolve），如果参数中有一个失败 回调失败（reject）
     })
     Promise.race([p1.p2]).then(data=>{
         //race 赛跑   race指的是 任务快 的先进行，其他延时任务后续进行
     })
     

     generator生成器函数

     //function* 函数名(){
     //yield 任务名
     //}
     function*  p1(){
     yield '任务一'
     yield '任务二'
     yield '任务三'
     return '任务四'
     }
     const task =p1()//调用之后返回迭代器对象 
     console.log(task.next())
     console.log(task.next())
     console.log(task.next())
     console.log(task.next())//通过next方法来遍历执行任务
     //{ value: '任务一', done: false }
     //{ value: '任务二', done: false }
     //{ value: '任务三', done: false }
     //{ value: '任务四', done: true }
     
     //value表示任务执行的结果
     //done 表示总任务执行状态 
     //若generator函数中不存在return 则done状态最后也为false
     //函数必须有一个return任务 ，done才可以为true
     

     async函数（async-await）

     • 函数function前面加async

     • await 表示等待一个异步任务完成才返回任务结果

       async function p1(){
           const result = await '任务一';
           return result
       }
       //console.log(p1());//Promise { <pending> }
       //返回的是一个Promise对象
       //所以可以用then方法
       p1().then(data=>{console.log(data)})//任务一
       

       Node异步处理工具

       • nextTick
       • setImmediate

       //原生的全局对象为window
       //Node.js全局对象为global
       process.nextTick(()=>{
       console.log(1)
       })
       setImmediate(()=>{
       console.log(2)
       })(
       process.nextTick(()=>{
       console.log(3)
       });
       console.log('主线程')
       //主线程
       //1
       //3
       //2
       
       //nextTick() 为第一个人
       //它和setImmediate()执行的顺序不一样，它是在事件轮询之前执行，为了防止I/O饥饿，所以有一个默认process.maxTickDepth=1000来限制事件队列的每次循环可执行的nextTick()事件的数目。
       //setImmediate()为最后一个人 
       //即时计时器立即执行工作，它是在事件轮询之后执行,为了防止轮询阻塞,每次只会调用一个。
       //nodejs中是事件驱动的，有一个循环线程一直从事件队列中取任务执行或者I/O的操作转给后台线程池来操作,把这个循环线程的每次执行的过程算是一次轮询.
       
       //nextTick()的回调函数执行的优先级要高于setImmediate();
       //process.nextTick()属于idle观察者,setImmediate()属于check观察者.在每一轮循环检查中,idle观察者先于I/O观察者,I/O观察者先于check观察者.
       
       

       第三方类库：async.js

       • 多任务执行

       • series 表示串行

         //series([task1,task2],callback)
         //串行：表示两个任务在一个任务线上，任意一个任务崩溃，其余任务全部无法执行
         const {series,parallel}=require('async')
         series([
             function(callback){
                 callback(null,'one')
             },
             function(callback){
                 callback(null,'two')
             }
             
         ],function(err,results){
             console.log(results)
         })
         
         
         //parallel 并行
         parallel([
             function(callback){
                 callback(null,1)
             },function(callback){
                 callback(null,2)
             }
         ],function(err,results){
             console.log(results)
         })
         

       async-await-promise模块化请求接口

       • async-await 内层请求数据接口返回外层promise使用

       • request请求

       • module.exports暴露接口

       • require导出

         const request=require(request);
         
         const status={
             init(){
                 return new Promise((resolve,reject)=>{
                     request('',(error,rsponse,body)=>{
                         resolve(body)
                     })
                     
                 })
             }
         }
         

         const p2=require('./path');
         //1
         const p1=async ()=>{
             const results=await init();
             return results
         }
         
         p2();
         //2
         
         const p1=()=>{
             const result=init().then(res=>{
                 console.log(res)
             })
         }
         p1();
         
         
         

     ​

     const p1=()=>{
         const result=init().then(res=>{
             console.log(res)
         })
     }
     p1();
     
     
     ```
     

     ​