Promise.prototype.catch

catch的参数是onRejected，即拒绝事件的回调，它返回一个新的 Promise。如果当前 Promise 是决议状态的话，则决议值会透传给新的 Promise 上注册的决议事件回调。

class MyPromise {
  // ...
  catch(onRejected) {
    return this.then(null, onRejected);
  }
}

它的实现利用了.then只能接收函数类型参数的特性，显式将onFulfilled设置为null。

Promise.prototype.finally

这是一个 ES2018 的新特性。finally方法返回一个 Promise，它接收的参数称为onFinally，其特点是，无论当前 Promise 被决议或者是被拒绝，onFinally都会执行。这为在 Promise 是否成功完成后都需要执行的代码提供了一种方式。需要注意的是，只有在onFinally中 throw 或返回被拒绝的 Promise 时，onFinally才会返回被相应原因拒绝的 Promise，否则返回的 Promise 状态与上一个 Promise 保持一致。

class MyPromise {
  // ...
  finally(cb) {
    return this.then(
      value => MyPromise.resolve(cb()).then(() => value),
      reason =>
        MyPromise.resolve(cb()).then(() => {
          throw reason;
        })
    );
  }
}

Promise.reject

实例上的方法实现完之后，我们来实现 Promise 上的静态方法。Promise.reject返回一个拒绝状态的 Promise

class MyPromise {
  // ...
  static reject(value) {
    return new MyPromise((resolve, reject) => reject(value));
  }
}

Promise.resolve

与Promise.reject类似，Promise.resolve返回一个被决议的 Promise。但是后者多了一些细节，即如果传参是 Promise 实例的话，则直接返回这个实例。因此Promise.resolve常被用来保障某个值是 Promise。

class MyPromise {
  // ...
  static resolve(value) {
    if (value instanceof MyPromise) return value;
    return new MyPromise(resolve => resolve(value));
  }
}

Promise.all

Promise.all接收一个数组作为参数，参数数组中的成员可以是 Promise，也可以是普通值。它的返回值是一个 Promise，该返回值 Promise 被决议时表示参数数组中所有成员均被决议，此时返回值 Promise 决议值为一个数组，与参数数组的决议值一一对应；该返回值 Promise 被拒绝时，说明参数数组中有成员被拒绝，此时返回值 Promise 的拒绝原因即为那个被拒绝的成员的拒绝原因。

Promise.all有一个特殊情况，当传递空数组时，返回决议值为空数组的 Promise。

class MyPromise {
  // ...
  static all(promises) {
    if (promises.length === 0) return MyPromise.resolve([]);
    return new MyPromise((resolve, reject) => {
      let resolvedValues = [];
      let resolvedCount = 0;
      for (let i = 0; i < promises.length; i++) {
        MyPromise.resolve(promises[i]).then(
          value => {
            resolvedValues[i] = value;
            if (++resolvedCount === promises.length) {
              resolve(resolvedValues);
            }
          },
          reason => reject(reason)
        );
      }
    });
  }
}

Promise.reject

传参形式与Promise.all相同，该函数的返回值是一个 Promise，当返回值 Promise 被决议时，说明参数数组中有成员被决议了，返回值的决议值即为该成员的决议值；当返回值 Promise 被拒绝时，说明参数数组中有成员被拒绝了，返回值的拒绝原因即为该成员的拒绝原因。

向Promise.race传递空数组时，返回值 Promise 会一直处于 Pending 状态，永远不会被决议或者拒绝，我们要避免这种情况。

class MyPromise {
  // ...
  static race(promises) {
    return new MyPromise((resolve, reject) => {
      for (let i = 0; i < promises.length; i++) {
        MyPromise.resolve(promises[i]).then(
          value => resolve(value),
          reason => reject(reason)
        );
      }
    });
  }
}

Promise.allSettled

这同样是一个 ES2018 新增的 API。它的传参与Promise.all一致，但返回值 Promise 一定会被决议，且决议值同样是数组，数组成员的形式要么是{status: 'fulfilled', value: FulfilledValue}，要么是{status: 'rejected', reason: RejectedReason}，具体是哪一种，取决于对应位置上的参数数组成员被决议还是拒绝。

static allSettled(promises) {
    return Promise.all(
      Array.from(promises, p => {
        return Promise.resolve(p).then(
          value => ({ status: "fulfilled", value }),
          reason => ({ status: "rejected", reason })
        );
      })
    );
  }
}

本篇文章将从头实现一个MyPromise，它和 ES6 Promise 具有一样的 API。同时，为了书写方便，我们将借助 ES6 Class 来完成编码。

构造函数

首先我们知道 Promise 有三种状态，分别是pending、fulfilled和rejected，并且状态改变只能由pending向其他两种状态单向转移。同时，我们需要维护一个值用来存储 Promise 的决议值或者拒绝原因。Promise 的构造函数接收一个参数，名为executor，它是一个函数，接收 Promise 传给它的resolve和reject两个函数作为参数。Promise 构造出来之后，我们可以调用 Promise 实例的.then方法来注册决议或拒绝的事件监听函数，并且是可以注册多个的。结合上面这些信息，我们可以先搭一个框架出来。

// Promise的三种状态
const PENDING = "PENDING";
const FULFILLED = "FULFILLED";
const REJECTED = "REJECTED";

// 工具函数，判断参数是否为函数
function isFunc(v) {
  return typeof v === "function";
}

class MyPromise {
  constructor(executor) {
    // 所处状态
    this._status = PENDING;
    // 决议值，可能是完成值，也可能是拒绝原因
    this._value = undefined;
    // onFulfilled事件回调队列
    this._fulfilledQueue = [];
    // onRejected事件回调队列
    this._rejectedQueue = [];
    // 执行executor，如果发生错误
    // 则将当前Promise设置为拒绝状态
    try {
      executor(this._resolve.bind(this), this._reject.bind(this));
    } catch (err) {
      this._reject(err);
    }
  }
  this._resolve() {}
  this._reject() {}
}

首先把三种状态抽象成变量方便以后使用，然后我们声明了一个工具函数isFunc，用来判断参数是否是函数。在构造函数内，除了存储状态的变量和存储决议值或拒绝原因的变量外，还需要声明两个队列，用来存储 Promise 决议或拒绝前，被注册的事件回调。目前this._reject和this._resolve还没有被实现，不要急，接着往下看。

_reject

_reject执行时，Promise 应处于pending状态，否则说明 Promise 已经决议或拒绝。如果状态没问题的话，则设置当前 Promise 的状态为rejected，同时把拒绝原因存储起来，然后从拒绝事件回调队列中取出所有回调一一执行。我们来按照这个思路实现一下。

class MyPromise {
  // ...
  _reject(reason) {
    // 保证Promise的状态转换只能发生一次
    if (this._status !== PENDING) return;
    const run = () => {
      this._value = reason;
      this._status = REJECTED;
      // 从相应队列里取出所有回调函数并执行
      let cb;
      while ((cb = this._rejectedQueue.shift())) {
        cb(reason);
      }
    };
    // 为了支持"同步"的Promise
    // 这里使用setTimeout来异步执行run
    setTimeout(run, 0);
  }
}

注意到我们把执行回调函数的过程封装在了setTimeout中，这是为什么呢？直接同步执行这个逻辑可不可以呢？考虑下面的代码

var p = new Promise((resolve, reject) => {
  reject();
});
p.then(null, () => {
  console.log("p is rejected");
});

Promise 并不止被用于异步过程，它的构造函数完全可以不包含任何异步过程。在上面的代码中，我们构造 Promise 的同时直接将其同步拒绝了，而且此时还没有执行到p.then这里，也就是说还没有注册上拒绝事件回调。因此从事件回调队列中取回调函数并一一执行的过程需要是异步的，这样才能保证像上面这段代码一样的“同步”Promise 能够正常执行。

_resolve

与_reject类似，_reject首先要保证状态转义符合要求，同时取出回调事件执行。但比_reject更强大的是，如果传参(也就是决议值)是 Promise 实例的话，_resolve则会跟踪自己的传参，因此决议值会变成传参的决议值而不是传参本身。举个例子

var p = new Promise((resolve, reject) => {
  resolve(Promise.resolve(42));
});
p.then(value => {
  console.log("p is resolved with", value);
});
// -> p is resolved with 42

接下来我们来看一下如何实现这个神奇的特性

class MyPromise {
  // ...
  _resolve(value) {
    if (this._status !== PENDING) return;
    const run = () => {
      const runFulfilled = value => {
        let cb;
        while ((cb = this._fulfilledQueue.shift())) {
          cb(value);
        }
      };
      const runRejected = reason => {
        let cb;
        while ((cb = this._rejectedQueue.shift())) {
          cb(reason);
        }
      };
      if (value instanceof MyPromise) {
        value.then(
          v => {
            this._value = v;
            this._status = FULFILLED;
            runFulfilled(v);
          },
          r => {
            this._value = r;
            this._status = REJECTED;
            runRejected(r);
          }
        );
      } else {
        this._value = value;
        this._status = FULFILLED;
        runFulfilled(value);
      }
    };
    setTimeout(run, 0);
  }
}

