06JavaScript-同步、异步、回调、Promise、as

同步API, 异步API

• 同步API：只有当前API执行完成后，才能继续执行下一个API

console.log('before') //先before 
console.log('after');//再after

• 异步API：当前API的执行不会阻塞后续代码的执行

console.log('before');
setTimeout(function (){
    console.log('last');
}, 0)//定时器是异步API

console.log('after');
//先输出before
//再输出after
//最后输出last

执行结果.png

同步API, 异步API的区别（ 获取返回值 ）

• 同步API可以从返回值中拿到API执行的结果, 但是异步API是不可以的
  同步：

    // 同步
  function sum (n1, n2) { 
      return n1 + n2;
  } 
  const result = sum (10, 20);
  console.log(result ) //30

异步：

   // 异步
  function getMsg () { 
      setTimeout(function () { 
          return { msg: 'Hello Node.js' }
      }, 2000);
  }
  const msg = getMsg ();
  console.log(msg) //undefined

• 异步API的返回值需要通过回调来拿到
  自己定义函数让别人去调用

function getData (callback) {
    callback('123')
}
getData(function (n) {
    console.log('callback函数被调用了') //callback函数被调用了
    console.log(n) //123
});

使用回调函数获取异步API执行结果

function getMsg (callback) {
    setTimeout(function () {
        callback({
            msg: 'hello node.js'
        })
    }, 2000)
}
getMsg(function (data) {
    console.log(data); //{ msg: 'hello node.js' }
});

同步API, 异步API的区别（代码执行顺序）

• 同步API从上到下依次执行，前面代码会阻塞后面代码的执行

for (var i = 0; i < 100000; i++) {
    console.log(i)
}
console.log('for循环后面的代码')
//先执行了100000次排序
//后执行了:for循环后面的代码

• 异步API不会等待API执行完成后再向下执行代码

console.log('代码开始执行')
setTimeout(function () {
    console.log('2s')
}, 2000)
setTimeout(function () {
    console.log('0s')
}, 0)
console.log('代码结束执行')
// 1.代码开始执行
// 2.代码结束执行
// 3.0s
// 4.2s

代码执行顺序分析

代码执行顺序分析.png

Node.js中的异步API

 fs.readFile('./demo.txt', (err, result) => {});

 var server = http.createServer();
 server.on('request', (req, res) => {});

• 如果异步API后面代码的执行依赖当前异步API的执行结果，但实际上后续代码在执行的时候异步API还没有返回结果，这个问题要怎么解决呢？

fs.readFile('./demo.txt', (err, result) => {});
console.log('文件读取结果');

• 需求：依次读取A文件、B文件、C文件

const fs = require('fs');
fs.readFile('./1.txt', 'utf8', (err, result1) => {
    console.log(result1)
    fs.readFile('./2.txt', 'utf8', (err, result2) => {
        console.log(result2)
        fs.readFile('./3.txt', 'utf8', (err, result3) => {
            console.log(result3)
        })
    })
});

Promise

• Promise出现的目的是解决Node.js异步编程中回调地狱的问题。

const fs = require('fs')
let promise = new Promise((resolve, reject) => {
    fs.readFile('./1.txt','utf8',(err,result) => {
        if (err  != null) {
            reject(err)
        } else{
            resolve(result)
        }
    })
})
promise.then((result) => {
    console.log(result) //成功时
})
.catch((err)=> {
    console.log(err); //失败时
})

当读多个文件的时候

function p1 () {
    return new Promise ((resolve, reject) => {
        fs.readFile('./1.txt', 'utf8', (err, result) => {
            resolve(result)
        })
    });
}

function p2 () {
    return new Promise ((resolve, reject) => {
        fs.readFile('./2.txt', 'utf8', (err, result) => {
            resolve(result)
        })
    });
}

function p3 () {
    return new Promise ((resolve, reject) => {
        fs.readFile('./3.txt', 'utf8', (err, result) => {
            resolve(result)
        })
    });
}

p1().then((r1)=> {
    console.log(r1);
    return p2();
})
.then((r2)=> {
    console.log(r2);
    return p3();
})
.then((r3) => {
    console.log(r3)
})

async关键字

异步函数
异步函数是异步编程语法的终极解决方案，它可以让我们将异步代码写成同步的形式，让代码不再有回调函数嵌套，使代码变得清晰明了

const fn = async () => {}

async function fn () {}

1.在普通函数定义的前面加上async关键字 普通函数就变成了异步函数
2.异步函数默认的返回值是promise对象
3.在异步函数内部使用throw关键字进行错误的抛出

async function fn () {
    throw '发生了一些错误';
    return 123;
}
// console.log(fn ())
fn ().then(function (data) {
    console.log(data);
}).catch(function (err){
    console.log(err);
})

总结

1. 普通函数定义前加async关键字 普通函数变成异步函数
2. 异步函数默认返回promise对象
3. 在异步函数内部使用return关键字进行结果返回 结果会被包裹的promise对象中 return关键字代替了resolve方法
4. 在异步函数内部使用throw关键字抛出程序异常
5. 调用异步函数再链式调用then方法获取异步函数执行结果
6. 调用异步函数再链式调用catch方法获取异步函数执行的错误信息

await关键字

1. await关键字只能出现在异步函数中
2. await promise await后面只能写promise对象 写其他类型的API是不不可以的
3. await关键字可是暂停异步函数向下执行 直到promise返回结果

async function p1 () {
    return 'p1';
}
async function p2 () {
    return 'p2';
}
async function p3 () {
    return 'p3';
}
async function run () {
    let r1 = await p1()
    let r2 = await p2()
    let r3 = await p3()
    console.log(r1) //p1
    console.log(r2) //p2
    console.log(r3) //p3
}
run();

async&&await

const fs = require('fs');
// 改造现有异步函数api 让其返回promise对象 从而支持异步函数语法
const promisify = require('util').promisify;
// 调用promisify方法改造现有异步API 让其返回promise对象
const readFile = promisify(fs.readFile);

async function run () {
    let r1 = await readFile('./1.txt', 'utf8')
    let r2 = await readFile('./2.txt', 'utf8')
    let r3 = await readFile('./3.txt', 'utf8')
    console.log(r1)
    console.log(r2)
    console.log(r3)
}
run();