同步异步

1.同步API，异步API的区别（获取返回值）

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

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

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

2. 回调函数

自己定义函数让别人去调用。

 // getData函数定义
 function getData (callback) {}
 // getData函数调用
 getData (() => {});

3. 代码执行顺序分析

console.log('代码开始执行');
setTimeout(() => {
    console.log('2秒后执行的代码');
}, 2000); 
setTimeout(() => {
    console.log('"0秒"后执行的代码');
}, 0);
console.log('代码结束执行');

4. promise

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

let promise = new Promise((resolve, reject) => {
  setTimeout(()=> {
    if (true) {
      resolve({name: '张三'})
    } else {
      reject('失败了')
    }
  }, 2000);
});
promise.then(result => console.log(result))  // {name: '张三'}
      .catch(error => console.log(error)); // 失败了

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);
})

先后打印三个异步函数

const fs = require('fs');
function p1() {
  return new Promise((resolve, reject)=> {
    fs.readFile('./1.txt', 'utf8', (err, result)=> {
      if( err !== null) {
        reject(err)
      } else {
        resolve(result);
      }
      
    })
  });
}
function p2() {
  return new Promise((resolve, reject)=> {
    fs.readFile('./2.txt', 'utf8', (err, result)=> {
      if( err !== null) {
        reject(err)
      } else {
        resolve(result);
      }
    })
  });
}
function p3() { 
  return new Promise((resolve, reject)=> {
    fs.readFile('./3.txt', 'utf8', (err, result)=> {
      if( err !== null) {
        reject(err)
      } else {
        resolve(result);
      }
    })
  });
}

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

 5. async

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

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

// 1. 在普通函数定义的前面加上async关键字，普通函数就变成了异步函数
// 2. 异步函数默认的返回值是promise对象
// 3. 在异步函数内使用throw关键字进行错误的抛出
async function fn () {
  throw '发生了一些错误'
  return 123;
}
fn().then(data => {
  console.log(data)
}).catch(error=> {
  console.log(error);
})

await关键字

• 它只能出现在异步函数中
• await promise 它可以暂停异步函数的执行，等待promise对象返回结果后再向下执行函数

async function p1() {
  return 'p1';
}
async function p2() {
  return 'p2';
}
async function p3() {
  return 'p3';
}
async function run () {
  await p1()
  await p2()
  await p3()
}

const fs = require('fs');
const promisify = require('util').promisify;

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();