整体结构上和_reject类似，但是_resolve中多了一个用来判断传参类型的逻辑，即传参如果是 Promise 实例，则在传参上注册.then事件，然后根据传参最终被决议还是拒绝来决定当前 Promise 应该被决议还是拒绝。最后，依然是由于“同步”Promise 的问题，需要把整个过程用setTimeout包裹起来，确保逻辑执行时已经被注册了事件回调。

then

根据规范，then位于 Promise 的实例上，每次调用都会返回一个新的 Promise 实例。它的作用是注册事件回调，决议事件回调一般被称为onFulfilled，拒绝事件回调一般被称为onRejected。then也有一个神奇的特性，如果onFulfilled或者onRejected返回了 Promise 实例，则then返回的新 Promise 实例会跟踪这些返回值 Promise。如下面的例子所示。

var p = new Promise((resolve, reject) => {
  resolve(Promise.resolve());
});
var p1 = p.then(() => {
  return Promise.resolve(42);
});
p1.then(value => {
  console.log("p1 is resolved with", value);
});
// -> p1 is resolved with 42

具体实现如下

class MyPromise {
  // ...
  then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) => {
      function fulfilled(value) {
        try {
          if (!isFunc(onFulfilled)) {
            resolve(value);
          } else {
            let ret = onFulfilled(value);
            if (ret instanceof MyPromise) {
              ret.then(resolve, reject);
            } else {
              resolve(ret);
            }
          }
        } catch (err) {
          reject(err);
        }
      }
      function rejected(reason) {
        try {
          if (!isFunc(onRejected)) {
            reject(reason);
          } else {
            let ret = onRejected(reason);
            if (ret instanceof MyPromise) {
              ret.then(resolve, reject);
            } else {
              reject(ret);
            }
          }
        } catch (err) {
          reject(err);
        }
      }
      switch (this._status) {
        case PENDING:
          this._fulfilledQueue.push(onFulfilled);
          this._rejectedQueue.push(onRejected);
          break;
        case FULFILLED:
          fulfilled(this._value);
          break;
        case REJECTED:
          rejected(this._value);
          break;
      }
    });
  }
}

可以看到总体结构是这样的，首先无脑构造一个 Promise 实例并返回，在该 Promise 实例的构造函数中，首先判断一下当前 Promise 的状态，如果还没被决议或拒绝，则先将事件回调存储在队列中。否则的话，直接调用相应的事件回调函数，判断返回值是否是 Promise 实例，如果是的话则追踪，不是的话新 Promise 将用该返回值决议或拒绝。

其中用到了我们之前声明的isFunc工具函数，因为在 MDN 中有这样一段描述

注意：如果忽略针对某个状态的回调函数参数，或者提供非函数 (nonfunction) 参数，那么 then 方法将会丢失关于该状态的回调函数信息，但是并不会产生错误。如果调用 then 的 Promise 的状态（fulfillment 或 rejection）发生改变，但是 then 中并没有关于这种状态的回调函数，那么 then 将创建一个没有经过回调函数处理的新 Promise 对象，这个新 Promise 只是简单地接受调用这个 then 的原 Promise 的终态作为它的终态。

什么意思呢，我们还是举个例子来说明吧

var p = new Promise(resolve => {
  resolve(42);
});
p.then(null, () => {
  console.log("I will never run");
}).then(value => {
  console.log("p.then() is resolved with", value);
});
// -> p.then() is resolved with 42

相应回调函数缺失或者不是函数时，效果就像决议值或拒绝原因被“透传”给.then返回的 Promise 的相应回调函数了。

总结

至此，我们就算模拟实现了一个比较完善的基础 Promise。实现过程中，我们可以发现看似神奇的 Promise 背后其实并没有魔法，它本质上还是基于回调实现的。目前我们实现的这个 Promise 只具有一些基本功能，而剩下的一些 API，如Promise.prototype.catch、Promise.prototype.finally、Promise.all等，留到下一篇再详细介绍吧~

1. 加载资源时，首先根据上次资源响应 Header 中的Expires和Cache-Control判断是否命中强缓存，如果命中则直接从缓存中取，不会发送资源请求到服务器
2. 如果没有命中强缓存，则服务端根据Last-Modified/If-Modified-Since和ETag/If-None-Match验证是否命中协商缓存，如果命中则返回 304 响应，不会返回资源数据
3. 如果没有命中协商缓存，则服务端返回资源数据

比较

相同点：不论是哪种缓存，都是从本地加载资源，服务端不会返回资源数据不同点：强缓存不会产生请求，协商缓存会产生请求

强缓存

Expires表示缓存到期时间，是一个绝对时间，形如Thu, 10 Oct 2017 01:47:03 GMT，它存在于资源的响应头中。该字段出现于 HTTP/1.0 规范中。Cache-Control表示缓存到期的相对时间，以下是一些常用字段值

1. max-age=86400，表示 24 小时后失效
2. must-revalidate，如果超过了 max-age 设置的时间，必须发送请求验证资源是否还有效
3. no-cache，依然缓存资源，但是否使用该资源，由后续的对比决定
4. no-store，真正意义上的“不要缓存”
5. public，内容可以被客户端和代理缓存（如 CDN）
6. private，内容只能被客户端缓存，代理不能缓存，默认值。

这些字段可以被混合使用，字段间关系如下Cache-Control 的优先级高于 Expires，出于兼容性考虑，两个字段常常会被同时设置

协商缓存

如果没有强缓存相关字段，或者强缓存判定资源失效时，进入协商缓存阶段机制(也就是说，强缓存优先级高于协商缓存)。

Last-Modified & If-Modified-Since

第一次请求资源时，资源响应头通过Last-Modified字段告知客户端资源的修改时间，客户端会记录下该时间，在下次请求时，会将该时间写入资源请求头的If-Modified-Since字段。服务端收到该请求后，将If-Modified-Since中的时间与资源的上次修改时间进行对比，两个值一致时，返回 304 响应，否则正常返回新的资源。

ETag & If-None-Match

该机制的运行流程和Last-Modified & If-Modified-Since类似，只不过将资源修改时间改成了资源内容的 hash，该 hash 在资源响应头的 ETag 中体现，在之后的资源请求头的 If-None-Match 中传回，服务器进行对比，如果一致则返回 304，否则正常返回资源。ETag 的优先级要高于 Last-Modified

Memory Cache vs Disk Cache

Chrome DevTools 有时会观察到(from memory cache)，有时则是(from disk cache)，可以通过以下操作复现

1. 资源设置为Cache-Control: max-age=86400，首次打开页面时，响应 200，返回资源
2. 刷新页面，显示 from memory cache
3. 关闭页面，重新打开，显示 from disk cache

此外，还可以观察到一个现象，from memory cache 时，耗时很短，往往是 0ms；而 from disk cache 时，往往需要消耗几毫秒的时间。说明确实是前者从内存里读，后者从硬盘里读。

no-cache vs no-store

用下面的场景进行说明。假设在 HTML 中，同步地请求同一个资源两次（按顺序写两遍），之后异步地再请求一次。

1. 当资源被设置为 no-cache 时，该资源只被请求了一次，说明 no-cache 的语义实际上是下次打开页面时，要重新请求资源，但在当前页面上的请求，有缓存的时候还是可以放心用的
2. 资源被设置为 no-store 时，该资源被请求三次，说明 no-store 无论无何都会发送请求（猜测，和名字体现出来的一样，no-store 根本就没把资源存储下来）

"" == 0;
"0" == false;
"" == [];
0 == [];
![] == [];

上面的所有表达式结果都为 true，怎么样，你答对了吗？

如果你能准确又自信的说出所有结果的话，说明你已经对 JS 中的宽松相等和类型转换相当了解啦，这篇文章对你可能帮助不大。如果你对结果有一点含糊的话，不妨跟着我一起探索下其中的知识点吧！

抽象操作

如果读过 ES 规范文档的话，你会发现文档里充斥着各种复杂的运算，为了方便描述这些复杂运算，文档作者往往会给这些运算起个名字，方便在其他地方引用，这些复杂运算就是抽象操作。在真正开始介绍宽松相等的规则之前，让我们先来了解一下 ES 规范中几种和类型转换相关的抽象操作吧。

ToString

ToString 操作会将其他类型的值转换成字符串类型，该操作具有以下规则

1. null -> “null”
2. undefined -> “undefined”
3. true -> “true”
4. false -> “false”
5. 数字的转换遵循通用规则，但极大或极小的值会采用指数形式
6. 对于其他对象，若没有定义toString方法，则输出内部属性[[Class]]

其他几条规则都比较明确，让我们来重点关注下第 6 条。JS 中除了普通对象之外，大多数都定义了自己的toString方法，比如Function.prototype.toString会输出函数源码，Array.prototype.toString会把值转换成字符串后在每个值中间插入逗号输出。这时候要获取[[Class]]属性的操作就要借助Object.prototype.toString来实现了，也就是我们非常熟悉的Object.prototype.toString.call(obj)操作了。

ToNumber

