Flutter(五)之完全搞懂Dart异步

时间 2019-11-06 标签 flutter 完全 dart 异步

前言一：接下来一段时间我会陆续更新一些列Flutter文字教程前端

更新进度： 每周至少两篇；vue

更新地点： 首发于公众号，次日更新于掘金、思否等地方；面试

更多交流： 能够添加个人微信 372623326，关注个人微博：coderwhy算法

但愿你们能够 帮忙转发，点击在看，给我更多的创做动力。编程

前言二：在写这篇文章以前，我一直在犹豫，要不要在这里讲解Dart的异步相关话题，由于这部份内容很容易让初学者望而却步：json

一、关于单线程和异步之间的关系，比较容易让人迷惑，虽然我必定会用本身的方式尽量让你听懂。数组

二、大量的异步操做方式（Future、await、async等），目前你看不到具体的应用场景。（好比你学习过前端中的Promise、await、async可能会比较简单，可是我会假设你没有这样的基础）。微信

不过，听我说：若是这一个章节你学完以后还有不少疑惑，没有关系，在后面用到相关知识时，回头来看，你会豁然开朗。网络

一. Dart的异步模型

咱们先来搞清楚Dart是如何搞定异步操做的数据结构

1.1. Dart是单线程的

1.1.1. 程序中的耗时操做

开发中的耗时操做：

在开发中，咱们常常会遇到一些耗时的操做须要完成，好比网络请求、文件读取等等；
若是咱们的主线程一直在等待这些耗时的操做完成，那么就会进行阻塞，没法响应其它事件，好比用户的点击；
显然，咱们不能这么干！！

如何处理耗时的操做呢？

针对如何处理耗时的操做，不一样的语言有不一样的处理方式。
处理方式一： 多线程，好比Java、C++，咱们广泛的作法是开启一个新的线程（Thread），在新的线程中完成这些异步的操做，再经过线程间通讯的方式，将拿到的数据传递给主线程。
处理方式二： 单线程+事件循环，好比JavaScript、Dart都是基于单线程加事件循环来完成耗时操做的处理。不过单线程如何能进行耗时的操做呢？！

1.1.2. 单线程的异步操做

我以前碰到不少开发者都对单线程的异步操做充满了问号？？？

其实它们并不冲突：

由于咱们的一个应用程序大部分时间都是处于空闲的状态的，并非无限制的在和用户进行交互。
好比等待用户点击、网络请求数据的返回、文件读写的IO操做，这些等待的行为并不会阻塞咱们的线程；
这是由于相似于网络请求、文件读写的IO，咱们均可以基于非阻塞调用；

阻塞式调用和非阻塞式调用

若是想搞懂这个点，咱们须要知道操做系统中的阻塞式调用和非阻塞式调用的概念。

阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态。
阻塞式调用： 调用结果返回以前，当前线程会被挂起，调用线程只有在获得调用结果以后才会继续执行。
非阻塞式调用： 调用执行以后，当前线程不会中止执行，只须要过一段时间来检查一下有没有结果返回便可。

咱们用一个生活中的例子来模拟：

你中午饿了，须要点一份外卖，点外卖的动做就是咱们的调用，拿到最后点的外卖就是咱们要等待的结果。
阻塞式调用： 点了外卖，再也不作任何事情，就是在傻傻的等待，你的线程中止了任何其余的工做。
非阻塞式调用： 点了外卖，继续作其余事情：继续工做、打把游戏，你的线程没有继续执行其余事情，只须要偶尔去看一下有没有人敲门，外卖有没有送到便可。

而咱们开发中的不少耗时操做，均可以基于这样的 非阻塞式调用：

好比网络请求自己使用了Socket通讯，而Socket自己提供了select模型，能够进行非阻塞方式的工做；
好比文件读写的IO操做，咱们可使用操做系统提供的基于事件的回调机制；

这些操做都不会阻塞咱们单线程的继续执行，咱们的线程在等待的过程当中能够继续去作别的事情：喝杯咖啡、打把游戏，等真正有了响应，再去进行对应的处理便可。

这时，咱们可能有两个问题：

