使用方便有用的方法，以减少代码行数，提高我们的工作效率，增加我们的摸鱼时间。

在我们的日常任务中，我们需要编写函数，如排序、搜索、寻找惟一值、传递参数、交换值等，所以在这里分享一下我工作多年珍藏的几个常用技巧和方法，以让大家增加摸鱼的时间。

这些方法肯定会帮助你：

• 减少代码行
• Coding Competitions
• 增加摸鱼的时间

1.声明和初始化数组

我们可以使用特定的大小来初始化数组，也可以通过指定值来初始化数组内容，大家可能用的是一组数组，其实二维数组也可以这样做，如下所示：

const array = Array(5).fill(''); 

// 输出

(5) ["", "", "", "", ""]



const matrix = Array(5).fill(0).map(() => Array(5).fill(0))

// 输出

(5) [Array(5), Array(5), Array(5), Array(5), Array(5)]

0: (5) [0, 0, 0, 0, 0]

1: (5) [0, 0, 0, 0, 0]

2: (5) [0, 0, 0, 0, 0]

3: (5) [0, 0, 0, 0, 0]

4: (5) [0, 0, 0, 0, 0]

length: 5

2. 求和，最小值和最大值

我们应该利用 reduce 方法快速找到基本的数学运算。

const array = [5,4,7,8,9,2];

求和

array.reduce((a,b) => a+b);

// 输出: 35

最大值

array.reduce((a,b) => a>b?a:b);

// 输出: 9

最小值

array.reduce((a,b) => a<b?a:b);

// 输出: 2

3.排序字符串，数字或对象等数组

我们有内置的方法sort()和reverse()来排序字符串，但是如果是数字或对象数组呢

字符串数组排序

const stringArr = ["Joe", "Kapil", "Steve", "Musk"]

stringArr.sort();

// 输出

(4) ["Joe", "Kapil", "Musk", "Steve"]



stringArr.reverse();

// 输出

(4) ["Steve", "Musk", "Kapil", "Joe"]

数字数组排序

const array  = [40, 100, 1, 5, 25, 10];

array.sort((a,b) => a-b);

// 输出

(6) [1, 5, 10, 25, 40, 100]



array.sort((a,b) => b-a);

// 输出

(6) [100, 40, 25, 10, 5, 1]

对象数组排序

const objectArr = [ 

    { first_name: 'Lazslo', last_name: 'Jamf'     },

    { first_name: 'Pig',    last_name: 'Bodine'   },

    { first_name: 'Pirate', last_name: 'Prentice' }

];

objectArr.sort((a, b) => a.last_name.localeCompare(b.last_name));

// 输出 

(3) [{…}, {…}, {…}]

0: {first_name: "Pig", last_name: "Bodine"}

1: {first_name: "Lazslo", last_name: "Jamf"}

2: {first_name: "Pirate", last_name: "Prentice"}

length: 3

4.从数组中过滤到虚值

像 0, undefined, null, false, "", ''这样的假值可以通过下面的技巧轻易地过滤掉。

const array = [3, 0, 6, 7, '', false];

array.filter(Boolean);





// 输出

(3) [3, 6, 7]

5. 使用逻辑运算符处理需要条件判断的情况

function doSomething(arg1){ 

    arg1 = arg1 || 10; 

// 如果arg1没有值，则取默认值 10

}



let foo = 10;  

foo === 10 && doSomething(); 

// 如果 foo 等于 10，刚执行 doSomething();

// 输出: 10



foo === 5 || doSomething();

// is the same thing as if (foo != 5) then doSomething();

// Output: 10

6. 去除重复值

const array  = [5,4,7,8,9,2,7,5];

array.filter((item,idx,arr) => arr.indexOf(item) === idx);

// or

const nonUnique = [...new Set(array)];

// Output: [5, 4, 7, 8, 9, 2]

7. 创建一个计数器对象或 Map

大多数情况下，可以通过创建一个对象或者Map来计数某些特殊词出现的频率。

let string = 'kapilalipak';



const table={}; 

for(let char of string) {

  table[char]=table[char]+1 || 1;

}

// 输出

{k: 2, a: 3, p: 2, i: 2, l: 2}

或者

const countMap = new Map();

  for (let i = 0; i < string.length; i++) {

    if (countMap.has(string[i])) {

      countMap.set(string[i], countMap.get(string[i]) + 1);

    } else {

      countMap.set(string[i], 1);

    }

  }

// 输出

Map(5) {"k" => 2, "a" => 3, "p" => 2, "i" => 2, "l" => 2}

8. 三元运算符很酷

function Fever(temp) {

    return temp > 97 ? 'Visit Doctor!'

      : temp < 97 ? 'Go Out and Play!!'

      : temp === 97 ? 'Take Some Rest!': 'Go Out and Play!';;

}



// 输出

Fever(97): "Take Some Rest!" 

Fever(100): "Visit Doctor!"

9. 循环方法的比较

• for 和 for..in 默认获取索引，但你可以使用arr[index]。
• for..in也接受非数字，所以要避免使用。
• forEach, for...of 直接得到元素。
• forEach 也可以得到索引，但 for...of 不行。

10. 合并两个对象

const user = { 

 name: 'Kapil Raghuwanshi', 

 gender: 'Male' 

 };

const college = { 

 primary: 'Mani Primary School', 

 secondary: 'Lass Secondary School' 

 };

const skills = { 

 programming: 'Extreme', 

 swimming: 'Average', 

 sleeping: 'Pro' 

 };



const summary = {...user, ...college, ...skills};



// 合并多个对象

gender: "Male"

name: "Kapil Raghuwanshi"

primary: "Mani Primary School"

programming: "Extreme"

secondary: "Lass Secondary School"

sleeping: "Pro"

swimming: "Average"

11. 箭头函数

箭头函数表达式是传统函数表达式的一种替代方式，但受到限制，不能在所有情况下使用。因为它们有词法作用域(父作用域)，并且没有自己的this和argument，因此它们引用定义它们的环境。

const person = {

name: 'Kapil',

sayName() {

    return this.name;

    }

}

person.sayName();

// 输出

"Kapil"

但是这样：

const person = {

name: 'Kapil',

sayName : () => {

    return this.name;

    }

}

person.sayName();

// Output

"

13. 可选的链

const user = {

  employee: {

    name: "Kapil"

  }

};

user.employee?.name;

// Output: "Kapil"

user.employ?.name;

// Output: undefined

user.employ.name

// 输出: VM21616:1 Uncaught TypeError: Cannot read property 'name' of undefined

13.洗牌一个数组

利用内置的Math.random()方法。

const list = [1, 2, 3, 4, 5, 6, 7, 8, 9];

list.sort(() => {

    return Math.random() - 0.5;

});

// 输出

(9) [2, 5, 1, 6, 9, 8, 4, 3, 7]

// 输出

(9) [4, 1, 7, 5, 3, 8, 2, 9, 6]

14.双问号语法

const foo = null ?? 'my school';

// 输出: "my school"



const baz = 0 ?? 42;

// 输出: 0

剩余和展开语法

function myFun(a,  b, ...manyMoreArgs) {

   return arguments.length;

}

myFun("one", "two", "three", "four", "five", "six");



// 输出: 6

和

const parts = ['shoulders', 'knees']; 

const lyrics = ['head', ...parts, 'and', 'toes']; 



lyrics;

// 输出: 

(5) ["head", "shoulders", "knees", "and", "toes"]

16.默认参数

const search = (arr, low=0,high=arr.length-1) => {

    return high;

}

search([1,2,3,4,5]);



// 输出: 4

17. 将十进制转换为二进制或十六进制

const num = 10;



num.toString(2);

// 输出: "1010"

num.toString(16);

// 输出: "a"

num.toString(8);

// 输出: "12"

18. 使用解构来交换两个数

let a = 5;

let b = 8;

[a,b] = [b,a]



[a,b]

// 输出

(2) [8, 5]

19. 单行的回文数检查

function checkPalindrome(str) {

  return str == str.split('').reverse().join('');

}

checkPalindrome('naman');

// 输出: true

20.将Object属性转换为属性数组

const obj = { a: 1, b: 2, c: 3 };



Object.entries(obj);

// Output

(3) [Array(2), Array(2), Array(2)]

0: (2) ["a", 1]

1: (2) ["b", 2]

2: (2) ["c", 3]

length: 3



Object.keys(obj);

(3) ["a", "b", "c"]



Object.values(obj);

(3) [1, 2, 3]

原文：https://dev.to/techygeeky/top...

准备工作

我们已经安装了cocoapods (如果没有安装,请百度搜索安装cocoapods教程,并安装)

下载EaseIM源码: 源码地址:http://docs-im.easemob.com/im/ios/other/easeimkit

EaseIMKit 使用指南 -> 简介 -> EaseIMKit 源码地址 EaseIMKit工程

下载完成后,如下目录 (其中红框内的两个文件夹是我们需要的文件夹)

打开之后,整体目录如下:

这里需要注意:

七.常见报错

如果工程报错,信息如下:

一、单线程模型的设计

1. 最基础的单线程处理简单任务

假设有几个任务：

• 任务1: "姓名：" + "杭城小刘"
• 任务2: "年龄：" + "1995" + "02" + "20"
• 任务3: "大小：" + (2021 - 1995 + 1)
• 任务4: 打印任务1、2、3 的结果

在单线程中执行，代码可能如下：

//c

void mainThread () {

  string name = "姓名：" + "杭城小刘";

  string birthday = "年龄：" + "1995" + "02" + "20" 

  int age = 2021 - 1995 + 1;

    printf("个人信息为：%s, %s, 大小：%d", name.c_str(), birthday.c_str(), age);

}

线程开始执行任务，按照需求，单线程依次执行每个任务，执行完毕后线程马上退出。

2. 线程运行过程中来了新的任务怎么处理？

问题1 介绍的线程模型太简单太理想了，不可能从一开始就 n 个任务就确定了，大多数情况下，会接收到新的 m 个任务。那么 section1 中的设计就无法满足该需求。

要在线程运行的过程中，能够接受并执行新的任务，就需要有一个事件循环机制。最基础的事件循环可以想到用一个循环来实现。

// c++

int getInput() {

  int input = 0;

  cout<< "请输入一个数";

  cin>>input;

  return input;

}



void mainThread () {

  while(true) {

    int input1 = getInput();

    int input2 = getInput();

    int sum = input1 + input2;

    print("两数之和为：%d", sum);

  }

}

相较于第一版线程设计，这一版做了以下改进：

• 引入了循环机制，线程不会做完事情马上退出。
• 引入了事件。线程一开始会等待用户输入，等待的时候线程处于暂停状态，当用户输入完毕，线程得到输入的信息，此时线程被激活。执行相加的操作，最终输出结果。不断的等待输入，并计算输出。

3. 处理来自其他线程的任务

真实环境中的线程模块远远没有这么简单。比如浏览器环境下，线程可能正在绘制，可能会接收到1个来自用户鼠标点击的事件，1个来自网络加载 css 资源完成的事件等等。第二版线程模型虽然引入了事件循环机制，可以接受新的事件任务，但是发现没？这些任务之来自线程内部，该设计是无法接受来自其他线程的任务的。

从上图可以看出，渲染主线程会频繁接收到来自于 IO 线程的一些事件任务，当接受到的资源加载完成后的消息，则渲染线程会开始 DOM 解析；当接收到来自鼠标点击的消息，渲染主线程则会执行绑定好的鼠标点击事件脚本（js）来处理事件。

需要一个合理的数据结构，来存放并获取其他线程发送的消息？

消息队列这个词大家都听过，在 GUI 系统中，事件队列是一个通用解决方案。

消息队列（事件队列）是一种合理的数据结构。要执行的任务添加到队列的尾部，需要执行的任务，从队列的头部取出。

有了消息队列之后，线程模型得到了升级。如下：

可以看出改造分为3个步骤：

• 构建一个消息队列
• IO 线程产生的新任务会被添加到消息队列的尾部
• 渲染主线程会循环的从消息队列的头部读取任务，执行任务

伪代码。构造队列接口部分

class TaskQueue {

  public:

  Task fetchTask (); // 从队列头部取出1个任务

  void addTask (Task task); // 将任务插入到队列尾部

}

改造主线程

TaskQueue taskQueue;

void processTask ();

void mainThread () {

  while (true) {

      Task task = taskQueue.fetchTask();

      processTask(task);

  }

}

IO 线程

void handleIOTask () {

  Task clickTask;

  taskQueue.addTask(clickTask);

}

Tips: 事件队列是存在多线程访问的情况，所以需要加锁。

4. 处理来自其他线程的任务

浏览器环境中，　渲染进程经常接收到来自其他进程的任务，IO 线程专门用来接收来自其他进程传递来的消息。IPC 专门处理跨进程间的通信。

5. 消息队列中的任务类型

消息队列中有很多消息类型。内部消息：如鼠标滚动、点击、移动、宏任务、微任务、文件读写、定时器等等。

消息队列中还存在大量的与页面相关的事件。如 JS 执行、DOM 解析、样式计算、布局计算、CSS 动画等等。

上述事件都是在渲染主线程中执行的，因此编码时需注意，尽量减小这些事件所占用的时长。

6. 如何安全退出

Chrome 设计上，确定要退出当前页面时，页面主线程会设置一个退出标志的变量，每次执行完1个任务时，判断该标志。如果设置了，则中断任务，退出线程

7. 单线程的缺点

事件队列的特点是先进先出，后进后出。那后进的任务也许会被前面的任务因为执行时间过长而阻塞，等待前面的任务执行完毕才可以执行后面的任务。这样存在2个问题。