ToNumber 操作会将其他类型的值转换成数字类型，该操作具有以下规则

1. true -> 1
2. false -> 0
3. undefined -> NaN
4. null -> 0
5. 字符串的转换遵循通用规则，但以 0 开头的八进制数无法正确识别。注意，空字符串转换后为 0
6. 对于其他对象，会对其进行 ToPrimitive 抽象操作，期待得到基本类型的值，然后对该基本类型的值进行 ToNumber 操作

这里有一个特殊的地方要注意，undefined会被转换成NaN，而null则会被转换成0。另外ToPrimitive具体对应什么样的操作呢？

ToPrimitive

ToPrimitive 操作会将其他类型的值转换成基础类型的值，该操作具有以下规则

1. 调用对象的 valueOf()方法，如果返回基本类型值，则返回该值，否则继续
2. 调用对象的 toString()方法，如果返回基本类型值，则返回该值，否则抛出 TypeError 异常

除非特意实现过，否则大部分对象的 valueOf 方法会返回自身，所以实际环境中，ToPrimitive 操作大部分时候是依赖 toString 方法完成的。注意，刚刚说的只是实践经验，具体操作时必须严格按照规范来。

ToBoolean

ToBoolean 操作会将其他类型的值转换成布尔类型值。首先 ES 规范中先规定了一个假值列表

1. undefined
2. null
3. false
4. ±0/NaN
5. ""

于是 ToBoolean 操作的规则是这样的

1. 假值列表中的值 -> false
2. 其他值 -> true

很简单对吧，不在假值列表中的值就是 true。

宽松相等

说起宽松相等，大部分开发者对它深恶痛绝，因为有太多反直觉的结果，所以大部分代码规范都要求开发者只使用严格相等，不要使用宽松相等。甚至有开发者整理了 JS 中各种典型值的相等关系表，可谓非常壮观。

但我觉得逃避解决不了问题，知其所以然才能有效避坑，所以让我们来探究一下宽松相等的原理。

首先，宽松相等和严格相等的区别是，宽松相等允许对操作符两侧的值按照“一定规则”进行类型转换。注意这里的“类型转换”，看起来它就是“万恶之源”了。让我们一起看看刚刚提到的“一定规则”具体是什么样的

1. 运算符两侧分别是字符串和数字时，对字符串进行 ToNumber 操作
2. 运算符两侧分别是布尔值和其他类型值时，对布尔值进行 ToNumber 操作
3. 运算符两侧分别是 null 和 undefined 时，返回 true
4. 运算符两侧分别是对象和数字/字符串时，对对象进行 ToPrimitive 操作

了解完规则之后，我们来拿文章最开始的例子检验一下。就拿![] == []来说吧，它的结果为 true，很反直觉对吧，空数组居然和它的取反相等，让我们来看一下 true 是被怎么推导出来的。

1. 对符号左侧表达式![]求值，由于[]不在假值列表里，所以![]的结果为 false
2. false == []按照规则，需要对 false 进行 ToNumber 操作，结果为 0
3. 0 == []一侧是对象，一侧是数字，所以对对象进行 ToPrimitive 操作
4. [].valueOf()返回结果是[]，不符合要求
5. [].toString()返回结果是""，符合要求
6. 0 == ""按照规则，对""进行 ToNumber 操作，结果是 0
7. 0 == 0结果为 true

怎么样，对照规则一步步走下来，逻辑是不是清晰多了？

逻辑比较

所谓逻辑比较就是大于小于这些，逻辑比较中也是存在类型转换的。其转换规则如下

1. 如果双方不都是字符串
   1. 对双方进行 ToPrimitive 操作
   2. 如果结果依然存在非字符串， 则对结果再次进行 ToNumber 操作，比较数字大小
   3. 如果结果均为字符串，则按字符串情况比较
2. 双方都是字符串，则按字母顺序比较

值得注意的一点是，大于等于和小于等于是通过逻辑取反得到结果的，也就说(a >= b) === true成立的条件是，(a < b) === false成立。这可能会造成一些反直觉的结果。

var a = { n: 42 };
var b = { n: 43 };
a < b; // -> false
a == b; // -> false
a > b; // -> false
a <= b; // -> true
a >= b; // -> true

结果乍一看非常反直觉，前三个表达式说明 a 既不大于 b，也不小于 b，也不等于 b，但是后面的大于等于和小于等于却是 true。其实结合上面说的很容易理解，比如a <= b的结果是由a > b的结果推导出来的，因此才是 true。

总结一下，虽然 JS 中的宽松相等和逻辑比较有很多反直觉的结果，但其背后都有规则可循，掌握了这些规则之后，我们发现宽松相等也不是那么坑，比如obj == null就能一下子判断出 obj 是不是 null 或者 undefined 这两种情况，很实用，也很安全。希望大家看了这篇文章之后能摘掉有色眼镜来看待==运算符，并对它加以合理利用。

字符组

字符组包含了要匹配字符的所有可能情况，使用[]表示，具体有如下三种描述方法

1. 列举。即列举所有可能字符，如[abc]
2. 范围。即使用范围表示所有可能字符，如 [a-z]
3. 取反。在上面两种写法的基础上，在前面加上^表示取反逻辑，如[^abc]

对于常见的字符组，正则引擎内置了一些简写

1. \d表示[0-9]
2. \D表示[^0-9]
3. \w表示[0-9a-zA-Z_]
4. \W表示[^0-9a-zA-Z_]
5. \s表示[ \t\v\n\r\f]，\v 是垂直制表符，\f 是换页符
6. \S表示[^ \t\v\n\r\f]
7. .表示[^\n\r\u2028\u2029]表示几乎所有字符，除了换行符、回车符、行分隔符、段分隔符

量词

量词用来描述某个模式出现的次数，有两种描述方法

1. {m,}表示至少出现 m 次
2. {m}表示恰好出现 m 次

同样，对于常用的量词，引擎内置了一些简写

1. ?表示{0, 1}
2. +表示{1,}
3. *表示{0,}

贪婪与非贪婪

先看一个例子

var regex = /\d{1,3}/g;
var string = "1 12 123 1234";
console.log(string.match(regex));
// -> ["1", "12", "123", "123", "4"]

\d{1,3}的意思是数字出现 1 到 3 次，但从结果可以观察到，这个模式会尽量多的匹配数字，即能匹配 3 个就不匹配两个，能匹配两个就不匹配一个。这种行为就是贪婪匹配。那么什么是非贪婪匹配的，在原来的例子上简单修改一下。

var regex = /\d{1,3}?/g;
var string = "1 12 123 1234";
console.log(string.match(regex));
// -> ["1", "1", "2", "1", "2", "3", "1", "2", "3", "4"]

匹配出来的结果都是一个数字，即能匹配一个就不匹配两个。通过上面的例子可以得到两个结论

1. 量词默认是贪婪的
2. 在模式后面加?可以将贪婪匹配变成非贪婪匹配

选择分支

语法是(p1|p2)，表示模式 p1 或模式 p2。看个例子

var regex = /\d{3}|\d{5}/g;
var string = "12345";
console.log(string.match(regex));
// -> ["123"]

从这个例子也可以看出来，选择分支是非贪婪的，即 p1 满足了，就不再去尝试匹配 p2 了。

匹配位置

除了匹配字符，正则表达式的一个重磅功能就是匹配位置，即开头、结尾和字符之间的位置。一些常用的表示方法如下

1. ^ 匹配开头，多行模式下匹配行开头
2. $ 匹配结尾，多行模式下匹配行结尾
3. \b 匹配\w 和\W 的位置，自然就有包括\w 和^以及\w 和$之间的位置
4. \B 是\b取反
5. (?=p) 模式 p 前面的位置 positive lookahead
6. (?!p) 上面的逻辑取反 negative lookahead

2019-5-30 更新，ES6 中新增了两个位置

1. (?<=p) 模式 p 后面的位置 positive lookbehind
2. (?<!p) 上面的逻辑取反 negative lookbehind

引用分组

被()包裹起来的模式可以在正则表达式中和 JS 相关 API 中被引用，当被正则表达式引用时，使用\数字表示，在被 JS 相关 API 引用时，使用$数字表示，其中的数字范围从 1 到 99。

下面通过几个例子展示一下具体的用法

var regex = /\d{4}(-|\/)\d{2}\1\d{2}/;
var string1 = "2016-07-18";
var string2 = "2016/07/18";
var string3 = "2016-07/18";
regex.test(string1); // -> true
regex.test(string2); // -> true
regex.test(string3); // -> false

var regex = /(\d{4})-(\d{2})-(\d{2})/;
var string = "2016-07-18";
var result = string.replace(regex, "$2/$3/$1");
console.log(result); // -> 07/18/2016

元字符

在编写正则表达式时，遇到下面这 20 个字符，要记得转义

1. \ | /
2. () [] {}
3. + - * =
4. . , : ! ?
5. ^ $

JS API

在 JS 中可以通过如下 API 使用正则表达式完成查找、替换、验证等操作