问题一： 若是在多核CPU中，单线程是否是就没有充分利用CPU呢？这个问题，我会放在后面来说解。
问题二： 单线程是如何来处理网络通讯、IO操做它们返回的结果呢？答案就是事件循环（Event Loop）。

1.2. Dart事件循环

1.2.1. 什么是事件循环

单线程模型中主要就是在维护着一个事件循环（Event Loop）。

事件循环是什么呢？

事实上事件循环并不复杂，它就是将须要处理的一系列事件（包括点击事件、IO事件、网络事件）放在一个事件队列（Event Queue）中。
不断的从事件队列（Event Queue）中取出事件，并执行其对应须要执行的代码块，直到事件队列清空位置。

咱们来写一个事件循环的伪代码：

// 这里我使用数组模拟队列, 先进先出的原则
List eventQueue = []; 
var event;

// 事件循环从启动的一刻，永远在执行
while (true) {
  if (eventQueue.length > 0) {
    // 取出一个事件
    event = eventQueue.removeAt(0);
    // 执行该事件
    event();
  }
}
复制代码

当咱们有一些事件时，好比点击事件、IO事件、网络事件时，它们就会被加入到eventLoop中，当发现事件队列不为空时发现，就会取出事件，而且执行。

齿轮就是咱们的事件循环，它会从队列中一次取出事件来执行。

1.2.2. 事件循环代码模拟

这里咱们来看一段伪代码，理解点击事件和网络请求的事件是如何被执行的：

这是一段Flutter代码，不少东西你们可能不是特别理解，可是耐心阅读你会读懂咱们在作什么。
一个按钮RaisedButton，当发生点击时执行onPressed函数。
onPressed函数中，咱们发送了一个网络请求，请求成功后会执行then中的回调函数。

RaisedButton(
  child: Text('Click me'),
  onPressed: () {
    final myFuture = http.get('https://example.com');
    myFuture.then((response) {
      if (response.statusCode == 200) {
        print('Success!');
      }
    });
  },
)
复制代码

这些代码是如何放在事件循环中执行呢？

一、当用户发生点击的时候，onPressed回调函数被放入事件循环中执行，执行的过程当中发送了一个网络请求。
二、网络请求发出去后，该事件循环不会被阻塞，而是发现要执行的onPressed函数已经结束，会将它丢弃掉。
三、网络请求成功后，会执行then中传入的回调函数，这也是一个事件，该事件被放入到事件循环中执行，执行完毕后，事件循环将其丢弃。

尽管onPressed和then中的回调有一些差别，可是它们对于事件循环来讲，都是告诉它：我有一段代码须要执行，快点帮我完成。

二. Dart的异步操做

Dart中的异步操做主要使用Future以及async、await。

若是你以前有过前端的ES六、ES7编程经验，那么彻底能够将Future理解成Promise，async、await和ES7中基本一致。

可是若是没有前端开发经验，Future以及async、await如何理解呢？

2.1. 认识Future

我思考了好久，这个Future到底应该如何讲解

2.1.1. 同步的网络请求

咱们先来看一个例子吧：

在这个例子中，我使用getNetworkData来模拟了一个网络请求；
该网络请求须要3秒钟的时间，以后返回数据；

import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

String getNetworkData() {
  sleep(Duration(seconds: 3));
  return "network data";
}
复制代码

这段代码会运行怎么的结果呢？

getNetworkData会阻塞main函数的执行

main function start
// 等待3秒
network data
main function end
复制代码

显然，上面的代码不是咱们想要的执行效果，由于网络请求阻塞了main函数，那么意味着其后全部的代码都没法正常的继续执行。

2.1.2. 异步的网络请求

咱们来对咱们上面的代码进行改进，代码以下：

和刚才的代码惟一的区别在于我使用了Future对象来将耗时的操做放在了其中传入的函数中；
稍后，咱们会讲解它具体的一些API，咱们就暂时知道我建立了一个Future实例便可；

import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    return "network data";
  });
}
复制代码

咱们来看一下代码的运行结果：

一、这一次的代码顺序执行，没有出现任何的阻塞现象；
二、和以前直接打印结果不一样，此次咱们打印了一个Future实例；
结论：咱们将一个耗时的操做隔离了起来，这个操做不会再影响咱们的主线程执行了。
问题：咱们如何去拿到最终的结果呢？

