为了自身的健康，为了买了个表，我决定开启这项闪电计划，目标只有一个：通过科学合理的方式，将体重从目前的 78 Kg 减轻到 73 Kg。

措施

措施主要分两个部分：控制饮食和持续运动。

控制饮食

• 早餐以燕麦搭配牛奶为主
• 严格控制晚餐的食物摄入量，一碗饭
• 晚饭后刷牙，之后除了喝水不吃任何东西
• 除少量水果外，不吃任何零食
• 不喝除牛奶、酸奶、咖啡之外的任何饮料

持续运动

• 工间休息
  • 开合跳
  • 蹲下起立
• 晚上的运动
  • 热身：平板支撑
  • 有氧运动：跳绳
  • 无氧运动：俯卧撑

为什么需要异步编程？

在我们的程序中，类似下面这样的代码，是由计算机的处理器一次性执行完毕的。代码的运行速度也很大程度上取决于计算机处理器的速度。

1
2
3
4
5
6
7
8
9
10
11

const sumTo = function(n) {
  let sum = 0

  for (let i = 0; i <= n; i++) {
    sum += i
  }

  return sum
}

sumTo(10000)

但是，还有很多其他程序需要在处理器外面与其他设备交互。比如，有些程序可能需要通过计算机网络进行通信，或者从硬盘读取数据，而这些都比从内存读取代码慢得多了。

当这样的情形发生时，让处理器处于空闲状态是非常浪费资源的，因为可能有不少其他工作需要处理器在这时来处理。某种程度上来说，这取决于你的操作系统，它会切换处理器运行多个不同的程序。但是，当我们在运行单个程序，遇到等待网络请求的情形时，我们没法让处理器去做其他事情。

在同步编程的模型里，事情一件接着一件地执行。当调用一个性能开销很大的函数时，只有当函数内的操作都完成了才会返回。在这个函数运行期间，程序只能原地待命。

异步编程的模型允许多个事情在同一时间发生。当我们开始一项任务（比如从硬盘读取数据），我们的程序可以继续运行。当这个任务完成时，程序会通知我们并返回一个结果。

我们可以用一个小例子来对比同步编程和异步编程：一个程序从网络获取两个资源文件然后组合成需要的结果。

在一个同步的环境里，只有当网络请求全部完成时，请求函数才会返回。执行上面那个例子的最简单方式就是：一个接一个地发出网络请求。这样做的缺点是：第二个网络请求只有在第一个网络请求全部完成时才会开始。那么，完成上述例子的时间将是至少两项网络请求所需时间之和。

1
2
3
4
5

// 先请求第一个资源文件
request(resourceOne)

// 当上面的网络请求完成，才会继续执行第二个网络请求
request(resourceTwo)

通常，对于 JavaScript 脚本而言，如果运行脚本时出现错误会挂掉，即引擎会在错误代码处停下来，不会继续执行后续代码，而是将错误信息打印到控制台。比如：

1
2
3
4

let a = 1;
console.log(b); (*)
console.log(a);
// Uncaught ReferenceError: b is not defined

上面的代码中，执行到 (*) 这一行便会停下来，将错误信息打印到控制台。

try…catch 结构

但是，有一种语法结构 try...catch 允许我们捕获错误并作出相应的处理，这样脚本在出现错误时不会挂掉，而是执行我们设定的错误处理代码。
我们来看两个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

try {
  
  alert('Start of try runs');  // (1) <--

  // ...no errors here

  alert('End of try runs');   // (2) <--

} catch(err) {
  
  alert('Catch is ignored, because there are no errors'); // (3)

}

alert("...Then the execution continues");

上面的代码中，因为 try 语句块没有错误，所以 catch 语句块内的代码会被忽略，不会执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

try {

  alert('Start of try runs');  // (1) <--

  lalala; // error, variable is not defined!

  alert('End of try (never reached)');  // (2)

} catch(err) {
  
  alert(`Error has occured!`); // (3) <--

}

alert("...Then the execution continues");

上面的代码中，由于 try 语句块内存在错误：变量未定义，所以 try 语句块内这一行之后的代码都不会执行，直接跳转到 catch 语句块内执行错误处理代码。

在 JavaScript 中，基于原型的继承是不支持多继承的。但是，在有些时候我们希望有类似的机制。一个非常的典型的例子是事件。有很多的对象，都应该含有对事件处理的方法。而这些针对事件处理的方法不适合被放在原型链中。在 JavaScript 中，实现混入mixin的方式非常简单：将这些方法放在一个对象中，然后通过 Object.assign 将该对象内的方法添加到类中。

在前面一篇原型与继承的学习笔记中，最后使用基于原型的范式实现了继承。而 ES6 引入的 class 关键字则提供了更加漂亮的语法，与 Java 等语言有点类似。还是以 Rabbit 继承 Animal 为例，使用 class 关键字的写法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

class Animal {
  constructor(name, speed) {
    this.name = name;
    this.speed = speed;
  }

  // 静态方法是从属于 class 本身的，而非其原型。静态属性同理。
  // 等同于：
  // Animal.compare = function(animalA, animalB) { ... }
  static compare(animalA, animalB) {
    return animalA.speed - animalB.speed;
  }

  // 成员方法是从属于 class 的原型的
  // 等同于：
  // Animal.prototype.run = function(speed) { ... }
  run(speed) {
    this.speed += speed;
    console.log(`${this.name} run with speed ${this.speed}`);
  }

  stop() {
    this.speed = 0;
    console.log(`${this.name} stopped`);
  }
}

class Rabbit extends Animal {
  constructor(name, speed, earLength) {
    super(name, speed); // 必须使用 super 调用父级构造器，然后才能访问 this
    this.earLength = earLength;
  }

  hide() {
    console.log(`${this.name} hide`);
  }

  stop() {
    // 通过 super.method() 可以调用父类的方法
    super.stop();
    this.hide();
  }
}

console.log(typeof Animal); // function
console.log(typeof Rabbit); // function

初识木材

树木是地球上既宝贵又神奇的资源。通过一系列精心设计，去繁就简的工序，重获新生的木材成为了我们家中的家具。他们陪伴我们和家人一起生活，一同成长，随着时间推移，记录着生活留下的痕迹，成为世上专属你的家具。

钟情实木家具的人，多是喜欢实木的原始素材质感，浑然天成的纹理，温润窝心的感觉，或是欣赏榫卯结构的精湛工艺，在选购前，对木材的特性先有个基本认知，可以帮助我们买到心头好。

同时也要了解，木材是多孔性的有机体，特别是只用木蜡油作表面处理的，存在一定的呼吸性，会随环境的湿度和温度而变化，冷缩热胀以及实木家具不同部位的收缩及膨胀程度不同，会令家具产生开裂及变形。只要是天然的木材均是如此，但请放心，轻微的裂纹及局部变形不会影响家具整体的强度和结构。

另外，天然原木有一些不可避免的的天然瑕疵，包括独特的木纹，木色的变化，树眼，结疤，深色矿物线，斑纹，细小洞孔等等。由多块实木板组成的家具，木板与木板之间必然存在颜色及木纹的差异。