• 如何处理高优先级的任务

  假如要监控 DOM 节点的变化情况（插入、删除、修改 innerHTML），然后触发对应的逻辑。最基础的做法就是设计一套监听接口，当 DOM 变化时，渲染引擎同步调用这些接口。不过这样子存在很大的问题，就是 DOM 变化会很频繁。如果每次 DOM 变化都触发对应的 JS 接口，则该任务执行会很长，导致执行效率的降低

  如果将这些 DOM 变化做为异步消息，假如消息队列中。可能会存在因为前面的任务在执行导致当前的 DOM 消息不会被执行的问题，也就是影响了监控的实时性。

  如何权衡效率和实时性？微任务 就是解决该类问题的。

  通常，我们把消息队列中的任务成为宏任务，每个宏任务中都包含一个微任务队列，在执行宏任务的过程中，假如 DOM 有变化，则该变化会被添加到该宏任务的微任务队列中去，这样子效率问题得以解决。

  当宏任务中的主要功能执行完毕欧，渲染引擎会执行微任务队列中的微任务。因此实时性问题得以解决

• 如何解决单个任务执行时间过长的问题

  

  可以看出，假如 JS 计算超时导致动画 paint 超时，会造成卡顿。浏览器为避免该问题，采用 callback 回调的设计来规避，也就是让 JS 任务延后执行。

二、 flutter 里的单线程模型

1. event loop 机制

Dart 是单线程的，也就是代码会有序执行。此外 Dart 作为 Flutter 这一 GUI 框架的开发语言，必然支持异步。

一个 Flutter 应用包含一个或多个 isolate，默认方法的执行都是在 main isolate 中；一个 isolate 包含1个 Event loop 和1个 Task queue。其中，Task queue 包含1个 Event queue 事件队列和1个 MicroTask queue 微任务队列。如下：

为什么需要异步？因为大多数场景下 应用都并不是一直在做运算。比如一边等待用户的输入，输入后再去参与运算。这就是一个 IO 的场景。所以单线程可以再等待的时候做其他事情，而当真正需要处理运算的时候，再去处理。因此虽是单线程，但是给我们的感受是同事在做很多事情（空闲的时候去做其他事情）

某个任务涉及 IO 或者异步，则主线程会先去做其他需要运算的事情，这个动作是靠 event loop 驱动的。和 JS 一样，dart 中存储事件任务的角色是事件队列 event queue。

Event queue 负责存储需要执行的任务事件，比如 DB 的读取。

Dart 中存在2个队列，一个微任务队列（Microtask Queue）、一个事件队列（Event Queue）。

Event loop 不断的轮询，先判断微任务队列是否为空，从队列头部取出需要执行的任务。如果微任务队列为空，则判断事件队列是否为空，不为空则从头部取出事件（比如键盘、IO、网络事件等），然后在主线程执行其回调函数，如下：

2. 异步任务

微任务，即在一个很短的时间内就会完成的异步任务。微任务在事件循环中优先级最高，只要微任务队列不为空，事件循环就不断执行微任务，后续的事件队列中的任务持续等待。微任务队列可由 scheduleMicroTask 创建。

通常情况，微任务的使用场景比较少。Flutter 内部也在诸如手势识别、文本输入、滚动视图、保存页面效果等需要高优执行任务的场景用到了微任务。

所以，一般需求下，异步任务我们使用优先级较低的 Event Queue。比如 IO、绘制、定时器等，都是通过事件队列驱动主线程来执行的。

Dart 为 Event Queue 的任务提供了一层封装，叫做 Future。把一个函数体放入 Future 中，就完成了同步任务到异步任务的包装（类似于 iOS 中通过 GCD 将一个任务以同步、异步提交给某个队列）。Future 具备链式调用的能力，可以在异步执行完毕后执行其他任务（函数）。

看一段具体代码：

void main() {

  print('normal task 1');

  Future(() => print('Task1 Future 1'));

  print('normal task 2');

  Future(() => print('Task1 Future 2'))

      .then((value) => print("subTask 1"))

      .then((value) => print("subTask 2"));

}

//

lbp@MBP  ~/Desktop  dart index.dart

normal task 1

normal task 2

Task1 Future 1

Task1 Future 2

subTask 1

subTask 2

main 方法内，先添加了1个普通同步任务，然后以 Future 的形式添加了1个异步任务，Dart 会将异步任务加入到事件队列中，然后理解返回。后续代码继续以同步任务的方式执行。然后再添加了1个普通同步任务。然后再以 Future 的方式添加了1个异步任务，异步任务被加入到事件队列中。此时，事件队列中存在2个异步任务，Dart 在事件队列头部取出1个任务以同步的方式执行，全部执行（先进先出）完毕后再执行后续的 then。

Future 与 then 公用1个事件循环。如果存在多个 then，则按照顺序执行。

例2:

void main() {

  Future(() => print('Task1 Future 1'));

  Future(() => print('Task1 Future 2'));



  Future(() => print('Task1 Future 3'))

      .then((_) => print('subTask 1 in Future 3'));



  Future(() => null).then((_) => print('subTask 1 in empty Future'));

}

lbp@MBP  ~/Desktop  dart index.dart

Task1 Future 1

Task1 Future 2

Task1 Future 3

subTask 1 in Future 3

subTask 1 in empty Future

main 方法内，Task 1 添加到 Future 1中，被 Dart 添加到 Event Queue 中。Task 1 添加到 Future 2中，被 Dart 添加到 Event Queue 中。Task 1 添加到 Future 3中，被 Dart 添加到 Event Queue 中，subTask 1 和 Task 1 共用 Event Queue。Future 4中任务为空，所以 then 里的代码会被加入到 Microtask Queue，以便下一轮事件循环中被执行。

综合例子

void main() {

  Future(() => print('Task1 Future 1'));

  Future fx = Future(() => null);

  Future(() => print("Task1 Future 3")).then((value) {

    print("subTask 1 Future 3");

    scheduleMicrotask(() => print("Microtask 1"));

  }).then((value) => print("subTask 3 Future 3"));



  Future(() => print("Task1 Future 4"))

      .then((value) => Future(() => print("sub subTask 1 Future 4")))

      .then((value) => print("sub subTask 2 Future 4"));



  Future(() => print("Task1 Future 5"));



  fx.then((value) => print("Task1 Future 2"));



  scheduleMicrotask(() => print("Microtask 2"));



  print("normal Task");

}

lbp@MBP  ~/Desktop  dart index.dart

normal Task

Microtask 2

Task1 Future 1

Task1 Future 2

Task1 Future 3

subTask 1 Future 3

subTask 3 Future 3

Microtask 1

Task1 Future 4

Task1 Future 5

sub subTask 1 Future 4

sub subTask 2 Future 4

解释：

• Event Loop 优先执行 main 方法同步任务，再执行微任务，最后执行 Event Queue 的异步任务。所以 normal Task 先执行
• 同理微任务 Microtask 2 执行
• 其次，Event Queue FIFO，Task1 Future 1 被执行
• fx Future 内部为空，所以 then 里的内容被加到微任务队列中去，微任务优先级最高，所以 Task1 Future 2 被执行
• 其次，Task1 Future 3 被执行。由于存在2个 then，先执行第一个 then 中的 subTask 1 Future 3，然后遇到微任务，所以 Microtask 1 被添加到微任务队列中去，等待下一次 Event Loop 到来时触发。接着执行第二个 then 中的 subTask 3 Future 3。随着下一次 Event Loop 到来，Microtask 1 被执行
• 其次，Task1 Future 4 被执行。随后的第一个 then 中的任务又是被 Future 包装成一个异步任务，被添加到 Event Queue 中，第二个 then 中的内容也被添加到 Event Queue 中。
• 接着，执行 Task1 Future 5。本次事件循环结束
• 等下一轮事件循环到来，打印队列中的 sub subTask 1 Future 4、sub subTask 1 Future 5.

3. 异步函数

异步函数的结果在将来某个时刻才返回，所以需要返回一个 Future 对象，供调用者使用。调用者根据需求，判断是在 Future 对象上注册一个 then 等 Future 执行体结束后再进行异步处理，还是同步等到 Future 执行结束。Future 对象如果需要同步等待，则需要在调用处添加 await，且 Future 所在的函数需要使用 async 关键字。

await 并不是同步等待，而是异步等待。Event Loop 会将调用体所在的函数也当作异步函数，将等待语句的上下文整体添加到 Event Queue 中，一旦返回，Event Loop 会在 Event Queue 中取出上下文代码，等待的代码继续执行。

await 阻塞的是当前上下文的后续代码执行，并不能阻塞其调用栈上层的后续代码执行

void main() {

  Future(() => print('Task1 Future 1'))

      .then((_) async => await Future(() => print("subTask 1 Future 2")))

      .then((_) => print("subTask 2 Future 2"));

  Future(() => print('Task1 Future 2'));

}

lbp@MBP  ~/Desktop  dart index.dart

Task1 Future 1

Task1 Future 2

subTask 1 Future 2

subTask 2 Future 2

解析：

• Future 中的 Task1 Future 1 被添加到 Event Queue 中。其次遇到第一个 then，then 里面是 Future 包装的异步任务，所以 Future(() => print("subTask 1 Future 2")) 被添加到 Event Queue 中，所在的 await 函数也被添加到了 Event Queue 中。第二个 then 也被添加到 Event Queue 中
• 第二个 Future 中的 'Task1 Future 2 不会被 await 阻塞，因为 await 是异步等待（添加到 Event Queue）。所以执行 'Task1 Future 2。随后执行 "subTask 1 Future 2，接着取出 await 执行 subTask 2 Future 2

4. Isolate

Dart 为了利用多核 CPU，将 CPU 层面的密集型计算进行了隔离设计，提供了多线程机制，即 Isolate。每个 Isolate 资源隔离，都有自己的 Event Loop 和 Event Queue、Microtask Queue。Isolate 之间的资源共享通过消息机制通信（和进程一样）

使用很简单，创建时需要传递一个参数。

void coding(language) {

  print("hello " + language);

}

void main() {

  Isolate.spawn(coding, "Dart");

}

lbp@MBP  ~/Desktop  dart index.dart

hello Dart

大多数情况下，不仅仅需要并发执行。可能还需要某个 Isolate 运算结束后将结果告诉主 Isolate。可以通过 Isolate 的管道（SendPort）实现消息通信。可以在主 Isolate 中将管道作为参数传递给子 Isolate，当子 Isolate 运算结束后将结果利用这个管道传递给主 Isolate

void coding(SendPort port) {

  const sum = 1 + 2;

  // 给调用方发送结果

  port.send(sum);

}



void main() {

  testIsolate();

}



testIsolate() async {

  ReceivePort receivePort = ReceivePort(); // 创建管道

  Isolate isolate = await Isolate.spawn(coding, receivePort.sendPort); // 创建 Isolate，并传递发送管道作为参数

    // 监听消息

  receivePort.listen((message) {

    print("data: $message");

    receivePort.close();

    isolate?.kill(priority: Isolate.immediate);

    isolate = null;

  });

}

lbp@MBP  ~/Desktop  dart index.dart

data: 3

此外 Flutter 中提供了执行并发计算任务的快捷方式-compute 函数。其内部对 Isolate 的创建和双向通信进行了封装。

实际上，业务开发中使用 compute 的场景很少，比如 JSON 的编解码可以用 compute。

计算阶乘：

int testCompute() async {

  return await compute(syncCalcuateFactorial, 100);

}



int syncCalcuateFactorial(upperBounds) => upperBounds < 2

    ? upperBounds

    : upperBounds * syncCalcuateFactorial(upperBounds - 1);

总结：

• Dart 是单线程的，但通过事件循环可以实现异步
• Future 是异步任务的封装，借助于 await 与 async，我们可以通过事件循环实现非阻塞的同步等待
• Isolate 是 Dart 中的多线程，可以实现并发，有自己的事件循环与 Queue，独占资源。Isolate 之间可以通过消息机制进行单向通信，这些传递的消息通过对方的事件循环驱动对方进行异步处理。
• flutter 提供了 CPU 密集运算的 compute 方法，内部封装了 Isolate 和 Isolate 之间的通信
• 事件队列、事件循环的概念在 GUI 系统中非常重要，几乎在前端、Flutter、iOS、Android 甚至是 NodeJS 中都存在。

JavaScript有2种类型：基本类型（string, booleans number, symbol）和对象。

对象是复杂的数据结构，JS 中最简单的对象是普通对象：一组键和关联值：

let myObject = {

  name: '前端小智'

}

但是在某些情况下无法创建对象。 在这种情况下，JS 提供一个特殊值null —表示缺少对象。

let myObject = null

在本文中，我们将了解到有关JavaScript中null的所有知识：它的含义，如何检测它，null与undefined之间的区别以及为什么使用null造成代码维护困难。

1. null的概念

JS 规范说明了有关null的信息：

值 null 特指对象的值未设置，它是 JS 基本类型 之一，在布尔运算中被认为是falsy。

例如，函数greetObject()创建对象，但是在无法创建对象时也可以返回null：

function greetObject(who) {

  if (!who) {

    return null;

  }

  return { message: `Hello, ${who}!` };

}



greetObject('Eric'); // => { message: 'Hello, Eric!' }

greetObject();       // => null

但是，在不带参数的情况下调用函数greetObject() 时，该函数返回null。 返回null是合理的，因为who参数没有值。

2. 如何检查null

检查null值的好方法是使用严格相等运算符：

const missingObject = null;

const existingObject = { message: 'Hello!' };



missingObject  === null; // => true

existingObject === null; // => false

missingObject === null的结果为true，因为missingObject变量包含一个null 值。

如果变量包含非空值（例如对象），则表达式existObject === null的计算结果为false。

2.1 null 是虚值

null与false、0、''、undefined、NaN都是虚值。如果在条件语句中遇到虚值，那么 JS 将把虚值强制为false。

Boolean(null); // => false



if (null) {

  console.log('null is truthy')

} else {

  console.log('null is falsy')

}

2.2 typeof null

typeof value运算符确定值的类型。 例如，typeof 15是'number'，typeof {prop：'Value'}的计算结果是'object'。

有趣的是，type null的结果是什么

typeof null; // => 'object'

为什么是'object'，typoef null为object是早期 JS 实现中的一个错误。

要使用typeof运算符检测null值。 如前所述，使用严格等于运算符myVar === null。

如果我们想使用typeof运算符检查变量是否是对象，还需要排除null值：