main function start
Instance of 'Future<String>'
main function end
复制代码

获取Future获得的结果

有了Future以后，如何去获取请求到的结果：经过.then的回调：

main(List<String> args) {
  print("main function start");
  // 使用变量接收getNetworkData返回的future
  var future = getNetworkData();
  // 当future实例有返回结果时，会自动回调then中传入的函数
  // 该函数会被放入到事件循环中，被执行
  future.then((value) {
    print(value);
  });
  print(future);
  print("main function end");
}
复制代码

上面代码的执行结果：

main function start
Instance of 'Future<String>'
main function end
// 3s后执行下面的代码
network data
复制代码

执行中出现异常

若是调用过程当中出现了异常，拿不到结果，如何获取到异常的信息呢？

import "dart:io";

main(List<String> args) {
  print("main function start");
  var future = getNetworkData();
  future.then((value) {
    print(value);
  }).catchError((error) { // 捕获出现异常时的状况
    print(error);
  });
  print(future);
  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    // 再也不返回结果，而是出现异常
    // return "network data";
    throw Exception("网络请求出现错误");
  });
}

复制代码

上面代码的执行结果：

main function start
Instance of 'Future<String>'
main function end
// 3s后没有拿到结果，可是咱们捕获到了异常
Exception: 网络请求出现错误

复制代码

2.1.3. Future使用补充

补充一：上面案例的小结

咱们经过一个案例来学习了一些Future的使用过程：

一、建立一个Future（多是咱们建立的，也多是调用内部API或者第三方API获取到的一个Future，总之你须要获取到一个Future实例，Future一般会对一些异步的操做进行封装）；
二、经过.then(成功回调函数)的方式来监听Future内部执行完成时获取到的结果；
三、经过.catchError(失败或异常回调函数)的方式来监听Future内部执行失败或者出现异常时的错误信息；

补充二：Future的两种状态

事实上Future在执行的整个过程当中，咱们一般把它划分红了两种状态：

状态一：未完成状态（uncompleted）

执行Future内部的操做时（在上面的案例中就是具体的网络请求过程，咱们使用了延迟来模拟），咱们称这个过程为未完成状态

状态二：完成状态（completed）

当Future内部的操做执行完成，一般会返回一个值，或者抛出一个异常。
这两种状况，咱们都称Future为完成状态。

Dart官网有对这两种状态解析，之因此贴出来是区别于Promise的三种状态

补充三：Future的链式调用

上面代码咱们能够进行以下的改进：

咱们能够在then中继续返回值，会在下一个链式的then调用回调函数中拿到返回的结果

import "dart:io";

main(List<String> args) {
  print("main function start");

  getNetworkData().then((value1) {
    print(value1);
    return "content data2";
  }).then((value2) {
    print(value2);
    return "message data3";
  }).then((value3) {
    print(value3);
  });

  print("main function end");
}

Future<String> getNetworkData() {
  return Future<String>(() {
    sleep(Duration(seconds: 3));
    // 再也不返回结果，而是出现异常
     return "network data1";
  });
}

复制代码

打印结果以下：

main function start
main function end
// 3s后拿到结果
network data1
content data2
message data3

复制代码

补充四：Future其余API

Future.value(value)

直接获取一个完成的Future，该Future会直接调用then的回调函数

main(List<String> args) {
  print("main function start");

  Future.value("哈哈哈").then((value) {
    print(value);
  });

  print("main function end");
}

复制代码

打印结果以下：

main function start
main function end
哈哈哈

复制代码

疑惑：为何当即执行，可是哈哈哈是在最后打印的呢？

这是由于Future中的then会做为新的任务会加入到事件队列中（Event Queue），加入以后你确定须要排队执行了

Future.error(object)

直接获取一个完成的Future，可是是一个发生异常的Future，该Future会直接调用catchError的回调函数

main(List<String> args) {
  print("main function start");

  Future.error(Exception("错误信息")).catchError((error) {
    print(error);
  });

  print("main function end");
}

复制代码

打印结果以下：

main function start
main function end
Exception: 错误信息

复制代码

Future.delayed(时间, 回调函数)