1. regex.test(string)
2. regex.exec(string)
3. string.search(regex)
4. string.match(regex)
5. string.split(regex)
6. string.replace(regex, string/function)

其他有趣的点

如果要匹配任意字符，可以使用逻辑取反操作来完成，比如[\d\D] / [\s\S] / [\w\W] / [^]

如果要写一个什么都匹配不了的模式，可以这样：/.^/即任意字符后面有个开头，这当然是不存在的

朴素的原型链继承

function SuperType() {
  this.name = "Han";
  this.friends = ["A", "B"];
}
SuperType.prototype.getName = function() {
  return this.name;
};
function SubType() {
  this.age = 18;
}
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.getAge = function() {
  return this.age;
};

让我们声明两个SubType的实例试一下

var p1 = new SubType();
var p2 = new SubType();
p1.getName(); // -> 'Han'
p1.getName(); // -> 'Han'
p1.getAge(); // -> 18

p1.name = "Xiaohan";
p1.getName(); // -> 'Xiaohan'
p2.getName(); // -> 'Han'

看起来是符合预期的对吧，子类继承了父类上定义的属性和方法，并且修改子类实例的属性时，不同实例间不会发生干扰。真的是这样吗？

p1.friends.push("C");
p2.friends; // -> ['A', 'B', 'C']

等等，改了p1.friends之后，为什么另一个实例p2也被影响了？刚刚改p1.name的时候明明是正常的！让我们冷静一下，回头看看最开始继承的实现。由于SubType.prototype = new SuperType()，父类的属性实际上是声明在子类的原型(即__proto__，以下统一称为原型)上的，因此p1.name实际上是p1.__proto__.name，所以父类属性实际上被所有子类实例共享。我们知道操作对象属性时，内部操作[[Get]]和[[Set]]的逻辑时不一样的，[[Get]]会沿着原型链向上查找，而[[Set]]则不会，这就会造成属性遮蔽现象。因此当我们执行p1.name = 'Xiaohan'时，触发[[Set]]操作，此时name属性就被定义在p1上了，之后在取该属性的值时，由于p1上已经有该属性了，因此不会继续沿原型链向上查找，所以赋值行为在不同子类实例间看起来是正常的。如果不是赋值操作，那可就要小心了，比如p1.friends.push('C')，这并不是一个赋值操作，而且直接操作了p1.friends属性，按照我们刚刚说的，本质上操作的是p1.__proto__.friends，而这个属性是被所有实例共享的！所以很自然的，p2.friends也被影响了。

所以，总结下原型链继承的问题：

1. 父类属性会被所有子类实例共享，如果操作不慎(比如上面例子中的对数组进行push操作等)，会影响所有实例，造成诡异的问题
2. 父类属性在声明时就被写死了，不能由子类定义，使用上不够灵活

经典继承(借用构造函数)

function SuperType(name) {
  this.name = name;
  this.friends = ["A", "B"];
  this.getName = function() {
    return this.name;
  };
}
function SubType() {
  SuperType.call(this, "Han");
  this.age = 18;
  this.getAge = function() {
    return this.age;
  };
}

在经典继承中，子类借用了父类的构造函数，将父类声明的属性和方法通过“借用”的方式声明在自己身上，从而既达到了继承的目的，又避免了原型链继承带来的子类实例共享父类属性的问题。但通过观察该实现，我们不难发现父类的所属性和方法在每个子类实例上都有一份儿，虽然实例间不会相互影响了，但本该得到复用的父类和子类方法，并没有真正被复用，造成了极大的资源浪费。

组合继承(伪经典继承)

function SuperType(name) {
  this.name = name;
  this.friends = ["A", "B"];
}
SuperType.prototype.getName = function() {
  return this.name;
};
function SubType() {
  SuperType.call(this, "Han");
  this.age = 18;
}
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.getAge = function() {
  return this.age;
};

顾名思义，组合继承结合了原型链继承和经典继承的做法，既能复用父类和子类方法，又能通过借用构造函数的方式，将父类属性定义在每个子类实例上，达到不相互干扰的目的。那么组合继承可以称得上完美的继承实现了吗？

并不是，让我们对照实现代码仔细分析一下。子类内部SuperType.call(this, "Han")和SubType.prototype = new SuperType()造成的结果是父类构造函数被调用了两次，该操作造成的结果是父类属性同时存在于子类实例和子类实例的原型上！因为上面提到的属性遮蔽现象，所以这种冗余对于开发者来说是感知不到的，但冗余毕竟是事实存在的，虽然不影响结果，但依然是一种资源浪费。

原型式继承

var person = {
  name: "Han",
  getName: function() {
    return this.name;
  }
};

var p1 = Object.create(person);
p1.name = "Xiaohan";
p1.getName(); // -> Xiaohan

原型式继承由知名大神Douglas Crockford提出，借助Object.create一脚踢开Function，直接借用原型链实现对象与对象之间的继承关系。这种继承的实现方法，思路简单直接，不会带来new来new去引起的各种“坑”，但由于出现比较晚，所以用的人相对来说也没那么多。YDKJS的作者Kyle Simpson倒是对这种模式赞赏有加，在其书中用了很大篇幅介绍它的优点和灵活性。

寄生式继承

function createAnotherPerson(original) {
  var clone = Object.create(original);
  clone.sayName = function() {
    console.log("name is", this.name);
  };
  return clone;
}

var person = { name: "Han" };
var han = createAnotherPerson(person);
han.name = "xiaohan";
han.sayName();

寄生式继承可以理解为位于原型式继承的扩展，它使用了工厂函数来创建实例，并为每个实例添加方法，增加了方法的可复用性。

组合寄生式继承