function isObject(object) {

  return typeof object === 'object' && object !== null;

}



isObject({ prop: 'Value' }); // => true

isObject(15);                // => false

isObject(null);              // => false

3. null 的陷阱

null经常会在我们认为该变量是对象的情况下意外出现。然后，如果从null中提取属性，JS 会抛出一个错误。

再次使用greetObject() 函数，并尝试从返回的对象访问message属性：

let who = '';



greetObject(who).message; 

// throws "TypeError: greetObject() is null"

因为who变量是一个空字符串，所以该函数返回null。 从null访问message属性时，将引发TypeError错误。

可以通过使用带有空值合并的可选链接来处理null:

let who = ''



greetObject(who)?.message ?? 'Hello, Stranger!'

// => 'Hello, Stranger!'

4. null 的替代方法

当无法构造对象时，我们通常的做法是返回null，但是这种做法有缺点。在执行堆栈中出现null时，刚必须进行检查。

尝试避免返回 null 的做法：

• 返回默认对象而不是null
• 抛出错误而不是返回null

回到开始返回greeting对象的greetObject()函数。缺少参数时，可以返回一个默认对象，而不是返回null：

function greetObject(who) {

  if (!who) {

    who = 'Stranger';

  }

  return { message: `Hello, ${who}!` };

}



greetObject('Eric'); // => { message: 'Hello, Eric!' }

greetObject();       // => { message: 'Hello, Stranger!' }

或者抛出一个错误：

function greetObject(who) {

  if (!who) {

    throw new Error('"who" argument is missing');

  }

  return { message: `Hello, ${who}!` };

}



greetObject('Eric'); // => { message: 'Hello, Eric!' }

greetObject();       // => throws an error

这两种做法可以避免使用 null。

5. null vs undefined

undefined是未初始化的变量或对象属性的值，undefined是未初始化的变量或对象属性的值。

let myVariable;



myVariable; // => undefined

null和undefined之间的主要区别是，null表示丢失的对象，而undefined表示未初始化的状态。

严格的相等运算符===区分null和undefined :

null === undefined // => false

而双等运算符==则认为null和undefined 相等

null == undefined // => true

我使用双等相等运算符检查变量是否为null 或undefined:

function isEmpty(value) {

  return value == null;

}



isEmpty(42);                // => false

isEmpty({ prop: 'Value' }); // => false

isEmpty(null);              // => true

isEmpty(undefined);         // => true

6. 总结

null是JavaScript中的一个特殊值，表示丢失的对象，严格相等运算符确定变量是否为空:variable === null。

typoef运算符对于确定变量的类型（number, string, boolean）很有用。 但是，如果为null，则typeof会产生误导：typeof null的值为'object'。

null和undefined在某种程度上是等价的，但null表示缺少对象，而undefined未初始化状态。

原文：https://segmentfault.com/a/1190000040222768

在 Web 动画方面，有一套非常经典的原则 -- Twelve basic principles of animation，也就是关于动画的 12 个基本原则（也称之为迪士尼动画原则），网上对它的解读延伸的文章也非常之多：