在延迟必定时间时执行回调函数，执行完回调函数后会执行then的回调；
以前的案例，咱们也可使用它来模拟，可是直接学习这个API会让你们更加疑惑；

main(List<String> args) {
  print("main function start");

  Future.delayed(Duration(seconds: 3), () {
    return "3秒后的信息";
  }).then((value) {
    print(value);
  });

  print("main function end");
}

复制代码

2.2. await、async

2.2.1. 理论概念理解

若是你已经彻底搞懂了Future，那么学习await、async应该没有什么难度。

await、async是什么呢？

它们是Dart中的关键字（你这不是废话吗？废话也仍是要强调的，万一你用它作变量名呢，无辜脸。）
它们可让咱们用同步的代码格式，去实现异步的调用过程。
而且，一般一个async的函数会返回一个Future（别着急，立刻就看到代码了）。

咱们已经知道，Future能够作到不阻塞咱们的线程，让线程继续执行，而且在完成某个操做时改变本身的状态，而且回调then或者errorCatch回调。

如何生成一个Future呢？

一、经过咱们前面学习的Future构造函数，或者后面学习的Future其余API均可以。
二、还有一种就是经过async的函数。

2.2.2. 案例代码演练

Talk is cheap. Show me the code.

咱们来对以前的Future异步处理代码进行改造，改为await、async的形式。

咱们知道，若是直接这样写代码，代码是不能正常执行的：

由于Future.delayed返回的是一个Future对象，咱们不能把它当作同步的返回数据："network data"去使用
也就是咱们不能把这个异步的代码当作同步同样去使用！

import "dart:io";

main(List<String> args) {
  print("main function start");
  print(getNetworkData());
  print("main function end");
}

String getNetworkData() {
  var result = Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return  "请求到的数据：" + result;
}

复制代码

如今我使用await修改下面这句代码：

你会发现，我在Future.delayed函数前加了一个await。
一旦有了这个关键字，那么这个操做就会等待Future.delayed的执行完毕，而且等待它的结果。

String getNetworkData() {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return  "请求到的数据：" + result;
}

复制代码

修改后执行代码，会看到以下的错误：

错误很是明显：await关键字必须存在于async函数中。
因此咱们须要将getNetworkData函数定义成async函数。

继续修改代码以下：

也很是简单，只须要在函数的()后面加上一个async关键字就能够了

String getNetworkData() async {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return  "请求到的数据：" + result;
}

复制代码

运行代码，依然报错（心想：你妹啊）：

错误很是明显：使用async标记的函数，必须返回一个Future对象。
因此咱们须要继续修改代码，将返回值写成一个Future。

继续修改代码以下：

Future<String> getNetworkData() async {
  var result = await Future.delayed(Duration(seconds: 3), () {
    return "network data";
  });

  return "请求到的数据：" + result;
}

复制代码

这段代码应该是咱们理想当中执行的代码了

咱们如今能够像同步代码同样去使用Future异步返回的结果；
等待拿到结果以后和其余数据进行拼接，而后一块儿返回；
返回的时候并不须要包装一个Future，直接返回便可，可是返回值会默认被包装在一个Future中；

2.3. 读取json案例

我这里给出了一个在Flutter项目中，读取一个本地的json文件，而且转换成模型对象，返回出去的案例；

这个案例做为你们学习前面Future和await、async的一个参考，我并不打算展开来说，由于须要用到Flutter的相关知识；

后面我会在后面的案例中再次讲解它在Flutter中我使用的过程当中；

读取json案例代码（了解一下便可）

import 'package:flutter/services.dart' show rootBundle;
import 'dart:convert';
import 'dart:async';

main(List<String> args) {
  getAnchors().then((anchors) {
    print(anchors);
  });
}

class Anchor {
  String nickname;
  String roomName;
  String imageUrl;

  Anchor({
    this.nickname,
    this.roomName,
    this.imageUrl
  });

  Anchor.withMap(Map<String, dynamic> parsedMap) {
    this.nickname = parsedMap["nickname"];
    this.roomName = parsedMap["roomName"];
    this.imageUrl = parsedMap["roomSrc"];
  }
}

