Nodejs资料之异步编程

◆ 同步API和异步API：

1、同步API：

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

for (var i = 0; i < 100000; i++) { 
    console.log(i);
}
console.log('for循环后面的代码');

2、异步API：

当前API的执行不会阻塞后续代码的执行

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

3、区别：

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

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

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

◆ 代码执行顺序分析：

代码：

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

执行顺序：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xu9DjWin-1577409930322)(en-resource://database/6194:1)]

◆ 回调函数：

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

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

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

扫描二维码关注公众号，回复： 8792478 查看本文章

function getMsg (callback) {
    setTimeout(function () {
        callback ({ msg: 'Hello Node.js' })
    }, 2000);
}
getMsg (function (msg) { 
    console.log(msg);
});

◆ Promise类：

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

const fs = require('fs');

let promise = new Promise((resolve, reject) => {
	fs.readFile('./100.txt', 'utf8', (err, result) => {
		if (err != null) {
			reject(err);
		}else {
			resolve(result);
		}
	});
});

promise.then((result) => {
	 console.log(result);
})
.catch((err)=> {
	console.log(err);
})

示例：顺序读取1.txt、2.txt和3.txt

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

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

◆ 异步函数：

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

const fn = async () => {};

async function fn () {}

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)
	console.log(r2)
	console.log(r3)
}

run();

◆ promisify：

promisify方法可以改造现有异步API，让其返回promise对象。

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