• Animation Principles for the Web
• [[译文]网页动画的十二原则](https://cssanimation.rocks/cn...

其中使用的示例 DEMO 属于比较简单易懂，但是没有很好地体现在实际生产中应该如何灵活运用。今天本文将带大家再次复习复习，并且替换其中的最基本的 DEMO，换成一些到今天非常实用，非常酷炫的动画 DEMO 效果。

Squash and stretch -- 挤压和拉伸

挤压和拉伸的目的是为绘制的对象赋予重量感和灵活性。它可以应用于简单的物体，如弹跳球，或更复杂的结构，如人脸的肌肉组织。

应用在动画中，这一原则最重要的方面是对象的体积在被挤压或拉伸时不会改变。如果一个球的长度被垂直拉伸，它的宽度（三个维度，还有它的深度）需要相应地水平收缩。

看看上面这张图，很明显右边这个运动轨迹要比左边的真实很多。

原理动画如下：

类似的一些比较有意思的 Web 动画 DEMO：

CodePen Demo -- CSS Flippy Loader 🍳 By Jhey点击预览

仔细看上面这个 Loading 动画，每个块在跳起之前都会有一个压缩准备动作，在压缩的过程中高度变低，宽度变宽，这就是挤压和拉伸，让动画看上去更加真实。

OK，再看两个类似的效果，加深下印象：

CodePen Demo -- CSS Loading Animation点击预览

CodePen Demo -- CSS Animation Loader - Jelly Box点击预览

简单总结一下，挤压和拉伸的核心在于保持对象的体积一致，当拉伸元素时，它的宽度需要变薄，而当挤压元素时，它的宽度需要变宽。

Anticipation -- 预备动作

准备动作用于为主要的动画动作做好准备，并使动作看起来更逼真。

譬如从地板上跳下来的舞者必须先弯曲膝盖，挥杆的高尔夫球手必须先将球杆向后挥动。

原理动画如下，能够看到滚动之前的一些准备动作：

看看一些实际应用的chang场景，下面这个动画效果：

CodePen Demo -- Never-ending box By Pawel点击预览

小球向上滚动，但是仔细看的话，每次向上滚动的时候都会先向后摆一下，可以理解为是一个蓄力动作，也就是我们说的准备动作。

类似的，看看这个购物车动画，运用了非常多的小技巧，其中之一就是，车在向前冲之前会后退一点点进行一个蓄力动作，整个动画的感觉明显就不一样，它让动画看起来更加的自然：

Staging -- 演出布局

Staging 意为演出布局，它的目的是引导观众的注意力，并明确一个场景中什么是最重要的。

可以通过多种方式来完成，例如在画面中放置角色、使用光影，或相机的角度和位置。该原则的本质是关注核心内容，避免其他不必要的细节吸引走用户的注意力。

原理动画如下：

上述 Gif 原理图效果不太明显，看看示例效果：

CodePen Demo -- CSS Loading Animation点击预览

该技巧的核心就是在动画的过程中把主体凸显，把非主体元素通过模糊、变淡等方式弱化其效果，降低用户在其之上的注意力。

Straight-Ahead Action and Pose-to-Pose -- 连续运动和姿态对应

其实表示的就是逐帧动画和补间动画：

• FrameAnimation（逐帧动画）：将多张图片组合起来进行播放，可以利用 CSS Aniation 的 Steps，画面由一帧一帧构成，类似于漫画书
• TweenAnimation（补间动画）：补间动画是在时间帧上进行关键帧绘制，不同于逐帧动画的每一帧都是关键帧，补间动画可以在一个关键帧上绘制一个基础形状，然后在时间帧上对另一个关键帧进行形状转变或绘制另一个形状等，然后中间的动画过程是由计算机自动生成。

这个应该是属于最基础的了，在不同场景下有不同的妙用。我们在用 CSS 实现动画的过程中，使用的比较多的应该是补间动画，逐帧动画也很有意思，譬如设计师设计好的复杂动画，利用多张图片拼接成逐帧动画也非常不错。

逐帧动画和补间动画适用在不同的场合，没有谁更好，只有谁更合适，比较下面两个时钟动画，其中一个的秒针运用的是逐帧动画，另外一个则是补间动画：

• 时钟秒针运用的是逐帧动画：

CodePen Demo -- CSS3 Working Clock By Ilia点击预览

• 时钟秒针运用的是补间动画：

CodePen Demo -- CSS Rotary Clock By Jake Albaugh点击预览

有的时候一些复杂动画无法使用 CSS 直接实现的，也会利用逐帧的效果近似实现一个补间动画，像是苹果这个耳机动画，就是实际逐帧动画，但是看起来是连续的：

CodePen Demo -- Apple AirPods Pro Animation (final demo) By Blake Bowen点击预览

这里其实是多张图片的快速轮播，每张图片表示一个关键帧。

Follow through and overlapping action 跟随和重叠动作

跟随和重叠动作是两种密切相关的技术的总称，它们有助于更真实地渲染运动，并有助于给人一种印象，即运动的元素遵循物理定律，包括惯性原理。

• 跟随意味着在角色停止后，身体松散连接的部分应该继续移动，并且这些部分应该继续移动到角色停止的点之外，然后才被拉回到重心或表现出不同的程度的振荡阻尼；
• 重叠动作是元素各部分以不同速率移动的趋势（手臂将在头部的不同时间移动等等）；
• 第三种相关技术是拖动，元素开始移动，其中一部分需要几帧才能追上。

要创造一个重叠动作的感觉，我们可以让元件以稍微不同的速度移动到每处。这是一种在 iOS 系统的视窗过渡中被运用得很好的方法。一些按钮和元件以不同速率运动，整体效果会比全部东西以相同速率运动要更逼真，并留出时间让访客去适当理解变化。

原理示意图：

看看下面这个购物车动画，仔细看购物车，在移动到停止的过程中，有个很明显的刹车再拉回的感觉，这里运用到了跟随的效果，让动画更加生动真实：

Slow In and Slow Out -- 缓入缓出

现实世界中物体的运动，如人体、动物、车辆等，需要时间来加速和减速。

真实的运动效果，它的缓动函数一定不是 Linear。出于这个原因，运动往往是逐步加速并在停止前变慢，实现一个慢进和慢出的效果，以贴近更逼真的动作。

示意图：

这个还是很好理解的。真实世界中，很少有缓动函数是 Linear 的运动。

Arc -- 弧线运动

大多数自然动作倾向于遵循一个拱形轨迹，动画应该遵循这个原则，遵循隐含的弧形以获得更大的真实感。

原理示意图：

嗯哼，在很多动画中，使用弧线代替直线，能够让动画效果更佳的逼真。看看下面这个烟花粒子动画：

CodePen Demo -- Particles, humankind's only weakness By Rik Schennink点击预览

整个烟花粒子动画看上去非常的自然，因为每个粒子的下落都遵循了自由落体的规律，它们的运动轨迹都是弧线而不是直线。

Secondary Action -- 次要动作

将次要动作添加到主要动作可以使场景更加生动，并有助于支持主要动作。走路的人可以同时摆动手臂或将手臂放在口袋里，说话或吹口哨，或者通过面部表情来表达情绪。

原理示意图：

简单的一个应用实例，看看下面这个动画：

CodePen Demo -- Submarine Animation (Pure CSS) By Akhil Sai Ram点击预览

这里实现了一个潜艇向前游动的画面，动画本身还有很多可以优化的地方。但也有一些值得学习肯定的地方，动画使用了尾浆转动和气泡和海底景物移动。

同时，值得注意的是，窗口的反光也是一个很小的细节，表示船体在移动，这个就属于一个次要动作，衬托出主体的移动。

再看看下面这打印动画，键盘上按键的上上下下模拟了点击效果，其实也是个次要动作，衬托主体动画效果：

![Secondary Action - CodePen Home
CSS Typewriter](https://p3-juejin.byteimg.com...

CodePen Demo -- CSS Typewriter By Aaron Iker点击预览

Timing -- 时间节奏

时间是指给定动作的绘图或帧数，它转化为动画动作的速度。

在纯粹的物理层面上，正确的计时会使物体看起来遵守物理定律。例如，物体的重量决定了它对推动力的反应，因为重量轻的物体会比重量大的物体反应更快。

同一个动画，使用不同的速率展示，其效果往往相差很多。对于 Web 动画而言，可能只需要调整 animation-duration 或 transition-duration 的值。

原理示意图：

可以看出，同个动画，不同的缓动函数，或者赋予不同的时间，就能产生很不一样的效果。

当然，时间节奏可以运用在很多地方，譬如在一些 Loading 动画中：

CodePen Demo -- Only Css 3D Cube By Hisami Kurita点击预览

又或者是这样，同个动画，不同的速率：

CodePen Demo -- Rotating Circles Preloader点击预览

也可以是同样的延迟、同样的速率，但是不同的方向：

CodePen Demo -- 2020 SVG Animation By @keyframers点击预览

Exaggeration -- 夸张手法

夸张是一种对动画特别有用的效果，因为力求完美模仿现实的动画动作可能看起来是静态和沉闷的。

使用夸张时，一定程度的克制很重要。如果一个场景包含多个元素，则应平衡这些元素之间的关系，以避免混淆或吓倒观众。

原理示意图：

OK，不同程度的展现对效果的感官是不一样的，对比下面两个故障艺术动画：

轻微晃动故障：

严重晃动故障：

CodePen Demo -- Glitch Animation点击预览

可以看出，第二个动画明显能感受到比第一个更严重的故障。

过多的现实主义会毁掉动画，或者说让它缺乏吸引力，使其显得静态和乏味。相反，为元素对象添加一些夸张，使它们更具活力，能够让它们更吸引眼球。

Solid drawing -- 扎实的描绘

这个原则表示我们的动画需要尊重真实性，譬如一个 3D 立体绘图，就需要考虑元素在三维空间中的形式。

了解掌握三维形状、解剖学、重量、平衡、光影等的基础知识。有助于我们绘制出更为逼真的动画效果。

原理示意图：

再再看看下面这个动画，名为 Close the blinds -- 关上百叶窗：

CodePen Demo -- Close the blinds By Chance Squires点击预览

hover 的时候有一个关上动画，使用多块 div 模拟了百叶窗的落下，同时配合了背景色从明亮到黑暗的过程，很好的利用了色彩光影辅助动画的展示。

再看看这个摆锤小动画，也是非常好的使用了光影、视角元素：

CodePen Demo -- The Three-Body Problem By Vian Esterhuizen点击预览

最后这个 Demo，虽然是使用 CSS 实现的，但是也尽可能的还原模拟了现实中纸张飞舞的形态，并且对纸张下方阴影的变化也做了一定的变化：

CodePen Demo -- D CSS-only flying page animation tutorial By @keyframers点击预览

好的动画，细节是经得起推敲的。

Appeal -- 吸引力

一反往常，精美的细节往往能非常好的吸引用户的注意力。

吸引力是艺术作品的特质，而如何实现有吸引力的作品则需要不断的尝试。

原理示意图：

我觉得这一点可能是 Web 动画的核心，一个能够吸引人的动画，它肯定是有某些特质的，让我们一起来欣赏下。

CodePen Demo -- Download interaction By Milan Raring点击预览

通过一连串的动作，动画展开、箭头移动、进度条填满、数字变化，把一个下载动画展示的非常 Nice，让人在等待的过程并不觉得枯燥。

再来看看这个视频播放的效果：

CodePen Demo -- Video button animation - Only CSS点击预览

通过一个遮罩 hover 放大，再到点击全屏的变化，一下子就将用户的注意力给吸引了过来。

Web 动画的一些常见误区

当然，上述的一些技巧源自于迪士尼动画原则，我们可以将其中的一些思想贯穿于我们的 Web 动画的设计之中。

但是，必须指出的是，Web 动画本身在使用的时候，也有一些原则是我们需要注意的。主要有下面几点：

• 增强动画与页面元素之间的关联性
• 不要为了动画而动画，要有目的性
• 动画不要过于缓慢，否则会阻碍交互

增强动画与页面元素之间的关联性

这个是一个常见的问题，经常会看到一些动画与主体之间没有关联性。关联性背后的逻辑，能帮助用户在界面布局中理解刚发生的变化，是什么导致了变化。

好的动画可以做到将页面的多个环节或者场景有效串联。

比较下面两个动画，第二个就比第一个更有关联性：

没有强关联性的：

有关联性的：

很明显，第二个动画比第一个动画更能让用户了解页面发生的变化。

不要为了动画而动画，要有目的性

这一点也很重要，不要为了动画而动画，要有目的性，很多时候很多页面的动画非常莫名其妙。

emm，简单一点来说就是单纯的为了炫技而存在的动画。这种动画可以存在于你的 Demo，你的个人网站中，但不太适合用于线上业务页面中。

使用动画应该有明确的目的性，譬如 Loading 动画能够让用户感知到页面正在发生变化，正在加载内容。

在我们的交互过程中，适当的增加过渡与动画，能够很好的让用户感知到页面的变化。类似的还有一些滚动动画。丝滑的滚动切换比突兀的内容明显是更好的体验。

动画不要过于缓慢，否则会阻碍交互

缓慢的动画，它产生了不必要的停顿。

一些用户会频繁看到它们的过渡动画，尽可能的保持简短。让动画持续时间保持在 300ms 或更短。

比较下面两个动画，第一次可能会让用户耳目一新，但是如果用户在浏览过程中频繁出现通过操作，过长的转场动画会消耗用户大量不必要的时间：

过长的转场动画：

缩短转场动画时间，保持恰当的时长：

结合产品及业务的创意交互动画

这一点是比较有意思的。我个人认为，Web 动画做得好用的妙，是能非常好的提升用户体验，提升品牌价值的。

结合产品及业务的创意动画，是需要挖掘，不断打磨的不断迭代的。譬如大家津津乐道的 BiliBili 官网，它的顶部 Banner，配合一些节日、活动，经常就会有出现一些有意思的创意交互动画。简单看两个：

以及这个：

我非常多次在不同地方看到有人讨论 Bilibili 的顶部 banner 动画，可见它这块的动画是成功的。很好的结合了一些节日、实事、热点，当成了一种比较固定的产品去不断推陈出新，在不同时候给与用户不同的体验。

考虑动画的性价比

最后一条，就是动画虽好，但是打磨一个精品动画是非常耗时的，尤其是在现在非常多的产品业务都是处于一种敏捷开发迭代之下。

一个好的 Web 动画从构思到落地，绝非前端一个人的工作，需要产品、设计、前端等等相关人员公共努力， 不断修改才能最终呈现比较好的效果。所以在项目初期，一定需要考虑好性价比，是否真的值得为了一个 Web 动画花费几天时间呢？当然这是一个非常见仁见智的问题。

参考文章

• 原理图来源 -- Understand Disney's 12 principles of animation
• Animation Principles for the Web
• [[译文]网页动画的十二原则](https://cssanimation.rocks/cn...
• Twelve basic principles of animation
• 功能性动画设计：优秀的转场效果

最后

想使用 Web 技术绘制生动有趣的动画并非易事，尤其在现在国内的大环境下，鲜有人会去研究动画原则，并运用于实践生产之中。但是它本身确实是个非常有意思有技术的事情。希望本文能给大伙对 Web 动画的认知带来一些提升和帮助，在后续的工作中多少运用一些。

原文：https://segmentfault.com/a/1190000040223372

安卓开发同学，初来匝道，谢谢关照

/**
 * QQ登陆授权判断
 * code 是前端点击QQ登陆按钮图标然后请求，然后请求这个回调地址 返回的
 * 我这里就可以取到了
 */
router.get('/qqauthor', async (ctx, next) => {
  const { code } = ctx.request.query
  console.log("code", code) // 打印查看是否获取到
  let userinfo
  let openid 
  let item
  if (code) {
  
    let token = await QQgetAccessToken(code) // 获取token 函数 返回 token 并存储
    console.log('返回的token',token)  
    openid = await getOpenID(token)  // 获取 Openid 函数 返回 Openid 并存储
    console.log('返回的openid', openid)   
    if (openid && token) {
      userinfo = await  QQgetUserInfO(token, openid)  // 如果都获取到了，获取用户信息
      console.log("返回的结果", userinfo)
    }
    
  }
  
  // 封装： 
  if (userinfo) {
    let obj = {
      nickname: userinfo.nickname,
      openid: openid,
      gender: userinfo.gender === '男' ? 1 : 2,
      province: userinfo.province,
      city: userinfo.city, 
      year: userinfo.year,
      avatar: userinfo.figureurl_qq_2 ? userinfo.figureurl_qq_2 : userinfo.figureurl_qq_1
    }  
    console.log('封装的obj', obj)
    item = await register({ userInfo: obj, way: 'qq' })
    /** 从这里到封装 都是改变我获取的用户信息存储到数据库里面，根据数据库的存储，创建新用户，如果有
    * 用户我就查询并获取用户的id 然后返回给前端 用户的 id
    */
    ctx.state = {
        id: item.data.id
      }
    await ctx.render('login', ctx.state)  // 如果获取到用户 id 返回 前端一个页面并携带参数 用户ID
  }
})


/**
 * 
 * @param {string} code 
 * @param {string} appId 密钥
 * @param {string} appKey key
 * @param {string} state client端的状态值。用于第三方应用防止CSRF攻击，成功授权后回调时会原样带回
 * @param {string} redirectUrl （回调地址）
 * @returns 
 */
async function QQgetAccessToken(code) {
    let result
    let appId = '申请成功就有了'
    let appKey = '申请成功就有了'
    let state = '自定义'
    let redirectUrl = 'https://xxxxx/qqauthor'  // 回调地址是一样的 我这里就是我的获取登陆接口的地址
    
    // 安装了 axios 请求 接口 获取返回的token
    await axios({
      url:`https://graph.qq.com/oauth2.0/token?grant_type=authorization_code&client_id=${appId}&client_secret=${appKey}&code=${code}&state=${state}&redirect_uri=${redirectUrl}&fmt=json`,
      method:'GET'
    }).then(res =>{
      console.log(res.data)
      result = res.data.access_token
    //   res.data.access_token
    }).catch(err => {
       console.log(err)
       result = err
    })
    
    return result
}


/**
 * 根据Token获取Openid
 * @param {string} accessToken token 令牌
 * @returns 
 */
async function getOpenID(accessToken) {
    let result
    
    // 跟上面差不多就不解释了
    await axios({
        url: `https://graph.qq.com/oauth2.0/me?access_token=${accessToken}&fmt=json`,
        method: 'GET'
    }).then(res => {
        // 获取到了OpenID
       result = res.data.openid
    }).catch(err => {
       result = err
    })
    
    return result
}


/**
 * 根据Openid 和 Token 获取用户的信息
 * @param {string} accessToken
 * @param {string} openid 
 * @returns 
 */
async function QQgetUserInfO (token, openid) {
  let result    
  await axios({
    url: `https://graph.qq.com/user/get_user_info?access_token=${token}&oauth_consumer_key=101907569&openid=${openid}`,
    method: 'GET'  
  }).then(res => {
      result =  res.data
  }).catch(err => {
    console.log(err)
    result = err
  })
  
  return result
}

前后端调试

前端我这里使用的是Vue2.0的语法去写的上login.vue 页面代码

<template>
<div class="icon" @click="qqAuth">
        <img src="@/static/img/qq48-48.png" alt="" />
        <span>QQ账号登陆</span>
</div>
</template>

// 这里我就直接写
<script>
export default {
methods: {
  // 简单粗暴
  qqAuth () {
      const appId = 申请就有了  
      const redirectUrl = 'https://xxx/qqauthor' // 回调地址 我这里路由是/qqauthor 你的是什么填什么
      const state = 'ahh' // 可自定义
      const display = '' // 可不传仅PC网站接入时使用。用于展示的样式。
      const scope = ''  // 请求用户授权时向用户显示的可进行授权的列表。 可不填
      const url = `
      https://graph.qq.com/oauth2.0/authorize?
      response_type=code&
      client_id=${appId}&
      redirect_uri=${redirectUrl}
      &state=${state}
      &scope=${scope}
      `
      window.open(url, '_blank')  // 开始访问请求 ，这个时候用户点击登陆，就会跳转到qq登陆界面，
      登陆后会返回code 到最开始我们写好的后端接口也就是回调地址哪里，开始操作
  },
}
 </script>

npm config set registry=https://registry.npm.taobao.org/

npm config set ELECTRON_MIRROR=http://npm.taobao.org/mirrors/electron/

/* main.js */
const { app, BrowserWindow } = require('electron')
const path = require('path')
const ipc = require('electron').ipcMain
const http = require('http');
const qs = require("qs")
const os = require('os');

// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let mainWindow;
let server;

const initServer = () => {
    server = http.createServer(function (request, response) {
        // 定义了一个post变量，用于暂存请求体的信息
        let post = '';
        // 通过req的data事件监听函数，每当接受到请求体的数据，就累加到post变量中
        //当有数据请求时触发
        request.on('data', function (data) {
            post += data;
        });
        // 在end事件触发后，通过querystring.parse将post解析为真正的POST请求格式，然后向客户端返回。
        request.on('end', function () {
            //解析为post对象
            post = JSON.parse(post);
            //将对象转化为字符串
            response.writeHead(200, { 'Content-Type': 'text-plain' });
            response.end('{"status":200}\n');
            mainWindow.webContents.send("flightdata", post)
        });
    }).listen(8124);
}


const createWindow = () => {
    // Create the browser window.
    mainWindow = new BrowserWindow({
        fullscreen: false,
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: false
        }
    });

    // and load the index.html of the app.
    mainWindow.loadFile("./build/index.html");

    // mainWindow.maximize()
    mainWindow.removeMenu()
    // mainWindow.webContents.openDevTools()
    mainWindow.webContents.openDevTools({mode:'right'});
    // Emitted when the window is closed.
    mainWindow.on('closed', () => {
        // Dereference the window object, usually you would store windows
        // in an array if your app supports multi windows, this is the time
        // when you should delete the corresponding element.
        mainWindow = null;
    });
};

const initApp = () => {
    createWindow();
    initServer();
}

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', initApp);

// Quit when all windows are closed.
app.on('window-all-closed', () => {
    // On OS X it is common for applications and their menu bar
    // to stay active until the user quits explicitly with Cmd + Q
    if (process.platform !== 'darwin') {
        app.quit();
    }
});

app.on('activate', () => {
    // On OS X it's common to re-create a window in the app when the
    // dock icon is clicked and there are no other windows open.
    if (mainWindow === null) {
        createWindow();
    }
});

这里面大部分逻辑你不用考虑，我以后的文章会讲到，而你只需要知道一点就行。

那就是我在这个mian中指定了一个静态网页，巧了！位置就在我们打包文件夹build下🤭。

// and load the index.html of the app.
    mainWindow.loadFile("./build/index.html");

然后配置package.json

{
    ...
    "main": "main.js",
    "homepage": "./",
    ...
}

分析：

main：配置刚才我们创建的Electron的入口文件main.js homepage：如果不配置的话，就会。。，em~~~~就会。。算了贴代码吧

...
    const publicUrlOrPath = getPublicUrlOrPath(
    process.env.NODE_ENV === 'development',
    require(resolveApp('package.json')).homepage,
    process.env.PUBLIC_URL
    );
    ...

<HashRouter getUserConfirmation={this.getConfirmation}>
        ...
    </HashRouter>

/* package.json */
 "scripts": {
    ...
    "electron": "electron ."
    ...
  },

Web view 用于加载和显示丰富的网络内容。例如，嵌入 HTML 和网站。Mail app 使用 web view 显示邮件中的 HTML 内容。

iOS 8 和 macOS 10.10 中引入了WebKit framework，用以取代UIWebView和WebView。同时，在两个平台上提供同一API。与UIWebView相比，WebKit 有以下优势：使用了与 Safari 一样的 JavaScript engine，在运行脚本前，将脚本编译为机器代码，速度更快；支持多进程架构，Web 内容在单独的线程中运行，WKWebView崩溃不会影响 app运行；能够以60fps滑动。另外，在 iOS 12 和 macOS 10.14中，UIWebView和WebView已经被正式弃用。

WebKit framework 提供了多个类和协议，用于在窗口中显示网络内容，并实现类似浏览器功能。例如，点击链接时显示链接内容，维护前进、后退列表，维护最近访问列表。加载网页内容时，异步从 HTTP 服务器请求内容，其响应 (response) 可能以增量、随机顺序到达，也可能因网络原因部分到达，而 WebKit 极大简化了这些过程。WebKit 框架还简化了显示各种 MIME 类型内容过程，以及管理视图中各元素滚动条。

WebKit 框架中的方法、函数只能在主线程或主队列中调用。

1. WKWebView
WKWebView是 WebKit framework 的核心。在 app 内使用WKWebView插入网络内容步骤如下：

1、创建WKWebView对象。
2、将WKWebView设置为要显示的视图。
3、向WKWebView发送加载 Web 内容的请求。

使用initWithFrame:configuration:方法创建WKWebView，使用loadHTMLString:baseURL:加载本地HTML文件，或使用loadRequest:方法加载网络内容。如下：

// Local HTMLs
    WKWebView *webView = [[WKWebView alloc] initWithFrame:self.view.bounds configuration:self.webConfiguration];
    self.view = webView;
    NSURL *htmlURL = [[NSBundle mainBundle] URLForResource:@"WKWebView - NSHipster" withExtension:@"htm"];
    NSURL *baseURL = [htmlURL URLByDeletingLastPathComponent];
    NSString *htmlString = [NSString stringWithContentsOfURL:htmlURL
                                                    encoding:NSUTF8StringEncoding
                                                       error:NULL];
    [webView loadHTMLString:htmlString baseURL:baseURL];
    
    // Web Content
    WKWebView *webView = [[WKWebView alloc] initWithFrame:self.view.bounds configuration:self.webConfiguration];
    self.view = webView;
    NSURL *myURL = [NSURL URLWithString:@"https://github.com/pro648/tips/wiki"];
    NSURLRequest *request = [NSURLRequest requestWithURL:myURL
                                             cachePolicy:NSURLRequestUseProtocolCachePolicy
                                         timeoutInterval:30];
    [webView loadRequest:request];

本地HTML文件可以在demo源码中获取：https://github.com/pro648/BasicDemos-iOS/tree/master/WebKit

如图所示：

设置allowsBackForwardNavigationGestures属性可以开启、关闭横向滑动触发前进、后退导航功能：

self.webView.allowsBackForwardNavigationGestures = YES;

1.1 KVO

WKWebView中的title、URL、estimatedProgress、hasOnlySecureContent和loading

属性支持键值观察，可以通过添加观察者，获得当前网页标题、加载进度等。

根据文档serverTrust属性也支持KVO，但截至目前，在iOS 12.1 (16B91)中使用观察者观察该属性，运行时会抛出this class is not key value coding-compliant for the key serverTrust的异常。

将网页标题显示出来可以帮助用户了解当前所在位置，显示当前导航进度能够能够让用户感受到加载速度，另外，还可以观察hasOnlySecureContent查看当前网页所有资源是否均通过加密连接传输。在viewDidLoad中添加以下代码：

[self.webView addObserver:self forKeyPath:@"hasOnlySecureContent" options:NSKeyValueObservingOptionNew context:webViewContext];
    [self.webView addObserver:self forKeyPath:@"title" options:NSKeyValueObservingOptionNew context:webViewContext];
    [self.webView addObserver:self forKeyPath:@"estimatedProgress" options:NSKeyValueObservingOptionNew context:webViewContext];

实现observerValueForKeyPath:ofObject:change:context:方法，在观察到值变化时进行对应操作：

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    if ([keyPath isEqualToString:@"hasOnlySecureContent"]) {
        BOOL onlySecureContent = [[change objectForKey:NSKeyValueChangeNewKey] boolValue];
        NSLog(@"onlySecureContent:%@",onlySecureContent ? @"YES" : @"NO");
    } else if ([keyPath isEqualToString:@"title"]) {
        self.navigationItem.title = change[NSKeyValueChangeNewKey];
    } else if ([keyPath isEqualToString:@"estimatedProgress"]) {
        self.progressView.hidden = [change[NSKeyValueChangeNewKey] isEqualToNumber:@1];
        
        CGFloat progress = [change[NSKeyValueChangeNewKey] floatValue];
        self.progressView.progress = progress;
    } else {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

如果你对键值观察、键值编码还不熟悉，可以查看我的另一篇文章：KVC和KVO学习笔记

运行demo，如下所示：

控制台会输出如下内容：

onlySecureContent:YES

WKWebView调用reload、stopLoading、goBack、goForward可以实现刷新、返回、前进等功能：

- (void)refreshButtonTapped:(id)sender {
    [self.webView reload];
}

- (void)stopLoadingButtonTapped:(id)sender {
    [self.webView stopLoading];
}

- (IBAction)backButtonTapped:(id)sender {
    [self.webView goBack];
}

- (IBAction)forwardButtonTapped:(id)sender {
    [self.webView goForward];
}

还可以通过观察loading属性，在视图加载完成时，更新后退、前进按钮状态：

- (void)viewDidLoad {
    ...
    
    [self.webView addObserver:self forKeyPath:@"loading" options:NSKeyValueObservingOptionNew context:webViewContext];
}
    
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    ...
    if (context == webViewContext && [keyPath isEqualToString:@"loading"]) {
        BOOL loading = [change[NSKeyValueChangeNewKey] boolValue];
        // 加载完成后，右侧为刷新按钮；加载过程中，右侧为暂停按钮。
        self.navigationItem.rightBarButtonItem = loading ? self.stopLoadingButton : self.refreshButton;
        
        self.backButton.enabled = self.webView.canGoBack;
        self.forwardButton.enabled = self.webView.canGoForward;
    } else {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

1.2 截取网页视图

在iOS 11和macOS High Sierra中，WebKit framework增加了takeSnapshotWithConfiguration:completionHandler: API用于截取网页视图。截取网页可见部分视图方法如下：

- (IBAction)takeSnapShot:(UIBarButtonItem *)sender {
    WKSnapshotConfiguration *shotConfiguration = [[WKSnapshotConfiguration alloc] init];
    shotConfiguration.rect = CGRectMake(0, 0, self.webView.bounds.size.width, self.webView.bounds.size.height);
    
    [self.webView takeSnapshotWithConfiguration:shotConfiguration
                              completionHandler:^(UIImage * _Nullable snapshotImage, NSError * _Nullable error) {
                                  // 保存截图至相册，需要在info.plist中添加NSPhotoLibraryAddUsageDescription key和描述。
                                  UIImageWriteToSavedPhotosAlbum(snapshotImage, NULL, NULL, NULL);
                              }];
}

此前，截取网页视图需要结合图层和graphics context。现在，只需要调用单一API。

1.3 执行JavaScript

可以使用evaluateJavaScript:completionHandler:方法触发web view JavaScript。下面方法触发输出web view userAgent:

[self.webView evaluateJavaScript:@"navigator.userAgent" completionHandler:^(id _Nullable userAgent, NSError * _Nullable error) {
        NSLog(@"%@",userAgent);
    }];

在iOS 12.1.2 (16C101) 中，输出如下：

Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/16C101

2. WKWebViewConfiguration

WKWebViewConfiguration是用于初始化Web视图属性的集合。通过WKWebViewConfiguration类，可以设置网页渲染速度，视频是否自动播放，HTML5 视频是否一帧一帧播放，如何与本地代码通信等。

WKWebViewConfiguration属性有偏好设置preference、线程池processPool和用户内容控制器userContentController等。

Web view 初始化时才需要WKWebViewConfiguration对象，WKWebView创建后无法修改其configuration。多个WKWebView可以使用同一个configuration。

例如，设置网页中最小字体为30，自动检测电话号码：

- (WKWebViewConfiguration *)webConfiguration {
    if (!_webConfiguration) {
        _webConfiguration = [[WKWebViewConfiguration alloc] init];
        
        // 偏好设置 设置最小字体
        WKPreferences *preferences = [[WKPreferences alloc] init];
        preferences.minimumFontSize = 30;
        _webConfiguration.preferences = preferences;
        
        // 识别网页中的电话号码
        _webConfiguration.dataDetectorTypes = WKDataDetectorTypePhoneNumber;
        
        // Web视图内容完全加载到内存之前，禁止呈现。
        _webConfiguration.suppressesIncrementalRendering = YES;
    }
    return _webConfiguration;
}

suppressesIncrementalRendering属性是布尔值，决定Web视图内容在完全加载到内存前是否显示，默认为NO，即边加载边显示。例如，Web视图中有文字和图片，会先显示文字后显示图片。

3. Scripts

用户脚本 (User Scripts) 是文档开始加载或加载完成后注入 Web 页面的 JS。User Scripts非常强大，其能够通过客户端设置网页，允许注入事件监听器，甚至可以注入脚本，这些脚本又可以回调 native app 。

3.1 WKUserScript

WKUserScript对象表示可以注入网页的脚本。initWithSource:injectionTime:forMainFrameOnly:方法返回可以添加到userContentController控制器的脚本。其中，source 参数为 script 源码；injectionTime为WKUserScriptInjectionTimeAtDocumentStart、WKUserScriptInjectionTimeAtDocumentEnd，

其参数如下：

source: script 源码。
injectionTime: user script注入网页时间，为WKUserScriptInjectionTime枚举常量。WKUserScriptInjectionTimeAtDocumentStart在创建文档元素之后，加载任何其他内容之前注入。WKUserScriptInjectionTimeAtDocumentEnd在加载文档后，但在加载其他子资源之前注入。
forMainFrameOnly: 布尔值，YES时只注入main frame，NO时注入所有 frame。
下面代码将隐藏 Wikipedia toc、mw-panel 脚本注入网页，同时使用 JS 提取网页 toc 表格内容：

// 隐藏wikipedia左边缘和contents表格
        NSURL *hideTableOfContentsScriptURL = [[NSBundle mainBundle] URLForResource:@"hide" withExtension:@"js"];
        NSString *hideTableOfContentsScriptString = [NSString stringWithContentsOfURL:hideTableOfContentsScriptURL
                                                                             encoding:NSUTF8StringEncoding error:NULL];
        WKUserScript *hideTableOfContentsScript = [[WKUserScript alloc] initWithSource:hideTableOfContentsScriptString
                                                                         injectionTime:WKUserScriptInjectionTimeAtDocumentStart
                                                                      forMainFrameOnly:YES];
        
        // 获取contents表格内容
        NSString *fetchTableOfContentsScriptString = [NSString stringWithContentsOfURL:[[NSBundle mainBundle] URLForResource:@"fetch" withExtension:@"js"] encoding:NSUTF8StringEncoding error:NULL];
        WKUserScript *fetchTableOfContentsScript = [[WKUserScript alloc] initWithSource:fetchTableOfContentsScriptString
                                                                          injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
                                                                       forMainFrameOnly:YES];

本文中的 js 和 HTML 均可通过文章底部源码链接获取。要使用 JavaScript 提取内容的网页为：https://en.wikipedia.org/w/index.php?title=San_Francisco&mobileaction=toggle_view_desktop

3.2 WKUserContentController
WKUserContentController对象为 JavaScript 提供了发送消息至 native app，将 user scripts 注入 Web 视图方法。

将 user script 添加到userContentController才可以注入网页中：

WKUserContentController *userContentController = [[WKUserContentController alloc] init];
        [userContentController addUserScript:hideTableOfContentsScript];
        [userContentController addUserScript:fetchTableOfContentsScript];

要监听 JavaScript 消息，需要先注册要监听消息名称。添加监听事件方法为addScriptMessageHandler:name:，参数如下：

scriptMessageHandler: 处理监听消息，该类需要遵守WKMessageHandler协议。
name: 要监听消息名称。
使用该方法添加监听事件后，JavaScript 的 window.webkit.messageHandlers.name.postMessage(messageBody) 函数将被定义在使用了该userContentController网页视图的所有frame。

监听fetch.js中 didFetchTableOfContents 消息：

[userContentController addScriptMessageHandler:self name:@"didFetchTableOfContents"];
        
        // 最后，将userContentController添加到WKWebViewConfiguration
        _webConfiguration.userContentController = userContentController;

3.3 WKScriptMessageHandler

监听 script message 的类必须遵守WKMessageHandler协议，实现该协议唯一且必须实现的userContentController:didReceiveScriptMessage:方法。Webpage 接收到脚本消息时会调用该方法。

- (void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage:(WKScriptMessage *)message {
    if ([message.name isEqualToString:@"didFetchTableOfContents"]) {
        id body = message.body;
        if ([body isKindOfClass:NSArray.class]) {
            NSLog(@"messageBody:%@",body);
        }
    }
}

如下所示：

JavaScript 消息是WKScriptMessage对象，该对象属性如下：

body：消息内容，可以是NSNumber、NSString、NSDate、NSArray、NSDictionary、NSNull类型。
frameInfo：发送该消息的frame。
name：接收消息对象名称。
webView：发送该消息的网页视图。
最终，我们成功的将事件从 iOS 转发到 JavaScript，并将 JavaScript 转发回 iOS。

4. WKNavigationDelegate

用户点击链接，使用前进、后退手势，JavaScript 代码(例如，window.location = ' https://github.com/pro648 ')，使用代码调用loadRequest:等均会让网页加载内容，即action引起网页加载；随后，web view 会向服务器发送request，接收response，可能会是positive response，也可能请求失败；之后接收数据。我们的应用可以在action后、request前，或者response后、data前自定义网页加载，决定继续加载，或取消加载。

WKNavigationDelegate协议内方法可以自定义Web视图接收、加载和完成导航请求过程的行为。

首先，声明遵守WKNavigationDelegate协议：

@interface ViewController () <WKNavigationDelegate>

其次，指定遵守WKNavigationDelegate协议的类为 web view 代理：

self.webView.navigationDelegate = self;

最后，根据需要实现所需WKNavigationDelegate方法。

webView:decidePolicyForNavigationAction:decisionHandler:方法在action后响应，webView:decidePolicyForNavigationResponse:decisionHandler:方法在response后响应。

根据前面的配置，WKWebView会自动识别网页中电话号码。截至目前，电话号码只能被识别，无法点击。可以通过实现webView:decidePolicyForNavigationAction:decisionHandler:方法，调用系统Phone app拨打电话

- (void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler {
    if (navigationAction.navigationType == WKNavigationTypeLinkActivated && [navigationAction.request.URL.scheme isEqualToString:@"tel"]) {
        [UIApplication.sharedApplication openURL:navigationAction.request.URL options:@{} completionHandler:^(BOOL success) {
            NSLog(@"Successfully open url:%@",navigationAction.request.URL);
        }];
        decisionHandler(WKNavigationActionPolicyCancel);
    } else {
        decisionHandler(WKNavigationActionPolicyAllow);
    }
}

实现了该方法后，必须调用decisionHandler块。该块参数为WKNavigationAction枚举常量。WKNavigationActionPolicyCancel取消导航，WKNavigationActionPolicyAllow继续导航。

WKNavigationAction对象包含引起本次导航的信息，用于决定是否允许本次导航。其属性如下：

request：本次导航的request。
sourceFrame：WKFrameInfo类型，请求本次导航frame信息。
targetFrame：目标frame。如果导航至新窗口，则targetFrame为nil。
navigationType：WKNavigationType枚举类型，为以下常量：
WKNavigationTypeLinkActivated：用户点击href链接。
WKNavigationTypeFormSubmitted：提交表格。
WKNavigationTypeBackForward：请求前进、后退列表中item。
WKNavigationTypeReload：刷新网页。
WKNavigationTypeFormResubmitted：因后退、前进、刷新等重新提交表格。
WKNavigationTypeOther：其他原因。
WKFrameInfo对象包含了一个网页中的frame信息，其只是一个描述瞬时状态 (transient) 的纯数据 (data-only) 对象，不能在多次消息调用中唯一标志某个frame。

如果需要在response后操作导航，需要实现webView:decidePolicyForNavigationResponse:decisionHandler:方法。WKNavigationResponse对象包含navigation response信息，用于决定是否接收response。其属性如下：

canShowMIMEType：布尔类型值，指示WebKit是否显示MIME类型内容。
forMainFrame：布尔类型值，指示即将导航至的frame是否为main frame。
response：NSURLResponse类型。
实现了该方法后，必须调用decisionHandler块，否则会在运行时抛出异常。decisionHandler块参数为WKNavigationResponsePolicy枚举类型。WKNavigationResponseCancel取消导航，WKNavigationResponseAllow继续导航。

Navigation action 和 navigation response 既可以在处理完毕后立即调用decisionHandler，也可以异步调用。

5. WKUIDelegate

WKWebView与 Safari 类似，尽管前者在一个窗口显示内容。如果需要打开多个窗口、监控打开、关闭窗口，修改用户点击元素时显示哪些选项，需要使用WKUIDelegate协议。

首先，声明遵守WKUIDelegate协议：

@interface ViewController () <WKUIDelegate>

其次，指定遵守WKUIDelegate协议的类为 web view 代理：

self.webView.uiDelegate = self;

最后，根据需要实现WKUIDelegate协议内方法。

5.1 新窗口打开

如何响应 JavaScript 的打开新窗口函数、或target="_blank"标签？有以下三种方法：

创建新的WKWebView，并在新的页面打开。
在 Safari 浏览器打开。
捕捉 JS ，在同一个WKWebView加载。
当 URL 为 mail、tel、sms 和 iTunes链接时交由系统处理。此时，系统会交由对应 app 处理。其他情况在当前 web view 加载。

5.2 响应 JavaScript 弹窗
在响应 JavaScript 时，可以通过WKUIDelegate协议使用 native UI呈现，有以下三种方法：

1、webView:runJavaScriptAlertPanelWithMessage:initiatedByFrame:completionHandler:：为了用户安全，在该方法的实现中需要需要标志出提供当前内容的网址，最为简便的方法便是frame.request.URL.host，响应面板应只包含一个OK按钮。当 alert panel 消失后，调用completionHandler。
2、webView:runJavaScriptConfirmPanelWithMessage:initiatedByFrame:completionHandler:：为了用户安全，在该方法的实现中需要需要标志出提供当前内容的网址，最为简便的方法便是frame.request.URL.host，响应面板包括两个按钮，一般为OK和Cancel。当 alert panel 消失后，调用completionHandler。如果用户点击的是OK按钮，为completionHandler传入YES；如果用户点击的是Cancel按钮，为completionHandler传入NO。
3、webView:runJavaScriptTextInputPanelWithPrompt:defaultText:initiatedByFrame:completionHandler:：为了用户安全，在该方法的实现中需要需要标志出提供当前内容的网址，最为简便的方法便是frame.request.URL.host，响应面板包括两个按钮（一个OK按钮，一个Cancel按钮）和一个输入框。当面板消失时调用completionHandler，如果用户点击的是OK按钮，传入文本框文本；否则，传入nil。

例如，输入账号、密码前点击登陆按钮，大部分网页会弹出警告框。在 JavaScript 中，会弹出 alert 或 confirm box。

JavaScript alert 会堵塞当前进程，调用completionHandler后 JavaScript 才会继续执行。

6. WKURLSchemeHandler

UIWebView支持自定义NSURLProtocol协议。如果想要加载自定义 URL 内容，可以通过创建、注册NSURLProtocol子类实现。此后，任何调用自定义 scheme (例如，hello world://) 的方法，都会调用NSURLProtocol子类，在NSURLProtocol子类处理自定义 scheme ，这将非常实用。例如，在 book 中加载图片、视频等。

WKWebView不支持NSURLProtocol协议，因此不能加载自定义 URL Scheme。在 iOS 11 中，Apple 为 WebKit framework 增加了WKURLSchemeHandler协议，用于加载自定义 URL Scheme。

WebKit遇到无法识别的 URL时，会调用WKURLSchemeHandler协议。该协议包括以下两个必须实现的方法：

webView:startURLSchemeTask:：加载资源时调用。
webView:stopURLSchemeTask:：WebKit 调用该方法以终止 (stop) 任务。调用该方法后，不得调用WKURLSchemeTask协议的任何方法，否则会抛出异常。
使用WKURLSchemeHandler协议处理完毕任务后，调用WKURLSchemeTask协议内方法加载资源。WKURLSchemeTask协议包括request属性，该属性为NSURLRequest类型对象。还包含以下方法：

didReceiveResponse:：设置当前任务的 response。每个 task 至少调用一次该方法。如果尝试在任务终止或完成后调用该方法，则会抛出异常。
didReceiveData:：设置接收到的数据。当接收到任务最后的 response 后，使用该方法发送数据。每次调用该方法时，新数据会拼接到先前收到的数据中。如果尝试在发送 response 前，或任务完成、终止后调用该方法，则会引发异常。
didFinish：将任务标记为成功完成。如果尝试在发送 response 前，或将已完成、终止的任务标记为完成，则会引发异常。
didFailWithError:：将任务标记为失败。如果尝试将已完成、失败，终止的任务标记为失败，则会引发异常。
在WKURLSchemeHandler协议方法内，可以获取到请求的request。因此，可以提取 URL 中任何内容，并将数据转发给WKWebView进行加载。

下面的方法分别使用 url 、custom URL Scheme加载网络图片和相册图片：

- (void)webView:(WKWebView *)webView startURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
        NSURL *url = urlSchemeTask.request.URL;
        if ([url.absoluteString containsString:@"custom-scheme"]) {
            NSArray<NSURLQueryItem *> *queryItems = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:YES].queryItems;
            for (NSURLQueryItem *item in queryItems) {
                
                // example: custom-scheme://path?type=remote&url=https://placehold.it/120x120&text=image1
                if ([item.name isEqualToString:@"type"] && [item.value isEqualToString:@"remote"]) {
                    for (NSURLQueryItem *queryParams in queryItems) {
                        if ([queryParams.name isEqualToString:@"url"]) {
                            NSString *path = queryParams.value;
                            path = [path stringByReplacingOccurrencesOfString:@"\\" withString:@""];
                            
                            // 获取图片
                            NSURLSession *session = [NSURLSession sharedSession];
                            NSURLSessionDataTask *task = [session dataTaskWithURL:[NSURL URLWithString:path] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
                                [urlSchemeTask didReceiveResponse:response];
                                [urlSchemeTask didReceiveData:data];
                                [urlSchemeTask didFinish];
                            }];
                            [task resume];
                        }
                    }
                } else if ([item.name isEqualToString:@"type"] && [item.value isEqualToString:@"photos"]) { // example: custom-scheme://path?type=photos
                    dispatch_async(dispatch_get_main_queue(), ^{
                        self.imagePicker = [[ImagePicker alloc] init];
                        [self.imagePicker showGallery:^(BOOL flag, NSURLResponse * _Nonnull response, NSData * _Nonnull data) {
                            if (flag) {
                                [urlSchemeTask didReceiveResponse:response];
                                [urlSchemeTask didReceiveData:data];
                                [urlSchemeTask didFinish];
                            } else {
                                NSError *error = [NSError errorWithDomain:urlSchemeTask.request.URL.absoluteString code:0 userInfo:NULL];
                                [urlSchemeTask didFailWithError:error];
                            }
                        }];
                    });
                }
            }
        }
    });
}

- (void)webView:(WKWebView *)webView stopURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
    NSError *error = [NSError errorWithDomain:urlSchemeTask.request.URL.absoluteString code:0 userInfo:NULL];
    [urlSchemeTask didFailWithError:error];
}

实现上述方法的类必须遵守WKURLSchemeHandler协议。另外，必须在WKWebView的配置中注册所支持的 URL Scheme：

// 添加要自定义的url scheme
        [_webConfiguration setURLSchemeHandler:self forURLScheme:@"custom-scheme"];

运行如下：

总结

WebKit为 iOS 、macOS 开发人员提供了一套强大的开发工具，可以直接在 app 网页视图中操作 JavaScript，使用 user script 将 JavaScript 注入网页，使用WKScriptMessageHandler协议接收 JavaScript 消息。使用WKNavigationDelegate协议自定义网页导航，使用WKUIDelegate在网页上呈现 native UI，使用WKURLSchemeHandler加载自定义 URL Scheme 内容。

如果只是简单呈现网页视图，推荐使用 iOS 9 推出的SFSafariViewController，几行代码就可实现与 Safari 一样的体验。SFSafariViewController还提供了自动填充、欺诈网站监测等功能。

Demo名称：WebKit
源码地址：https://github.com/pro648/BasicDemos-iOS/tree/master/WebKit

链接：https://www.jianshu.com/p/65c66f924d56

pthread多线程(C语言) + Socket

pthread是使用使用C语言编写的多线程的API， 简称Pthreads ，是线程的POSIX标准，可以在Unix / Linux / Windows 等系统跨平台使用。在类Unix操作系统（Unix、Linux、Mac OS X等）中，都使用Pthreads作为操作系统的线程。

GitHub项目FanSocket(纯C语言socket+线程队列)+其他demo客户端

1.线程创建

//子线程1
void test1(int *a){
    printf("线程test1");
    //修改自己的子线程系统释放，注释打开后，线程不能用pthread_join方法
    //pthread_detach(pthread_self());
}
//子线程2
void test2(int *a){
    printf("线程test2");
}

/*
int  pthread_create(pthread_t  *  thread, //新线程标识符
pthread_attr_t * attr, //新线程的运行属性
void * (*start_routine)(void *), //线程将会执行的函数
void * arg);//执行函数的传入参数，可以为结构体
*/

//创建线程方法一    （手动释放线程）
int a=10;
pthread_t pid;
pthread_create(&pid, NULL, (void *)test1, (void *)&a);


//线程退出或返回时，才执行回调，可以释放线程占用的堆栈资源（有串行的作用）
if(pthread_join(pid, NULL)==0){
    //线程执行完成
    printf("线程执行完成：%d\n",threadIndex);
    if (message!=NULL) {
        printf("线程执行完成了\n");
    }
}


//创建线程方法二  （自动释放线程）
//设置线程属性
pthread_attr_t attr;
pthread_attr_init (&attr);
//线程默认是PTHREAD_CREATE_JOINABLE，需要pthread_join来释放线程的
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
//线程并发
int rc=pthread_create(&pid, &attr, (void *)test2, (void *)a);
pthread_attr_destroy (&attr);
if (rc!=0) {
    printf("创建线程失败\n");
    return;
}

2.线程退出和其他

pthread_exit (tes1) //退出当前线程
pthread_main_np () // 获取主线程

//主线程和子线程
if(pthread_main_np()){
    //main thread
}else{
    //others thread
}

int pthread_cancel(pthread_t thread)；//发送终止信号给thread线程,如果成功则返回0
int pthread_setcancelstate(int state, int *oldstate)；//设置本线程对Cancel信号的反应
int pthread_setcanceltype(int type, int *oldtype)；//设置本线程取消动作的执行时机
void pthread_testcancel(void)；//检查本线程是否处于Canceld状态，如果是，则进行取消动作，否则直接返回

3 线程互斥锁（量）与条件变量

3.1 互斥锁(量)

//静态创建
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//动态创建
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
//注销互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

//lock 和unlock要成对出现，不然会出现死锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
//判断是否可以加锁，如果可以加锁并返回0，否则返回非0
int pthread_mutex_trylock(pthread_mutex_t *mutex);

3.2 条件变量

1、条件变量是利用线程间共享的全局变量进行同步的一种机制，
2、一个线程等待”条件变量的条件成立”而挂起；
3、另一个线程使”条件成立”（给出条件成立信号）。
4、为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。

//静态创建
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
//动态创建
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
//注销条件变量
int pthread_cond_destroy(pthread_cond_t *cond);
//条件等待，和超时等待
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, 
                           const struct timespec *abstime);
//开启条件，启动所有等待线程
int pthread_cond_broadcast(pthread_cond_t *cond);
//开启一个等待信号量
int pthread_cond_signal(pthread_cond_t *cond);

4.线程同步：互斥锁（量）与条件变量(具体封装实现)

/*全局的队列互斥条件*/
extern pthread_cond_t fan_cond;
extern pthread_cond_t fan_cond_wait;
/*全局的队列互斥锁*/
extern pthread_mutex_t fan_mutex;
//extern pthread_mutex_t fan_mutex_wait;

extern int fan_thread_status;//0=等待 1=执行 -1=清空所有
extern int fan_thread_clean_status;//0=默认  1=清空所有

//开启线程等待  return=-2一定要处理
extern int fan_thread_start_wait(void);
//正常的超时后继续打开下一个信号量 return=-2一定要处理
int fan_thread_start_timedwait(int sec);
//启动线程，启动信号量
extern int fan_thread_start_signal(void);
//启动等待信号量
extern int fan_thread_start_signal_wait(void);
//暂停线程
extern int fan_thread_end_signal(void);
//初始化互斥锁
extern int fan_thread_queue_init(void);
//释放互斥锁信号量
extern int fan_thread_free(void);

//让队列里面全部执行完毕，而不是关闭线程；
extern int fan_thread_clean_queue(void);
//每次关闭清空后，等待1-2秒，要恢复状态，不然线程添加
extern int fan_thread_init_queue(void);
//设置线程的优先级，必须在子线程
extern int fan_thread_setpriority(int priority);

线程队列互斥，并且按入队顺序，一个一个按照外部条件，触发信号量，主要是等待队列，

/*全局的队列互斥条件*/
pthread_cond_t fan_cond=PTHREAD_COND_INITIALIZER;
pthread_cond_t fan_cond_wait=PTHREAD_COND_INITIALIZER;

/*全局的队列互斥锁*/
pthread_mutex_t fan_mutex = PTHREAD_MUTEX_INITIALIZER;
//pthread_mutex_t fan_mutex_wait = PTHREAD_MUTEX_INITIALIZER;
int fan_thread_status=1;//0=等待 1=执行
int fan_thread_clean_status;//0=默认  1=清空所有

//开启线程等待
int fan_thread_start_wait(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_clean_status=0;
    while (fan_thread_status==0) {
        pthread_cond_wait(&fan_cond, &fan_mutex);
        if (fan_thread_clean_status==1) {
            break;
        }
    }
    if (fan_thread_clean_status==1) {
        pthread_mutex_unlock(&fan_mutex);
        return -2;
    }
    if (fan_thread_status==1) {
        fan_thread_status=0;
        pthread_mutex_unlock(&fan_mutex);
    }else{
        pthread_mutex_unlock(&fan_mutex);
    }
    return 0;
}
//正常的超时后继续打开下一个信号量
int fan_thread_start_timedwait(int sec){
    int rt=0;
    pthread_mutex_lock(&fan_mutex);
    struct timeval now;
    struct timespec outtime;
    gettimeofday(&now, NULL);
    outtime.tv_sec = now.tv_sec + sec;
    outtime.tv_nsec = now.tv_usec * 1000;
    
    int result = pthread_cond_timedwait(&fan_cond_wait, &fan_mutex, &outtime);
    if (result!=0) {
        //线程等待超时
        rt=-1;
    }
    if (fan_thread_clean_status==1) {
        rt = -2;
    }
    pthread_mutex_unlock(&fan_mutex);
    return rt;
}
//启动线程，启动信号量
int fan_thread_start_signal(void){
    int rs=pthread_mutex_trylock(&fan_mutex);
    if(rs!=0){
        pthread_mutex_unlock(&fan_mutex);
    }
    fan_thread_status=1;
    pthread_cond_signal(&fan_cond);
//    pthread_cond_broadcast(&fan_cond);//全部线程
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//开启等待时间的互斥信号量
int fan_thread_start_signal_wait(void){
    int rs=pthread_mutex_trylock(&fan_mutex);
    if(rs!=0){
        pthread_mutex_unlock(&fan_mutex);
    }
//    fan_thread_status=1;
    pthread_cond_signal(&fan_cond_wait);
    //    pthread_cond_broadcast(&fan_cond);//全部线程
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//暂停下一个线程
int fan_thread_end_signal(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_status=0;
    pthread_cond_signal(&fan_cond);
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//初始化互斥锁（动态创建）
int fan_thread_queue_init(void){
    pthread_mutex_init(&fan_mutex, NULL);
    pthread_cond_init(&fan_cond, NULL);
    return 0;
}
//释放互斥锁和信号量
int fan_thread_free(void)
{
    pthread_mutex_destroy(&fan_mutex);
    pthread_cond_destroy(&fan_cond);
    return 0;
}

//清空所有的队列
int fan_thread_clean_queue(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_clean_status=1;
    pthread_cond_broadcast(&fan_cond);
    pthread_cond_broadcast(&fan_cond_wait);
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//恢复队列
int fan_thread_init_queue(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_clean_status=0;
    fan_thread_status=1;
    pthread_cond_signal(&fan_cond);
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//设置线程的优先级，必须在子线程
int fan_thread_setpriority(int priority){
    struct sched_param sched;
    bzero((void*)&sched, sizeof(sched));
//    const int priority1 = (sched_get_priority_max(SCHED_RR) + sched_get_priority_min(SCHED_RR)) / 2;
    sched.sched_priority=priority;
    //SCHED_OTHER(正常,非实时)SCHED_FIFO(实时，先进先出)SCHED_RR(实时、轮转法)
    pthread_setschedparam(pthread_self(), SCHED_RR, &sched);
    return 0;
}

5 其他线程方法

//return=0:线程存活。ESRCH：线程不存在。EINVAL：信号不合法。
int kill_ret=pthread_kill(pid, 0);//测试线程是否存在
printf("线程状态：%d\n",kill_ret);
if(kill_ret==0){
    //关闭线程
    pthread_cancel(pid);
}


pthread_equal(pid, pid1);//比较两个线程ID是否相同


//函数执行一次
pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_once(&once, test1);

转自：https://www.jianshu.com/p/6fcd478635e2

据财经媒体报道：FIL将在6月底进行系统升级，FIL升级对矿工有哪些利好？那对与刚了解FIL挖矿的朋友们现在正是参与的好时机+slf81818，为什么呢？一起来了解下：

Filecoin’s v13 HyperDrive网络升级的重要意义在于：

一：人类宝贵信息的可验证存储容量将增长10—25倍。

二：GAS费大幅降低，无限期限接近于0。

三：质押费快速下降，新进场的投入成本明显降低，更有利于生态发展。

四：参与存储商激增，将实现更快的网络增长。

五：三大运营商之一（移动电信联通）智慧城市的数据将接入储存IPFS系统，进一步促进IPFS的应用落地，或将成为IPFS历史级重大标志性事件。

Filecoin V13版本的更新将是颠覆性的，也是突破共识的一次更新。其目的也不仅仅是降低Gas费，而是释放带宽，为Filecoin添加智能合约功能做准备。

目前FIL市场的具体情况具体分析，大多数人都在观望，主要还是带着想要一夜暴富的想法去炒币。这完全是两个概念，炒币没有哪个不伤筋动骨，这还是要轻的，可以考虑一下它的恐怖程度！为什么说矿工总是食物链的顶端？合理的投资方式是看其长期收益，不需要过多地去看目前的价格高低，手中的矿机每天都能产出 FIL，不用管它涨跌，相反，炒币就是你买了多少就有多少，性质不同。

例如，买一只鸡来给你每天生蛋，头七天价格比以前低，把鸡蛋存起来不卖，第八天它的价格达到了你想要的市场价就全部卖掉，与此相反，你直接买鸡蛋来倒买倒卖，风险成本是显而易见的。炒币看运气，屯币看心态，矿机相当于永动机。

现在币价低，加入挖矿成本也会很低，最重要的是其日产币并未降低，反而还在增加产量，这也大大缩短了回本周期，未来币价上涨，矿机也将随之涨价，人多挖矿效率肯定不如现在人少，回本周期更是大幅拉长，挖矿最大优势在于自身持币增多，有“粮”就能度过寒冬，躲过熊市就是迎来资产爆发的喜悦。感谢大家关注芳姐+slf81818，了解更多币圈最新资讯。

前言

很高兴遇见你~

今天准备和大家分享的是 LayoutInflater，我给它取名：布局打气筒，很形象，其实就是根据英文翻译过来的😂。我们知道气球打气筒可以给气球打气从而改变它的形状。而布局打气筒的作用就是给我们的 Xml 布局打气让它变成一个个 View 对象。在我们的日常工作中，经常会接触到他，因为只要你写了 Xml 布局，你就要使用 LayoutInflater，下面我们就来好好讲讲它。

注意：本文所展示的系统源码都是基于Android-30 ，并提取核心部分进行分析

一、基本使用

1、LayoutInflater 实例获取

1）、通过 LayoutInflater 的静态方法 from 获取

2）、通过系统服务 getSystemService 方法获取

3）、如果是在 Activity 或 Fragment 可直接获取到实例

//1、通过 LayoutInflater 的静态方法 from 获取

val layoutInflater: LayoutInflater = LayoutInflater.from(this)



//2、通过系统服务 getSystemService 方法获取

val layoutInflater: LayoutInflater = getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater



//3、如果是在 Activity 或 Fragment 可直接获取到实例

layoutInflater //相当于调用 getLayoutInflater()

 

实际上，1 是 2 的简单写法，只是 Android 给我们做了一下封装。拿到 LayoutInflater 实例后，我们就可以调用它的 inflate 系列方法了，这几个方法是本篇文章的一个重点，如下：

从 Xml 布局到创建 View 对象，这几个方法扮演着至关重要的作用，其中我们用的最多就是第一个和第三个重载方法，现在我们就来使用一下

二、例子

1、创建一个新项目，MainActivity 对应的布局如下：

<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout

    xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:id="@+id/cons_main"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity"/>

 

2、创建一个新的布局取名 item_main.xml，如下图：

3、修改 MainActivity 中的代码

class MainActivity : AppCompatActivity() {

  

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_main)

      

        val consMain = findViewById<ConstraintLayout>(R.id.cons_main)

        val itemMain = layoutInflater.inflate(R.layout.item_main, null)

        consMain.addView(itemMain)

    }

}

 

上述代码我们使用了两个参数的 inflate 重载方法，第二个参数 root 传了一个 null ，然后把当前布局添加到 Activity 中，运行看下效果：

啥情况？怎么和预想的不一样呢？我的背景颜色怎么不见了？把这个问题 1 先记着

接下来，我们修改一下 MainActivity 中的代码，如下：

val itemMain = layoutInflater.inflate(R.layout.item_main, consMain)

//等同下面这行代码

val itemMain = layoutInflater.inflate(R.layout.item_main, consMain,true)

 

实际上上面这句代码就相当于调用了三个参数的重载方法，且第三个参数为 true，我们看下它两个参数的源码：

public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {

    return inflate(resource, root, root != null);

}

 

现在在运行看下结果：

报错了，提示我们当前 child 已经有了一个父 View，你必须先调用父 View 的 removeView 方法移除当前 child 才行。是不是疑问更多了呢？把这个问题 2 也先记着

我们在修改一下 MainActivity 中的代码，如下：

val itemMain = layoutInflater.inflate(R.layout.item_main, consMain,false)

 

在运行看下结果：

嗯，现在达到了我们预期的效果

现在回到上面那两个问题，分析发现是 LayoutInflater inflate 方法传了不同的参数导致的，那这些参数到底有什么玄乎的地方呢？接下来跟着我的脚步分析下源码，或许你就豁然开朗了

三、LayoutInflater inflate 系列方法源码分析

在分析源码之前，我们需要明白一些基础知识：

我们一般都会使用 layout_width 和 layout_height 来设置 View 的大小，实际上是要满足一个条件，那就是这个 View 必须存在于一个容器或布局中，否则没有意义，之后如果将 layout_width 设置成 match_parent 表示让 View 的宽度填充满布局，如果设置成 wrap_content 表示让 View 的宽度刚好可以包含其内容，如果设置成具体的数值则 View 的宽度会变成相应的数值。这也是为什么这两个属性叫作 layout_width 和layout_height，而不是 width 和 height 。

明白了上面这些知识，我们继续往下看

实际上，我们调用 LayoutInflater inflate 系列方法，最终都会走到上述截图的第 4 个重载方法，看下它的源码，仅贴出关键代码：

public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {

    synchronized (mConstructorArgs) {

       //...

       //获取布局 Xml 里面的属性集合

       AttributeSet attrs = Xml.asAttributeSet(parser);

       // 将传入的 root 赋值 给 result 

       View result = root;

     

       // 创建根 View 赋值给 temp

       final View temp = createViewFromTag(root, name, inflaterContext, attrs);

			

       ViewGroup.LayoutParams params = null;

			

       if (root != null) {

           //...

           //如果传入的 root 不为空，通过 root 和布局属性生成布局参数

           params = root.generateLayoutParams(attrs);

           if (!attachToRoot) {

             	// 如果传入的 attachToRoot 为 false 则给当前创建的根 View 设置布局参数

                temp.setLayoutParams(params);

           }

       }

                  

       //递归创建子 View 并添加到父布局中

       rInflateChildren(parser, temp, attrs, true);



       if (root != null && attachToRoot) {

           //如果 root 不为空且 attachToRoot 为 true，添加当前创建的根 View 到 root      

           root.addView(temp, params);

       }



       if (root == null || !attachToRoot) {

           //如果 root 为空或者 attachToRoot 为 false, 将当前创建的根 View 赋值给 result

           result = temp;

       }

      

       //...

       //返回当前 result

       return result;

   }

}

 

上述代码我们可以得到一些结论：

1、如果传入的 root 不为 null 且 attachToRoot 为 false，此时会给 Xml 布局生成的根 View 设置布局参数

注意：Xml 布局生成的根 View 并没有被添加到任何其他 View 中，此时根 View 的布局属性不会生效，但是我们给它设置了布局参数，那么它就会生效，只是没有被添加到任何其他 View 中

2、如果传入的 root 不为 null 且 attachToRoot 为 true，此时会将 Xml 布局生成的根 View 通过 addView 方法携带布局参数添加到 root 中

注意：此时 Xml 布局生成的根 View 已经被添加到其他 View 中，注意避免重复添加而报错

3、如果传入的 root 为 null ，此时会将 Xml 布局生成的根 View 对象直接返回

注意：此时 Xml 布局生成的根 View 既没有被添加到其他 View 中，也没有设置布局参数，那么它的布局参数将会失效

明白了上面这些知识点，我们在看下为啥为会出现之前那些问题

四、问题分析

1、问题 1

上述问题 1 实际上我们是调用了 LayoutInflater 两个参数的 inflate 重载方法：

inflate(@LayoutRes int resource, @Nullable ViewGroup root)

 

传入的实参： resouce 传入了一个 Xml 布局，root 传入了 null

根据我们上面源码得到的结论，当传入的 root 为 null ，此时会将 Xml 布局生成的根 View 对象直接返回

那么此时这个布局根 View 不在任何 View 中，因此它的布局属性失效了，但是 TextView 在一个布局中，它的布局属性会生效，因此就出现了上述截图中的效果

2、问题 2

上述问题 2 我们调用的还是 LayoutInflater 两个参数的构造方法

传入的实参： resouce 传入了一个 Xml 布局，root 传入了 consMain

实际又会调用 LayoutInflater 三个参数的 inflate 重载方法：

inflate(@LayoutRes int resource, @Nullable ViewGroup root,boolean attachToRoot)

 

此时传入实参变为：resouce 传入了一个 Xml 布局，root 传入了 consMain，attachToRoot 传入了 true

根据我们上面源码得到的结论：当传入的 root 不为 null 且 attachToRoot 为 true，此时会将 Xml 布局生成的根 View 通过 addView 方法携带布局参数添加到 root 中

此时我们在 MainActivity 中又重复调用了 addView 方法，因此就报那个错了。如果想不报错，把 MainActivity 中的那行 addView 去掉就可以了

3、预期效果

上述预期效果，我们调用的是 LayoutInflater 三个参数的 inflate 重载方法

传入的实参：resouce 传入了一个 Xml 布局，root 传入了 consMain，attachToRoot 传入了 false

根据我们上面源码得到的结论：当传入的 root 不为 null 且 attachToRoot 为 false，此时会给 Xml 布局生成的根 View 对象设置布局参数

此时根 View 的布局属性会生效，只不过没有被添加到任何 View 中，而又因为 MainActivity 中调用了 addView 方法，把当前根 View 添加了进去，所以达到了我们预期的效果

到这里，你是否明白了 LayoutInflater inflate 方法的应用了呢？

如果还有疑问，欢迎评论区给我提问，我们一起讨论

五、为啥 Activity 中布局根 View 的布局属性会生效？

看下面这张图：

注意：Android 版本号和应用主题会影响到 Activity 页面组成，这里以常见页面为例

我们的页面中有一个顶级 View 叫 DecorView，DecorView 中包含一个竖直方向的 LinearLayout，LinearLayout 由两部分组成，第一部分是标题栏，第二部分是内容栏，内容栏是一个FrameLayout，我们在 Activity 中调用 setContentView 就是将 View 添加到这个FrameLayout 中。

看到这里你应该也明白了：Activity 中布局根 View 的布局属性之所以能生效，是因为 Android 会自动在布局文件的最外层再嵌套一个FrameLayout

六、总结

本篇文章重点内容：

1、 LayoutInflater inflate 方法参数的应用，记住下面这个规律：

• 当传入的 root 不为 null 且 attachToRoot 为 false，此时会给 Xml 布局生成的根 View 设置布局参数
• 当传入的 root 不为 null 且 attachToRoot 为 true，此时会将 Xml 布局生成的根 View 通过 addView 方法携带布局参数添加到 root 中
• 当传入的 root 为 null ，此时会将 Xml 布局生成的根 View 对象直接返回

2、Activity 中布局根 View 的布局属性会生效是因为 Android 会自动在布局文件的最外层再嵌套一个 FrameLayout

前言

#ViewRootImpl

void scheduleTraversals() {

    if (!mTraversalScheduled) {

        mTraversalScheduled = true;

        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();

      	//重点关注这里：绘制的操作封装在mTraversalRunnable里，交给`Choreographer`类处理

        mChoreographer.postCallback(

                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

       //...

    }

}

 

#Choreographer

public void postCallback(int callbackType, Runnable action, Object token) {

    postCallbackDelayed(callbackType, action, token, 0);

}

public void postCallbackDelayed(int callbackType,

        Runnable action, Object token, long delayMillis) {

    //...

    postCallbackDelayedInternal(callbackType, action, token, delayMillis);

}

 

#Choreographer

private void postCallbackDelayedInternal(int callbackType,

        Object action, Object token, long delayMillis) {

  synchronized (mLock) {

    //把当前的runnable加入到callback队列中

    mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);

     //达到期限时间

    if (dueTime <= now) {

       scheduleFrameLocked(now);

    } else {

       Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);

       msg.arg1 = callbackType;

       msg.setAsynchronous(true);

       mHandler.sendMessageAtTime(msg, dueTime);

    }

  }

}

 

#Choreographer

//默认使用VSync同步机制

private static final boolean USE_VSYNC = SystemProperties.getBoolean(

            "debug.choreographer.vsync", true);

private void scheduleFrameLocked(long now) {

    if (!mFrameScheduled) {

        mFrameScheduled = true;

        //是否使用VSync同步机制

        if (USE_VSYNC) {

            //是否在主线程

            if (isRunningOnLooperThreadLocked()) {

                scheduleVsyncLocked();

            } else {

                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);

                msg.setAsynchronous(true);

                mHandler.sendMessageAtFrontOfQueue(msg);

            }

        } else {

            final long nextFrameTime = Math.max(

                    mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);

            if (DEBUG_FRAMES) {

                Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms.");

            }

            Message msg = mHandler.obtainMessage(MSG_DO_FRAME);

            msg.setAsynchronous(true);

            mHandler.sendMessageAtTime(msg, nextFrameTime);

        }

    }

}

 

#Choreographer

private final FrameDisplayEventReceiver mDisplayEventReceiver;

private void scheduleVsyncLocked() {

  	//调用DisplayEventReceiver的scheduleVsync

    mDisplayEventReceiver.scheduleVsync();

}

 

#DisplayEventReceiver

public abstract class DisplayEventReceiver {

	public DisplayEventReceiver(Looper looper, int vsyncSource) {

    //初始化一个接收者

  	mReceiverPtr = nativeInit(new WeakReference<DisplayEventReceiver>(this), mMessageQueue,

                vsyncSource);

	}



	public void scheduleVsync() {

    //初始化的接收者对象mReceiverPtr传进去

    nativeScheduleVsync(mReceiverPtr);

	}

}

 

#Choreographer.FrameDisplayEventReceiver

private final class FrameDisplayEventReceiver extends DisplayEventReceiver

        implements Runnable {

   public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {

       super(looper, vsyncSource);

   }

          

   @Override

   public void onVsync(long timestampNanos, long physicalDisplayId, int frame) {

     //...

     long now = System.nanoTime();

     mTimestampNanos = timestampNanos;

     mFrame = frame;

     Message msg = Message.obtain(mHandler, this);

     msg.setAsynchronous(true);

     //timestampNanos / TimeUtils.NANOS_PER_MS 时间后走run方法

     mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);

   }



   @Override

   public void run() {

     mHavePendingVsync = false;

     //接收到同步信号后执行

     doFrame(mTimestampNanos, mFrame);

   }

 }

 

void doFrame(long frameTimeNanos, int frame) {

    final long startNanos;

    synchronized (mLock) {

      if (!mFrameScheduled) {

          return; // no work to do

      }

      long intendedFrameTimeNanos = frameTimeNanos;

      startNanos = System.nanoTime();

      //抖动时间： 当前时间 - 同步信号通知的时间

      final long jitterNanos = startNanos - frameTimeNanos;

      //mFrameIntervalNanos = (long)(1000000000 / getRefreshRate()) 类似 1s/60hz = 16.6ms，不过这里是纳秒为单位

      //抖动时间超过了一帧刷新的时间，即发生了Jank

      if (jitterNanos >= mFrameIntervalNanos) {

          final long skippedFrames = jitterNanos / mFrameIntervalNanos;

          //计算调帧数，超过一定限制（默认30），就表示应用在主线程做了大量工作，影响了绘制，打印提示

          if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {

              Log.i(TAG, "Skipped " + skippedFrames + " frames!  "

                      + "The application may be doing too much work on its main thread.");

          }

          final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;

          frameTimeNanos = startNanos - lastFrameOffset;

      }

      //...

    }



    try {

        //按顺序执行任务（这里只留了核心代码）

        doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_INSETS_ANIMATION, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);

    } finally {}

}

 

 mChoreographer.postCallback(

                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

 

void doCallbacks(int callbackType, long frameTimeNanos) {

    CallbackRecord callbacks;

    synchronized (mLock) {

        final long now = System.nanoTime();

        callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(

                now / TimeUtils.NANOS_PER_MS);

        if (callbacks == null) {

            return;

        }

        mCallbacksRunning = true;

    try {

        for (CallbackRecord c = callbacks; c != null; c = c.next) {

          //注意这里：执行CallbackRecord的run方法

          c.run(frameTimeNanos);

        }

    } finally {

        synchronized (mLock) {

            mCallbacksRunning = false;

            do {

                final CallbackRecord next = callbacks.next;

              	//回收处理完的CallbackRecord

                recycleCallbackLocked(callbacks);

                callbacks = next;

            } while (callbacks != null);

        }

    }

}

 

private static final class CallbackRecord {

    public CallbackRecord next;

    public long dueTime;

    public Object action; // Runnable or FrameCallback

    public Object token;



    public void run(long frameTimeNanos) {

        if (token == FRAME_CALLBACK_TOKEN) {

            ((FrameCallback)action).doFrame(frameTimeNanos);

        } else {

           //执行我们最初post的Runnable

           ((Runnable)action).run();

        }

    }

}

 

 mChoreographer.postCallback(

                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

 

在音视频或 OpenGL 开发中，文字渲染是一个高频使用的功能，比如制作一些酷炫的字幕、为视频添加水印、设置特殊字体等等。

// 创建一个 bitmap 

Bitmap bitmap = Bitmap.createBitmap(width, hight, Bitmap.Config.ARGB_8888);

// 初始化画布绘制的图像到 bitmap 上

Canvas canvas = new Canvas(bitmap);

// 建立画笔

Paint paint = new Paint(); 

// 获取更清晰的图像采样，防抖动

paint.setDither(true); 

paint.setFilterBitmap(true);

// 绘制文字到 bitmap

canvas.drawText text, x, y,paint);

 

int[] textureIds = new int[1];

//创建纹理

GLES20.glGenTextures(1, textureIds, 0);

mTexId = textureIds[0];

//绑定纹理

GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexId);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);