Future<List<Anchor>> getAnchors() async {
  // 1.读取json文件
  String jsonString = await rootBundle.loadString("assets/yz.json");

  // 2.转成List或Map类型
  final jsonResult = json.decode(jsonString);

  // 3.遍历List，而且转成Anchor对象放到另外一个List中
  List<Anchor> anchors = new List();
  for (Map<String, dynamic> map in jsonResult) {
    anchors.add(Anchor.withMap(map));
  }
  return anchors;
}

复制代码

三. Dart的异步补充

3.1. 任务执行顺序

3.1.1. 认识微任务队列

在前面学习学习中，咱们知道Dart中有一个事件循环（Event Loop）来执行咱们的代码，里面存在一个事件队列（Event Queue），事件循环不断从事件队列中取出事件执行。

可是若是咱们严格来划分的话，在Dart中还存在另外一个队列：微任务队列（Microtask Queue）。

微任务队列的优先级要高于事件队列；
也就是说事件循环都是优先执行微任务队列中的任务，再执行 事件队列 中的任务；

那么在Flutter开发中，哪些是放在事件队列，哪些是放在微任务队列呢？

全部的外部事件任务都在事件队列中，如IO、计时器、点击、以及绘制事件等；
而微任务一般来源于Dart内部，而且微任务很是少。这是由于若是微任务很是多，就会形成事件队列排不上队，会阻塞任务队列的执行（好比用户点击没有反应的状况）；

说道这里，你可能已经有点凌乱了，在Dart的单线程中，代码究竟是怎样执行的呢？

一、Dart的入口是main函数，因此main函数中的代码会优先执行；
二、main函数执行完后，会启动一个事件循环（Event Loop）就会启动，启动后开始执行队列中的任务；
三、首先，会按照先进先出的顺序，执行 微任务队列（Microtask Queue）中的全部任务；
四、其次，会按照先进先出的顺序，执行 事件队列（Event Queue）中的全部任务；

3.1.2. 如何建立微任务

在开发中，咱们能够经过dart中async下的scheduleMicrotask来建立一个微任务：

import "dart:async";

main(List<String> args) {
  scheduleMicrotask(() {
    print("Hello Microtask");
  });
}
复制代码

在开发中，若是咱们有一个任务不但愿它放在Event Queue中依次排队，那么就能够建立一个微任务了。

Future的代码是加入到事件队列仍是微任务队列呢？

Future中一般有两个函数执行体：

Future构造函数传入的函数体
then的函数体（catchError等同看待）

那么它们是加入到什么队列中的呢？

Future构造函数传入的函数体放在事件队列中
then的函数体要分红三种状况：
状况一：Future没有执行完成（有任务须要执行），那么then会直接被添加到Future的函数执行体后；
状况二：若是Future执行完后就then，该then的函数体被放到如微任务队列，当前Future执行完后执行微任务队列；
状况三：若是Future世链式调用，意味着then未执行完，下一个then不会执行；

// future_1加入到eventqueue中，紧随其后then_1被加入到eventqueue中
Future(() => print("future_1")).then((_) => print("then_1"));

// Future没有函数执行体，then_2被加入到microtaskqueue中
Future(() => null).then((_) => print("then_2"));

// future_三、then_3_a、then_3_b依次加入到eventqueue中
Future(() => print("future_3")).then((_) => print("then_3_a")).then((_) => print("then_3_b"));
复制代码

3.1.3. 代码执行顺序

咱们根据前面的规则来学习一个极的代码执行顺序案例：

import "dart:async";

main(List<String> args) {
  print("main start");

  Future(() => print("task1"));
	
  final future = Future(() => null);

  Future(() => print("task2")).then((_) {
    print("task3");
    scheduleMicrotask(() => print('task4'));
  }).then((_) => print("task5"));

  future.then((_) => print("task6"));
  scheduleMicrotask(() => print('task7'));

  Future(() => print('task8'))
    .then((_) => Future(() => print('task9')))
    .then((_) => print('task10'));

  print("main end");
}

复制代码

代码执行的结果是：

main start
main end
task7
task1
task6
task2
task3
task5
task4
task8
task9
task10

复制代码

代码分析：