function inheritPrototype(subType, superType) {
  subType.prototype = Object.create(superType.prototype);
  subType.prototype.constructor = subType;
}
function SuperType(name) {
  this.name = name;
  this.friends = ["A", "B"];
}
SuperType.prototype.getName = function() {
  return this.name;
};
function SubType() {
  SuperType.call(this, "Han");
  this.age = 18;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.constructor = SubType;
SubType.prototype.getAge = function() {
  return this.age;
};

在初看《红宝书》时，对继承这一块儿的内容安排很困惑，前面都是在用函数实现继承，怎么突然插入了原型式继承和寄生式继承呢？看到组合寄生式继承时，我释然了。在Object.create出现之前，开发者们一直使用new来构建原型链，这多多少少有些晦涩难懂，而Object.create简单直接的逻辑，无疑大大简化了构建原型链的难度，那能不能用Object.create来解决一下上面提到的几种继承实现的问题呢？

答案是肯定的，让我们的目光回到组合继承。我们提到组合继承的缺点是父类构造函数被调用两次，造成了势必被遮蔽的父类属性出现在了子类实例的原型链上，这是一种资源浪费。那有没有办法避免这种资源浪费呢？我们既要构造SubType.prototype和SuperType.prototype的原型链关系，又要避免SuperType的冗余调用，防止资源浪费。显然，这时候该Object.create登场了。观察上面的代码，inheritPrototype就达到了我们的目的：既构造了原型链关系，又避免了这个过程中SuperType的调用。至此，继承的实现算是达到了比较完善的程度。

我们知道，ES6的类只是语法糖，其背后依然是基于原型链实现的，其实现方式和组合寄生式继承大致相同，但又有细微差别，未来有时间会总结下ES6的类是如何实现的。

截图

因为教务系统加了验证码，所以这次使用了 GUI。但是我只会用 Tkinter，所以别期待太好看。大概就长下面这样了。

登录界面：

错误提示：

主界面：

使用说明

源码方式

在使用源码方式运行前，请确保你已经安装了 Python 环境（目前只支持 2.X），并安装了requests、beautifulsoup4、Pillow这三个库（项目源码中附带了requirements.txt文件）

从项目地址克隆源码，然后执行./score.py即可。

可执行文件（未完成）

双击下载下来的 EXE 文件即可。 计划用 cx_Freeze 打包一下，估计明天才有时间弄了。

写在后面

• 强烈推荐使用源码方式运行，程序代码都看得到，如果出了问题自己调试起来也方便
• 非常不愿意打包 EXE，毕竟直接给可执行文件的话总会有人说三道四。如果选择可执行文件方式运行的话请自行承担所有风险
• 草草发布，我只在 Win8 下测试了。肉身不在学校，只能 Mac 开虚拟机开发，超苦逼的。不过我猜其他环境问题应该不大，尤其是*nix 系，最可能出问题的地方应该是字符串编码
• 代码在GitHub上，使用中出现什么问题可以直接在这篇文章下评论或者在去GitHub开 issue
• 祝大家保研/出国/考研成功！

下载

我们需要用到的软件是 shadowsocks，你可以从这里下载

需要说明的一点是：对于Win8 及之后的系统，需要选择Shadowsocks-win-dotnet4.0-x.x.x.zip这种安装包，对于Win7 及之前的系统，需要选择Shadowsocks-win-x.x.x.zip这种安装包。

ps. 因为下载服务器位于 Github，所有有些时候不翻墙是无法下载的，于是这个问题就变成了先有鸡还是先有蛋的问题。对于这种情况，我强烈建议找你男朋友解决。

配置

下载完软件之后，我们得到了一个可爱的压缩包，果断解压。然后我们就得到了一个名为Shadowsocks.exe的文件，找一个你喜欢的地方放置它，比如我们把它放在 D 盘的 Shadowsocks 目录下。

放置好之后，双击打开。跳出了一个配置页面，在这个配置页面中填入我给你的服务器信息（服务器 IP、服务器端口、密码、加密方式），其他选项保持默认就好，填好以后点击确定。

这时候它就非常调皮的跑到右下角的系统托盘里了。

如果你没找到他，那很可能是隐藏在托盘最左侧的小三角里面了。

他老在小三角里躲着也不是个事儿，所以我们来配置一下，让它始终显示在系统托盘里。点击系统托盘最左边的小三角，然后点击自定义，找到 shadowsocks，并将右侧的行为改成“显示图标和通知”，然后就大功告成了。

使用

Easy 模式

在系统托盘的 shadowsocks 图标上右键，勾选“启用系统代理”，在“系统代理模式”中选择“PAC 模式”，勾选“开机启动”。

做完上面这几步之后就可以愉快的上网了，Facebook、Google、Twitter、YouTube 全都无障碍访问。

但是，Easy 模式有一个缺陷：只能绕过一些常见的“被 GFW 认证的网站”，对于一些比较小众，但依然被“GFW 认证”的网站就无能为力了。为了解决这种问题，一个简单粗暴的解决方式是在“系统代理模式”中选择“全局模式”，这时候所有的访问会全部由代理中转，也就解决了那些小众网站不能访问的问题。但是这又带来了一个新的问题，既然是所有流量都会经过中转服务器，那么访问境内网站的时候就会非常慢，于是你又得切回“PAC 模式”，这么切来切去的不是个办法，所以想完美解决这个问题我们就要学习下面的 Hard 模式。

Hard 模式

Hard 模式说起来比较复杂，以后慢慢补充。

孤独的人是可耻的 ——张楚

生病的人是痛苦的 ——我

不知道隔了多久，又得了我最擅长的感冒。这次感冒来势汹汹，让我很快进入了生病状态。当然我也没怂，当天我就从自习室撤出来了，从此一周再也没进去过。

说起我这体弱多病的身体，那真是有年头儿了。记得小时候经常发烧，经常到什么程度呢？家里一直备着输液的所有药品和器具，我妈一旦发现我烧起来了，立马输液伺候。而我经常非常争气地在晚上发烧，所以关于小时候发烧的记忆一直是半夜突然被老妈叫醒，迷迷糊糊的爬起来自己握着手腕（哪儿听说过亲妈给亲儿子输液还用压脉带的？），然后感觉手背上被什么东西咬了一下，管不了那么多了，太困。于是接着睡。就这样，晚上发烧，天亮之前解决，第二天“高高兴兴上学去”，丝毫没耽误学习（摔！）

不过长大之后身体好像好了不少，不再病病殃殃的了。高中倒是老感冒，不过发烧的次数应该一只手能数的过来。记得比较清楚的一次是高一刚开学的时候，那时候正在讲化学里的“物质的量”，当时的我觉得这玩意儿真特么难懂啊，什么玩意儿啊，描述一种物质的多少用质量不就得了，干嘛弄出个“摩尔”出来。刚开始的骂娘，后来越来越看不懂了之后竟然像小小姑娘一样觉得委屈——高中真特么难啊。就在这种委屈中，我被病魔战胜了。在这种情况下谁都没办法继续坚持上课对不对，所以我顺利地拿到年级主任签的假条骑着自行车回家了。重点来了，回家的路上我竟然哭了，卧槽，我特么一个大老爷们儿骑着自行车突然哭了！！！现在想想真丢人啊！回家之后还是老一套，被右手握住手腕的左手又被咬了。不过那次生病之后我仿佛基因突变一般突然理解了“物质的量”的概念，这玩意儿不就是数量么，老子终于明白啦咩哈哈哈！紧接着迎来了高中的第一次期中考试，我意外的超长发挥，成功进步一百多名一下子进入了年纪前 20。

这次生病来的太猛烈，以至于我还没准备好就完全失去战斗力了。生病的过程是痛苦的，每天的生活是无聊的。起床——吃饭——上床玩儿手机——吃饭——睡午觉——发呆——吃饭——晚安。前两天买的小鸡手柄可算是用上了，每天无聊的时候就和怪叔叔玩儿双人的 FC 游戏，不亦乐乎。这几天在网上瞎逛的时候看到了邱神很老的博客、chon 的博客和大鹰的博客，有感于大牛的发迹。考研之后的待办清单上又多了几项：ArchLinux、Ruby、i3 等等等还有好多。

今天是生病的第七天，下午终于强迫自己去了久别的自习室。说实话，在考试周即将到来之际，一个星期不去自习室是需要勇气的；一周没去过自习室之后再想去是同样需要勇气的。下午去之前纠结了好久，抱着手机在寝室做了好久，鞋都换好了，但屁股就是不想挪地方。当时我心里有两个小人儿——一个说：别去了吧，歇会儿吧。另一个说：好啊好啊~不过复习不等人啊，我还是抱着电脑去自习室吹空调了。有了电脑之后坐在自习室里就容易多了，心里也舒服很多：老子都已经坐过来了，你还想怎样啊！

鼻子依旧闻不到味道，我想好了，等我问到味道的第一天，我一定去北门买一份加了肉的肠粉好好尝尝，嗯！

以上。

由于教务系统的地址变更以及验证码的加入，Python 版的评教脚本已经失效，请使用 javascript 版

每个学期末都烦心事儿不断，评教这件小事儿还非得过来掺合掺合。扒着眼睛找那个巨小无比的选择按钮真实让人烦躁啊。作为死工科生，总得做点什么。于是就写了个评教脚本。

总共有两个版本（考虑到坑爹的 windows，实际上是三个）

• JavaScript 版
• Python 版
• Py4win 版（src+exe）

这三个版本有点儿不一样。Javascript 版就是一串 JS 代码，直接在浏览器中运行即可，不需要额外下载安装任何东西，但是缺点是每次只能评一位老师，也就是说你还是得运行十几次代码才能完成教学评估。Python 版是一个.py 文件，在大多数 Linux/OSX 上都能直接运行，而且能一次性完成评教，是真正的“一键评教”。单独把 Windows 割裂出来是因为编码问题，cmd 的默认编码是 gb2312，于是就出现了乱码，于是把 Python 版的代码做一些编码上的处理就变成了 Py4win 版，考虑到大部分 windows 下没安装 Python，于是用 py2exe 打包了一个 exe，算作是 Py4win 版的一部分吧。

下面开始挨个介绍使用方法。

JavaScript 版（一般般推荐）

复制下面这串代码(有结构的未压缩版请看文章最后)

javascript: "URP 综合教务系统 - 教学评估 - 教学评估"==window.document.title?x=window.frames[1].frames[2].document.getElementsByTagName("input"):"问卷评估页面"==window.document.title?x=window.document.getElementsByTagName("input"):alert("请确认一个你现在是不是处于正确的页面上，本程序只能在教学评估页面运行！"),data=new Array;for(var i=0;i<x.length;i++)"hidden"==x[i].type&&data.push(x[i].value);function post(t,e,n){n=n||"post";var a=document.createElement("form");for(var i in a.setAttribute("method",n),a.setAttribute("action",t),e)if(e.hasOwnProperty(i)){var d=document.createElement("input");d.setAttribute("type","hidden"),d.setAttribute("name",i),d.setAttribute("value",e[i]),a.appendChild(d)}document.body.appendChild(a),a.submit()}post("http://jwxt.bupt.edu.cn/jxpgXsAction.do?oper=wjpg",{wjbm:data[0],bpr:data[1],pgnr:data[2],"0000000021":"10_0.95","0000000022":"10_0.95","0000000023":"5_0.95","0000000024":"20_0.95","0000000025":"10_0.95","0000000026":"5_0.95","0000000027":"5_0.95","0000000028":"20_0.95","0000000029":"10_0.95","0000000030":"5_0.95",zgpj:"老师讲课很认真的啦~"},"post");

登录教务系统，打开教学评估页面，选择一门课程进行评估，于是就到了下面这个页面（由于测试的关系我已经评完了）

然后，在浏览器的地址栏中粘贴刚刚复制的代码，注意，一定要带前面的javascript:，有些浏览器由于安全方面的考虑会自动过滤掉这串字符，这时就需要我们手动加上。粘贴好之后按回车，脚本会自动完成选择和提交的动作。默认都选“优”也就是第二档。

还有两种使用方式可以参考：

• 把这段代码加到书签里，到评估页面后直接点书签就行了
• 在浏览器开发者工具的 Console 中执行

Python 版（最推荐）

如果你用的是 Linux/OSX，那么在安装完BeautifulSoup后就可以直接调用了。

BeautifulSoup 安装命令：sudo pip install beautifulsoup4或sudo easy_install beautifulsoup4

运行脚本：python pingjiao.py

运行效果大概就是下面这样

Py4win 版（src 推荐，exe 非常不推荐）

如果你在 windows 上装了 python，那么使用方法和 Python 版完全相同，装好 BeautifulSoup 就能用了。

如果没装，但是你还非常想用的话，那只能用 exe 版本了。exe 版本使用非常简单，双击“评教.exe”运行就行了。

exe 版本使用 Py4win 版的 src+py2exe 打包，使用上没有任何问题，但是我不推荐用。直接给可执行文件是个很敏感的事儿，你完全可以说我植入了什么奇怪的东西，虽然我什么都没干。所以如果你使用 exe 版的话，你必须自己承担这带来的一切后果。有点危言耸听了，但是永远要相信「6L+Z5Liq5LiW55WM5LiK5bCP5Lq66L+Y5piv5oy65aSa55qE」。

所有的文件来这儿下载

1. 源码在 GitHub
2. Py4win 版的 exe 文件在 百度云

Special Thanks

感谢 @qiukun 大神的指导。良师益友没得说~

既然决定了要住院，我就回学校办手续了，回来那天是 12 月 31 号，我还记得当时走出医院的时候我还琢磨着，老天还是挺够意思的，至少没让我在医院跨年。31 号那天晚上我请我们宿舍的吃饭，花的不多，还不到 300 块钱，特别逗的是隔壁的一个菜上到我们的桌子上了，我们义无反顾的就给吃了。虽然吃的不丰盛，但是大家还算高兴。那天晚上，大家似乎也没有太激动，0 点，我站在阳台上带头喊了一句：新年快乐。当时百感交集，新年了，这一年的开头就这么累。免不了有点哀伤。

但是住院的那段日子，我真的很快乐。

不得不承认，住院的这二十天是我今年最爽的日子了。无忧无虑，我从没有像现在这么友善过，也从没有像现在这么正能量过，我见每个人的时候都微笑，见每个稍微认识点的人都热情的打招呼，关键是，我是发自内心的，我发自内心的和订饭的阿姨开玩笑，发自内心的觉得应该送何叔叔点礼物，发自内心的对对面屋的姑娘说声：“就不！”。

这就是 14 年的开头，在这段开头的时间，我写了 20 年来几乎最励志的日记。

当然，整个 2014 年还发生了很多有意思的故事，最大的一件事儿就是实习了。今天就不说了吧，该期末复习了。

接下来这一年肯定还会发生好多故事，不求别的，只求能离自己的心近一点。

今年刚刚开始，我去车道沟“旅行”，当时心情压抑的不行，同时还有点庆幸，让我在宿舍跨了年。“旅行”期间想了好多事儿啊，当时一点一点地写在了为知笔记里面，而且当时还立志今年一定要好好练练文笔。一整年就快过去了，文笔依然差，写东西依然不勤快。

人一到某个阶段的末尾就禁不住回忆，今年经历了好多事儿啊。尤其是年中开始去某小公司实习的经历，让我成长了很多。见识了甲方乙方勾心斗角争夺利益，见识了公司里让人恶心的不行的踢皮球现象。网站的项目磨磨唧唧弄到现在，还好有光光，足够强势，一直以来让我们保持主动权，不至于被公司欺负得太厉害。还有就是感恩，感恩这个公司让我认识了这么多好玩儿的同事，大家每天在办公室里逗比的不行，真是开心。

因为做这个项目，迫使自己学了很多新的技术，这种感觉真的是好久都没有过了。想起初中的那段时间，刚刚接触互联网，看什么东西都觉得新鲜，什么都想玩儿。那是个时候非常痴迷“偏门技术”，比如 Windows 下的破解、外挂和黑客技术。现在想想那时候看的东西确实是挺入门的，但那时候学习的热情实在是高的不能再高了，每天脑子里想得都是这些东西。那时候老妈一直不理解，觉得我就是纯粹地在玩儿电脑（这么想也没啥不对，我确实就是在玩儿啊），三番五次地阻止我用电脑，还把电脑设了密码。也就是那时候起，我熟练地掌握了 Ghost 装系统的技术。把原来带密码的系统备份一下，换成自己的没密码系统，等老妈快下班的时候再赶紧换回来。现在想想还挺怀念的。对于那段时间的瞎折腾几乎没有后悔，除了一点，那时候因为要学破解和外挂，稍微学了点汇编的皮毛，没有深入学习。如果那时候的我知道大学还要学一门叫做“微机原理”的课的话，估计汇编早就学成了。

V2EX 是个好社区，和 HiPDA 一样是个人站点。在 ifanr 看了一篇 Livid 的专访，感觉是个十分有意思的人。很多时候，读一些人的访谈或者事迹的时候不禁感慨，真牛逼。回头单独写写吧。zhuyi 成了专业吃货，没事儿的时候敲敲鼓。Livid 不知道在干啥，偶尔会看见他和 Oliva 在社区里互动一下。阮一峰入职阿里了，不过他的博客看得确实不多。伞哥前段时间在微博上和老婆撕逼，嚷嚷着要离婚，哎，过日子真不容易。各位大佬活得有声有色，看他们的故事比看电视剧有意思得多。

晚上很没骨气地去吃了烤肉大哥，之所以说自己没骨气是因为他家现在有外卖了，而店里还是那几个人，还是那么大地方。很明显的，大哥已经有点顾不上店里的顾客了，肉的味道也不怎么好了。之前因为这个已经把他家加入黑名单了，但是今天实在是有点想吃，所以还是很没骨气的去了，果然还是黑名单的命，彻底再见了。今天听大哥说，他这个店已经开了 11 年，真的，因为外卖毁了真的不太好。想起前些日子去南门最里面的那家北邮学长开的黄焖鸡，像叔叔熊一样，被悄无声息的收购掉了。有些嘴比较叼的顾客从味道上就能尝出来，还有些顾客从店员的变化里看出来了。总之以后是不会去了。想到这里心里还有点不是滋味，南门能吃的店越来越少了，以后去哪儿吃饭啊，发愁……

踏踏实实活着，老老实实攒钱，还信用卡，等待圣诞节割肉。还有，我啥时候能捡个女朋友啊，愁……

哦，晚上光光告诉我爱知乎关了。挺好的站点，因为版权问题不得已关掉了。惆怅……不过目前还好，RSS 还没停。依旧惆怅……

说起奋斗，我脑海里最深刻的记忆应该就是高中的那段时间了吧。其实高中的故事我实在是不想再提，不管是自己回忆还是和别人讲述，都已经讲得太腻味了。无非就是早上五点起、晚上十一点半睡、一个月放两天假等等等等……没啥可说的了，我知道很多当时的高考考生比我努力的多。

但是我还是想说说这事儿。国庆节放假回家，在老房子里翻到了高三时的笔记本，里面零零散散的记着一些错题和知识点，这不奇怪。比较让我纳闷儿的是每隔几页就会有一些给自己洗脑的话。比如明天会更加辉煌啊之类的，我实在是想不出当时怎么会这么相信“成功学”，自己哪儿来的文采给自己注射了这么多鸡血。说真的，照那个思路写下去，大学毕业之后当个“成功学”作家或者进中宣部肯定没问题。

上大学之后全变了。来了北京之后见到了很多奇奇怪怪的东西，眼界开阔了，变得越来越不会轻易相信某些东西。对很多东西的认识也在被自己不断地推翻。就拿奋斗这件事儿来说，过去的时候我觉得奋斗嘛，只要咬着牙拼命去做就是了。现在想想，真是 naive 啊。回想自己上高中的时代，真是因为所谓的“奋斗”伤了不少人。当时很多人让我帮着讲题，我都态度恶劣的回绝了。班里的事儿也是能不掺和就不掺和。说实话，要不是当时我成绩不错，早就在班里混不下去了。所以我很明白，过去那种“奋斗”的方式不对，首先对你自己来说就很不舒服，确实，自己做完了很多事儿，但同时呢，你发现身边的同学离你越来越远。本该放松下来大家说笑打闹的时候，人家再也不会叫上你。如果这时候你想着：奋斗的人总是孤独的。那么好，你完蛋了。对别人来说，你的“奋斗”伤害了他们。让他们觉得你无情冷漠，同学朋友的友谊在你眼里一文不值。

现在，我觉得奋斗应该是这样的。做什么事儿，安安静静的做就好，遇到瓶颈了别哭天抢地，取得一点成绩的时候也别沾沾自喜。现在很多场合都在谈论“热情”。“拿出你们的热情！”——别了吧，我看还是拿出靠谱的计划比较好。热情只是一时的，只有长久稳定的计划才能为执行力提供保障。

唔…实在是写不下去了。为了凑够 800 字，下面全是扯淡。

现在坐在图书馆里敲字，深秋的上午，阳光明媚，而且没有最讨厌的瑟瑟秋风，外面的树动都不带动一下的。世界从来没这么安静过，每个人都静静地做自己的事儿。回想起昨天宋艳杰的事儿，我还真是觉得，活着真好。

本来今年也是抱着狂欢的心态去的，结果遭遇了各种不爽。真是不得不上来吐槽下了。

雾霾啊，雾霾！

马拉松前些天大家就得到了不幸的消息：马拉松当天会有严重雾霾。当时很多人就表示，如果当天污染指数达到了 300 就弃赛。当天五点半起床的时候往窗外看，已经是雾蒙蒙一片了。果不其然，当天的污染指数轻轻松松的破了 300。可就算是这样，参加比赛的人依然非常非常多。存衣服、做热身依旧是挤挤挤！

到处都是撒尿的

去年马拉松完了之后，新闻上的头条是关于比赛选手到处撒尿的。说实话去年我还真没觉得，但是今年我算是领教了。跑到蓝靛厂南路、北路的时候路边到处都是沿着河边撒尿的，真是服了……

成绩不能更丢人

去年两小时五十分勉勉强强跑完了半程。今年跑之前琢磨着，参加测向比赛之前也算是训练了，成绩应该不会比去年差吧。可是我忽略了疯长的体重，和去年比，体重飙升了十几公斤，这些重量足够我喝一壶了。跑到 17 公里的时候腿就抽了，尝试着挣扎了一下，结果还是一跑就抽。无奈，只能退赛了。这一退赛可算是让我遇到了各种奇葩事儿。

路边惊魂

刚才说到，17 公里的时候我腿抽筋了，抽筋了就上收容车呗。上了收容车，人家说还没到时间呢，得等会儿才能开。于是我就坐在车上到处望。结果一回头，看见一位男选手在追着一位女选手打闹，当时心里想的是男女朋友也别在这儿打闹啊。结果那男的追上女的之后直接抱住就啃，注意，是真啃。旁边的选手马上就把男的拉开了，结果那男的就躺在地上抽……太特么吓人了。当时收容车上的志愿者就打了急救电话。一会儿收容车开走了，也不知道后来是怎么处理的。

正文

其实主线故事是在收容车开走之后才开始的。

收容车开动的时候 17 公里处已经快要关门了，路上已经有了其他车辆，特别堵，所以师傅开起来本来就不爽。就这么着蹭到了北四环的学院桥。大家都知道，学院桥往东一拐就是奥体也就是终点了。于是师傅跟车上的志愿者说咱直接回奥体吧。志愿者肯定不能同意呀，按规定收容车肯定是要沿着赛道开回去的，毕竟前面还会有很多中途退赛的选手的。于是师傅就开始骂骂咧咧的，这时候车上的人也基本分成两拨了，一拨人觉得既然都离得这么近了赶紧回去就得了，另一拨人就说你上车了当然没事儿，前面还有那么多人没上车呢，他们怎么办？然后两拨人就开始吵。后来师傅直接急眼，就差动手了……我真服了，有这个劲儿干嘛不再跑一会儿啊，刚上车的时候一个个都快死了的样子，上来之后一下子都来了精神。当时我是真的怒了，但实在是没劲儿说话。

后来师傅还是妥协了，听了志愿者的话，按照规定继续往前走。可是刚走了没一会儿，车上的志愿者接到组委会的电话，说时间太晚了，收容车可以直接开回终点了。听到这个消息，司机师傅直接就炸了，“早就说直接回去就得了，这回好吧，学院桥过了，你说我怎么拐回去。行了，堵着吧！”。一会儿终于又从北往南开回了学院桥，可是得往西走一段。这师傅司机又开始赌气了，玩命儿往西开，就是不掉头，边开边说：你们不是指挥我么，这回你们让我往东开，我偏往西开。全车人无语，只能等师父解气了再说了。

一会儿师父终于玩儿爽了，掉头往东开。结果到了奥体之后已经来晚了，人家已经不给收容车开门了。于是又绕着奥体公园转转转，终于在大屯那边找到了一个入口。进了公园没一会儿保安把我们拦下说不能往里开了。大家只好“被下车”。下车之后大家准备去终点处取衣服，可是被拦在玲珑塔下面了，那个门死活也不给我们开，说只有工作人员能进去。在沟通的过程中我还和门口保安发生了一点小小的语言冲突。说了半天人家就是不让进，没办法，大家准备绕个大圈看看能不能从另一面进去了。刚走没一会儿，门开了！当时心里一亿只草泥马奔腾而过啊！这尼玛干啥呢，玩儿我们呢啊？有完没完？

没完！刚过了玲珑塔关卡，我们又来到了终点关卡。和刚才一样，又是只能工作人员进去。这回大家根本不商量了，因为这次是护栏。过去北京的交通护栏是 30cm 的，现在是 1.5m 的。所以你懂的，根本没人商量，直接就翻了。保安一看翻护栏的人实在是太多，不得已把门就给开了。至此，我终于找到了衣服。赶紧取出装衣服袋子里的香蕉和巧克力一口气吃了，然后坐在旁边的石头墩子上吹冷风。啊，终于结束了！

做梦！刚坐下就开始给一起来的两个小伙伴打电话，结果一个小伙伴的手机没电关机了。另一个小伙伴因为方向搞错了半天过不来。我又一次跪倒在地上，这特么是上天对我的惩罚么。在第二个小伙伴继续摸索走过来的路线的时候，我继续坐在石头敦子上吹冷风，顺便思考人生。这次马拉松真不爽啊，雾霾这么大，成绩这么差，说好的去半程终点看裴帅去矿大看楠姐的目标都没达成。上了收容车之后看一车人分成三拨吵架。哎，气过头了，好想哭。

哦！想起来了，和一个小伙伴汇合之后一起坐公交回来。公交车是下车刷卡的那种，我下车的时候还刷了卡。就这样，到宿舍之后发现公交卡丢了……里面还有九十大洋！已经欲哭无泪了。

哎，人生好艰难 ╮(╯▽╰)╭

这就是我的 2014 年马拉松，人生第二次马拉松，第一次全马。很遗憾没完赛，不过明年我会继续跑。从现在起会一直为 2015 北马准备哦！这次要特别感谢北邮跑团的小伙伴们，尤其是 Five 姐姐，还专门给做了 BUPT 的 logo，简直赞。大家明年一起加油哦！

今天上午刚刚搬家到新的博客，这个博客使用 Markdown 语法写作，靠 DropBox 同步文章，感觉还是有点儿意思呢。之前的 Octopress 博客http://coding.yunbo.li访问速度实在是太差，而且到现在为止我还是没学会怎么在上面发布文章，这时 Farbox 出现了，索性转了过来。btw，以前的负能量小站已经迁移到了http://laodao.yunbo.li

目前这个系统的大体流程已经搞明白了，但是和其他博客系统一样，主题修改还是让我头疼。

不过也管不了那么多啦，等把一切都搞明白了再开始写不知道要等到什么时候了，索性就这样写吧，反正文章丢不了。

今天给大家带来的是一个 Python 写的小玩具，在北邮人 BT 上说谢谢刷魔力值。

在北邮人 BT 上有这么一条规则：

而且除了对每个种子只能说一次之外，系统对说谢谢这个功能没有其他限制。BYRBT 上大概有 4W 个种子，也就是说我们可以通过说谢谢得到 4W 魔力值。我们要做的就是靠 Python 来实现说谢谢的功能从而获得魔力值。

好，了解完思路，让我们进入实战环节。

说谢谢背后的原理

当我们对一个种子“说谢谢”的时候，浏览器干了什么？

首先，我们打开浏览器（以 Chrome 为例了，据说 FireFox 的 FireBug 也很好用），进入 BT 随便打开一个种子，比如我们打开这个http://bt.byr.cn/details.php?id=152137&hit=1，页面拉到种子信息那里，我们可以看到说谢谢按钮。

这时，请出我们今天的第一个大杀器——Chrome 开发者工具[^1]。

Chrome 开发者工具是随 Chrome 浏览器一起发布的面向开发人员的网页调适工具，通过它，我们可以看到网页背后的技术细节。在 Windows 下，我们可以用F12打开开发者工具，在 OSX 下，快捷键为Command+Option+I。

打开开发者工具后，我们会开到这样一个窗口。最上方是功能选项卡，不同的选项卡下对应着不同的功能，我们用的比较多的是Elements和Network选项卡。在Elements选项卡中，我们可以方便地以标准的树状结构浏览 HTML 元素，通常这对了解网页布局和网页元素的细节是很有帮助的。

Network选项卡主要用来显示网页背后的数据交互，也就是用来查看 HTTP 请求。这里有两个按钮需要注意，首先是左上角的那个红点，它的左右和录音机的录制键差不多，红色表示记录状态，灰色表示非记录状态。它旁边的那个灰色叉子按钮是 Clear 键，用来删除已有的记录。在这一行的最右侧是Preserve log选项，如果它处于选中状态，那么即使网页刷新或者跳转，已有的记录依然会被保留。（默认情况下一旦页面刷新，已有记录会被清除）

现在我们要用到Network功能，所以切换到Network选项卡。然后，我们点击“说谢谢”按钮。我们观察到，Network选项卡下出现了一个条目：

这里我们需要关注两个点，首先是Path==>thanks.php。然后是Method==>POST，也就是说，在我们点“说谢谢”按钮的时候，实际上是向thanks.php发送了一个POST请求[^2]。

点击这个 POST 请求查看详情，注意框框中的内容Request URL:http://bt.byr.cn/thanks.php和id:152137。第一个是我们发送 POST 请求的 URL，也就是说，是这个 URL 接受了浏览器发送的请求；第二个是请求过程中发送的参数（表），这里也就是种子 ID（还记得我们最开始打开了哪个 URL 吗？）

到此，我们已经清楚的了解了在点击“说谢谢”按钮时，浏览器都做了哪些事儿。那接下来就是用 Python 模拟这个动作了。

用 Python 实现

让我们整理一下思路，说谢谢的核心就是一个 POST 请求，这个请求有两个变量，Request URL是固定的，id是种子 ID。也就是说只要我们得到多少种子 ID 也就会得到相应的魔力值。那么接下来我们要做的就是抓取全站的种子 ID。

打开一个种子页面，然后右键->查看网页源代码，我们发现有很多类似这样的代码：

• href="details.php?id=152186&hit=1"
• href="viewsnatches.php?id=152186"
• href="comment.php?action=add&pid=152186&type=torrent"
• href="download.php?id=152186"

这里面都包含了我们需要的种子 ID152186，所以方法就有了，只要通过正则表达式将网页源码中的种子 ID 匹配出来就可以了。

于是，我们祭出今天的第二个大杀器——BeatutifulSoup。

Beautiful Soup 是用 Python 写的一个 HTML/XML 的解析器，它可以很好的处理不规范标记并生成剖析树。通常用来分析爬虫抓取的 web 文档。对于 不规则的 Html 文档，也有很多的补全功能，节省了开发者的时间和精力。

简单说，BeautifulSoup 的作用是让我们更方便的在 HTML 代码中找东西。

材料已备齐，开搞

从这里开始我们按事件发生的先后顺序讲……要不然我怕讲乱了……

登录

登录是以后所有操作的基础，所以我们先看看登录的过程。打开 Chrome 开发者工具，找到 Network 选项，把 Preserve log 选中。然后我们登录一下 BT

很不幸，BT今天挂掉了，截图只能以后搞了

我们可以看到，登录的 POST 请求中发出了四个数据 username、password、imagestring 和 imagehash。前两个不用说，是你的用户名密码。imagestring 是你输入的验证码字符，imagehash 是与这张验证码图片对应的一个 hash 值，只有 hash 值和你输入的 string 值成功匹配时你才能登录。

好像说着说着就有点罗嗦了，有空慢慢写吧……to be continued

很难想象我竟然起了一个这么 ordinary 的 tilte，事实上标题里说的这个问题已经虐了我一个晚上，尤其是 vsftpd，当初在树莓派上配置过 vsftpd，隐约记得没有多长时间就配好了。结果隔了半年再次尝试 vsftpd 的时候，这货狠狠地抽了我一巴掌，死活配不对，尤其是用户那一块儿，简直烦死了。好不容易折腾好了，马克一下，防止下次被虐。

环境说明

写这篇文章的时候没在学校，手上只有一台弱不经风的 air，小心翼翼地在虚拟机里装了 Ubuntu Server 12.04。网卡用了桥接模式，所以虚拟机里的系统得到的是类似 192.168.1.xxx 这样的 IP。其他的就没什么好说的了。

先换个源

北京地区的推荐北京交通大学或者搜狐的源，速度超快哦~如果你在教育网的话那就随意了，清华、北理工、华中科大等等速度都好得不得了。

以北交源为例，从这个页面查看源地址，然后修改 sources.list。

修改之前，先备份一下

sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak

然后放心大胆地修改 sources.list 即可

sudo vim /etc/apt/sources.list

LAMP 安装

LAMP 是指 Linux、Apache、MySql 和 PHP。安装过程很简单，麻烦的是配置。首先在终端里运行下面的命令进行 LAMP 的安装

sudo apt-get install apache2 mysql-server mysql-client php5 php5-gd php5-mysql

安装过程中需要设置 mysql 的 root 密码，这个很重要，请千万记牢！ 由于 LAMP 大部分操作与/var/www 目录相关，为了方便，修改该目录的权限为普通用户可访问。

sudo chmod 777 /var/www/

phpmyadmin 的安装

phpmyadmin 可以让我们方便的通过 web 管理服务器上的 mysql 数据库。

sudo apt-get install phpmyadmin

在安装过程中会要求选择 Web server：apache2 或 lighttpd，选择 apache2 然后会要求输入一个密码，建议和 mysql 的 root 密码设置成一样的。 然后把 phpmyadmin 的目录链接到/var/www 里面

sudo ln -s /usr/share/phpmyadmin /var/www

到此，LAMP 和 phpmyadmin 的安装就完成了，这时候在浏览器中输入虚拟机的 IP 地址，可以看到“It works！“的提示，说明 Apache 已经正常工作了。进入 phpmyadmin 目录，就像这样 192.168.1.xxx/phpmyadmin，就可以看到 phpmyadmin 的首页了，用户名 root，密码用前面几步输入的 root 密码就可以登录啦。

万恶的 vsftpd

本来是想弄成多用户的，每个用户只能操作自己目录内的文件，但是操作的时候遇到了一些问题，waiting for update 我们的应用场景是有多个 FTP 用户，分别对应着不同的 Home 目录，并且彼此只能在各自的目录内进行操作。

先安装

sudo apt-get install vsftpd

然后我们建立一个 ftp 用户，比如叫 ftpuser

sudo useradd ftpuser
sudo passwd ftpuser

为 ftpuser 建立用户目录

sudo mkdir /home/ftpuser

改变权限

sudo chown -R ftpuser /home/ftpuser

用户部分处理完，我们开始配置 vsftpd

sudo vim /etc/vsftpd.conf

参考下面的配置

#禁止匿名用户登录

anonymous_enable=NO
#本地用户可用
local_enable=YES
#可用写操作
write_enable=YES
#权限掩码(设置上传的文件为所有用户可读写,这样Apache就有读写权限了)
local_umask=000
#不须要显示某目录下文件信息
dirmessage_enable=NO
#加点登录后的提示语句
ftpd_banner=Hello~~

重启 vsftpd，上面的配置就生效啦~

sudo /etc/init.d/vsftpd restart

参考文档

1. Ubuntu 12.04下LAMP安装配置

国庆假期回家，在自己的房间里翻出来高中时候的笔记本。翻了翻，发现了一些幼稚的文字。发上来留个纪念吧。下面这篇应该是 2012 年 3 月的。

3 月中旬，我去外地考试，在回家的班车上看见了一对情侣，他们是那么朴素，自然，衣着也并不华丽。女生脸上有淡淡的高原红，她话不多，一举一动都带着几分害羞。男生显得高大，结实。

这对情侣带着两只大大的旅行箱，看得出已经在旅途上奔波了好久。上车后，由于人多，他们不得不分开坐，女生坐在班车的中间位置，后背朝前，正好面向我。男生坐在了大后面。此时女生显得十分不安，脸上没有了笑意，并开始不断的咬嘴唇。她变得更加少言，买票的问她问题，她也只是配合着手势简单的回答。她就这样沉默了好久。这时有几个乘客要下车，男生终于挤到了前面，可是座位还是不够，所以女生坐在了他怀里。

雨停了，花朵张开笑脸，对着太阳微笑。女生终于笑了，她笑得那样自然，亲切。也许对她来说，只有和那男生在一起时，才有安全感，这就是爱，一份正经历着奔波洗涤的爱。看得出，他们俩并不富裕，但他们的这份爱却值得所有人羡慕，就像樱花的粉色，让人感到无比舒适。

我的文笔差到了极点，一件无比美好的事被我描写成这样。不管将来如何，我希望他们此时此刻正体会着对方浅浅的爱。我还年少，经世不多，我深知自己没有能力去评价什么是爱，但内心告诉我，这就是爱。

这个小站会取代过去的 laodao.yunbo.li，作为我矫情、发牢骚的地方。小站虽然搭建在 Github Pages 上，但是前端库文件都是用的 BaiduCDN，所以速度应该还说得过去。今天晚上准备把 laodao.yunbo.li 给停掉了，又有一段记忆要被尘封。

感觉大二这一年还是让我成长了不少，至少让我在遇到那么多事儿的情况下不那么心慌了。搁过去，这么多事儿压在我身上的话，估计早就焦虑得睡不着觉了。虽然现在还是会因为这些琐事头疼，但还好，不会再像过去一样——心里波涛汹涌，翻江倒海。

过去的一段时间以“忙”为理由推掉了好多好多事儿，比如健身，比如写博客，比如读书。希望从这个小站建立开始，我能改掉这个坏毛病吧。昨天跑步的时候得到一个体会，按时间比按量来的舒服，30 分钟一到，我马上停下来，因为我知道还有别的事儿要做，不能咬着牙在这里跑步。做其他事儿也一样，在自己还算舒服的情况下，尽量做就好。时间点到了，马上投身到下一件该做的事儿上。

如果让我用一句诗来描述最近的心态的话，那就是——悟以往之不谏，知来者之可追。