ByteBuffer bitmapBuffer = ByteBuffer.allocate(bitmap.getHeight() * bitmap.getWidth() * 4);//RGBA

bitmap.copyPixelsToBuffer(bitmapBuffer);

bitmapBuffer.flip();



//设置内存大小绑定内存地址

GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, mWatermarkBitmap.getWidth(), mWatermarkBitmap.getHeight(),

        0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, bitmapBuffer);



//解绑纹理

GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);

 

https://www.freetype.org/

 

LOCAL_PATH:= $(call my-dir)



include $(CLEAR_VARS)





LOCAL_SRC_FILES := \

        ./src/autofit/autofit.c \

        ./src/base/ftbase.c \

        ./src/base/ftbbox.c \

        ./src/base/ftbdf.c \

        ./src/base/ftbitmap.c \

        ./src/base/ftcid.c \

        ./src/base/ftdebug.c \

        ./src/base/ftfstype.c \

        ./src/base/ftgasp.c \

        ./src/base/ftglyph.c \

        ./src/base/ftgxval.c \

        ./src/base/ftinit.c \

        ./src/base/ftlcdfil.c \

        ./src/base/ftmm.c \

        ./src/base/ftotval.c \

        ./src/base/ftpatent.c \

        ./src/base/ftpfr.c \

        ./src/base/ftstroke.c \

        ./src/base/ftsynth.c \

        ./src/base/ftsystem.c \

        ./src/base/fttype1.c \

        ./src/base/ftwinfnt.c \

        ./src/bdf/bdf.c \

        ./src/bzip2/ftbzip2.c \

        ./src/cache/ftcache.c \

        ./src/cff/cff.c \

        ./src/cid/type1cid.c \

        ./src/gzip/ftgzip.c \

        ./src/lzw/ftlzw.c \

        ./src/pcf/pcf.c \

        ./src/pfr/pfr.c \

        ./src/psaux/psaux.c \

        ./src/pshinter/pshinter.c \

        ./src/psnames/psmodule.c \

        ./src/raster/raster.c \

        ./src/sfnt/sfnt.c \

        ./src/smooth/smooth.c \

        ./src/tools/apinames.c \

        ./src/truetype/truetype.c \

        ./src/type1/type1.c \

        ./src/type42/type42.c \

        ./src/winfonts/winfnt.c