一、main函数先执行，因此main start和main end先执行，没有任何问题；
二、main函数执行过程当中，会将一些任务分别加入到EventQueue和MicrotaskQueue中；
三、task7经过scheduleMicrotask函数调用，因此它被最先加入到MicrotaskQueue，会被先执行；
四、而后开始执行EventQueue，task1被添加到EventQueue中被执行；
五、经过final future = Future(() => null);建立的future的then被添加到微任务中，微任务直接被优先执行，因此会执行task6；
六、一次在EventQueue中添加task二、task三、task5被执行；
七、task3的打印执行完后，调用scheduleMicrotask，那么在执行完此次的EventQueue后会执行，因此在task5后执行task4（注意：scheduleMicrotask的调用是做为task3的一部分代码，因此task4是要在task5以后执行的）
八、task八、task九、task10一次添加到EventQueue被执行；

事实上，上面的代码执行顺序有可能出如今面试中，咱们开发中一般不会出现这种复杂的嵌套，而且须要彻底搞清楚它的执行顺序；

可是，了解上面的代码执行顺序，会让你对EventQueue和microtaskQueue有更加深入的理解。

3.2. 多核CPU的利用

3.2.1. Isolate的理解

在Dart中，有一个Isolate的概念，它是什么呢？

咱们已经知道Dart是单线程的，这个线程有本身能够访问的内存空间以及须要运行的事件循环；
咱们能够将这个空间系统称之为是一个Isolate；
好比Flutter中就有一个Root Isolate，负责运行Flutter的代码，好比UI渲染、用户交互等等；

在 Isolate 中，资源隔离作得很是好，每一个 Isolate 都有本身的 Event Loop 与 Queue，

Isolate 之间不共享任何资源，只能依靠消息机制通讯，所以也就没有资源抢占问题。

可是，若是只有一个Isolate，那么意味着咱们只能永远利用一个线程，这对于多核CPU来讲，是一种资源的浪费。

若是在开发中，咱们有很是多耗时的计算，彻底能够本身建立Isolate，在独立的Isolate中完成想要的计算操做。

如何建立Isolate呢？

建立Isolate是比较简单的，咱们经过Isolate.spawn就能够建立了：

import "dart:isolate";

main(List<String> args) {
  Isolate.spawn(foo, "Hello Isolate");
}

void foo(info) {
  print("新的isolate：$info");
}

复制代码

3.2.2. Isolate通讯机制

可是在真实开发中，咱们不会只是简单的开启一个新的Isolate，而不关心它的运行结果：

咱们须要新的Isolate进行计算，而且将计算结果告知Main Isolate（也就是默认开启的Isolate）；
Isolate 经过发送管道（SendPort）实现消息通讯机制；
咱们能够在启动并发Isolate时将Main Isolate的发送管道做为参数传递给它；
并发在执行完毕时，能够利用这个管道给Main Isolate发送消息；

import "dart:isolate";

main(List<String> args) async {
  // 1.建立管道
  ReceivePort receivePort= ReceivePort();

  // 2.建立新的Isolate
  Isolate isolate = await Isolate.spawn<SendPort>(foo, receivePort.sendPort);

  // 3.监听管道消息
  receivePort.listen((data) {
    print('Data：$data');
    // 再也不使用时，咱们会关闭管道
    receivePort.close();
    // 须要将isolate杀死
    isolate?.kill(priority: Isolate.immediate);
  });
}

void foo(SendPort sendPort) {
  sendPort.send("Hello World");
}

复制代码

可是咱们上面的通讯变成了单向通讯，若是须要双向通讯呢？

事实上双向通讯的代码会比较麻烦；
Flutter提供了支持并发计算的compute函数，它内部封装了Isolate的建立和双向通讯；
利用它咱们能够充分利用多核心CPU，而且使用起来也很是简单；

注意：下面的代码不是dart的API，而是Flutter的API，因此只有在Flutter项目中才能运行

main(List<String> args) async {
  int result = await compute(powerNum, 5);
  print(result);
}

int powerNum(int num) {
  return num * num;
}

复制代码

备注：全部内容首发于公众号，以后除了Flutter也会更新其余技术文章，TypeScript、React、Node、uniapp、mpvue、数据结构与算法等等，也会更新一些本身的学习心得等，欢迎你们关注