LOCAL_C_INCLUDES += $(LOCAL_PATH)/include



LOCAL_CFLAGS += -W -Wall

LOCAL_CFLAGS += -fPIC -DPIC

LOCAL_CFLAGS += "-DDARWIN_NO_CARBON"

LOCAL_CFLAGS += "-DFT2_BUILD_LIBRARY"



LOCAL_CFLAGS += -O2



LOCAL_MODULE:= freetype



include $(BUILD_STATIC_LIBRARY)

#https://android.googlesource.com/platform/external/freetype/+/android-6.0.1_r28/Android.mk

 

APP_OPTIM := release

APP_CPPFLAGS := -std=c++14 -frtti

NDK_TOOLCHAIN_VERSION := clang

APP_PLATFORM := android-28

APP_STL := c++_static

APP_ABI := arm64-v8a,armeabi-v7a



 

https://github.com/githubhaohao/NDK_OpenGLES_3_0

 

#include "ft2build.h"

#include 

 

FT_Library ft;



if (FT_Init_FreeType(&ft))

	LOGCATE("TextRenderSample::LoadFacesByASCII FREETYPE: Could not init FreeType Library");





FT_Face face;

if (FT_New_Face(ft, "/sdcard/fonts/Antonio-Regular.ttf", 0, &face))

	LOGCATE("TextRenderSample::LoadFacesByASCII FREETYPE: Failed to load font");





FT_Set_Pixel_Sizes(face, 0, 96);

 

if (FT_Load_Char(face, 'A', FT_LOAD_RENDER))

    std::cout << "ERROR::FREETYTPE: Failed to load Glyph" << std::endl;