function f1(callback){

　　setTimeout(function () {　　// ----> 将耗时的操作推迟执行，什么垃圾的初级思想，当然不可行
　　　　// f1的任务代码
　　　　callback();
　　}, 1000);

}

// 当f1发生done事件，就执行f2。
f1.on('done', f2);

---------------------------------------------------------------------
function f1(){
　　setTimeout(function () {
　　　　// f1的任务代码
　　   // 执行完成后，立即触发done事件，从而开始执行f2
　　　　f1.trigger('done');　　

　　}, 1000);
}

// f2向"信号中心"jQuery订阅"done"信号。
jQuery.subscribe("done", f2);

-----------------------------------------------------------------------
function f1(){
　　setTimeout(function () {
　　　　// f1的任务代码
　　　　// f1执行完成后，向"信号中心"jQuery发布"done"信号，从而引发f2的执行
　　　　jQuery.publish("done");　　
　　}, 1000);
}

　f1().then(f2);

function f1(){
　　var dfd = $.Deferred();
　　setTimeout(function () {
　　　　// f1的任务代码
　　　　dfd.resolve();
　　}, 500);

　　return dfd.promise;
}

/**
 * 函数作为参数 
 */
const promise = new Promise( function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);　　　　　　// pending ----> resolved，在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；
  } else {
    reject(error);　　　　　　 // pending ----> rejected，在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
  }
});

/* 延迟执行 */
// 1.返回一个Promise实例，一段时间以后才会发生的结果（算是一种承诺）
function timeout(ms) {
  return new Promise( (resolve, reject) => {
    setTimeout(resolve, ms, 'done');　　     // [开始异步流程]
  } );
}

timeout(100).then( (value) => {　　// 2.过了指定的时间（ms参数）以后，Promise实例的状态变为resolved，就会触发then方法绑定的回调函数
  console.log(value);
} );

/* 立即执行 */
// 1.Promise 新建后就会立即执行
let promise = new Promise(function(resolve, reject) {
  console.log('Promise');                    // [开始异步流程]
  resolve();
});

promise.then(function() {
  console.log('resolved.');　　// 2. then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行
});

console.log('Hi!');

// Promise
// Hi!
// resolved

function loadImageAsync(url) {
// 使用Promise包装了一个图片加载的异步操作
  return new Promise( function(resolve, reject){
    const image = new Image();              // [开始异步流程]

    image.onload = function() {　　// --> 加载成功,就执行这个
      resolve(image);
    };

    image.onerror = function() {   // --> 加载失败,就执行这个
      reject(new Error('Could not load image at ' + url));
    };

    image.src = url;
  });
}

const p1 = new Promise(function (resolve, reject) {
  setTimeout(() => reject(new Error('fail')), 3000)　　// 1. p1是一个 Promise，3 秒之后变为rejected
})

const p2 = new Promise(function (resolve, reject) {　　// 2. p2的状态在 1 秒之后改变，resolve方法返回的是p1
  setTimeout(() => resolve(p1), 1000)　　　　　　　　　　 // 3. p2返回的是另一个 Promise，导致p2自己的状态无效了，被p1决定
})

p2.then(result => console.log(result))　　　　　　　　　　// 4. then语句都针对的是后者（p1）
  .catch(error => console.log(error))　　　　　　　　　　 // 5. 又过了 2 秒，p1变为rejected，导致触发catch方法指定的回调函数。
// Error: fail

new Promise((resolve, reject) => {
  resolve(1);       // 立即 resolved 的 Promise 是在本轮事件循环的末尾执行，总是晚于本轮循环的同步任务【变为：return resolve(1)就不会执行后面的了】
  console.log(2);　　// 仍然会执行，并且还是首先打印出来【后继操作应该放到then方法里面，而不应该直接写在resolve或reject的后面】
}).then(r => {
  console.log(r);
});
// 2
// 1

function* helloWorldGenerator() {
  yield 'hello';       // 状态一
  yield 'world';　　　　 // 状态二
  return 'ending';　　　// 状态三
}

var hw = helloWorldGenerator();　　// 不会立即执行，返回的是：一个指向内部状态的指针对象

调用 Generator 函数，返回一个遍历器对象，代表 Generator 函数的内部指针。

以后，每次调用遍历器对象的next方法，就会返回一个有着value和done两个属性的对象。

value属性表示当前的内部状态的值，是yield表达式后面那个表达式的值；

done属性是一个布尔值，表示是否遍历结束。

（1）遇到yield表达式，就暂停执行后面的操作，并将紧跟在yield后面的那个表达式的值，作为返回的对象的value属性值。

（2）下一次调用next方法时，再继续往下执行，直到遇到下一个yield表达式。

（3）如果没有再遇到新的yield表达式，就一直运行到函数结束，直到return语句为止，并将return语句后面的表达式的值，作为返回的对象的value属性值。

（4）如果该函数没有return语句，则返回的对象的value属性值为undefined。

var arr = [1, [[2, 3], 4], [5, 6]];

var flat = function* (a) {
  a.forEach(function (item) {
    if (typeof item !== 'number') {
      yield* flat(item);
    } else {
      yield item;
    }
  });
};

for (var f of flat(arr)){
  console.log(f);
}

function* outer() {
  yield 'open'
  yield inner()　　// --> (A)
  yield 'close'
}

function* inner() {
  yield 'hello!'
}

== yield inner() ==
var gen = outer()
gen.next() // -> 'open'
gen.next() // -> a generator，这是表象
gen.next() // -> 'close'


== yield* inner() ==
var gen = outer()
gen.next() // -> 'open'
gen.next() // -> 'hello!'，这是表象背后的本质
gen.next() // -> 'close'

function f(m){
  return m * 2;     
}

f(x + 5);

// 等同于

var thunk = function () {
  return x + 5;
};

function f(thunk){
  return thunk() * 2;
}

// 正常版本的readFile（多参数版本）
fs.readFile(fileName, callback);

--------------------------------------------
// Thunk版本的readFile（单参数版本）
var readFileThunk = Thunk(fileName);
readFileThunk(callback);

var Thunk = function (fileName){
  return function (callback){
    return fs.readFile(fileName, callback); 
  };
};

var fs       = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile);

var gen = function* (){
  var r1 = yield readFile('/etc/fstab');
  console.log(r1.toString());
var r2 = yield readFile('/etc/shells');
  console.log(r2.toString());
};

var fs = require('fs');

var readFile = function (fileName){
  return new Promise(function (resolve, reject){
    fs.readFile(fileName, function(error, data){
      if (error) reject(error);
      resolve(data);
    });
  });
};

var gen = function* (){
  var f1 = yield readFile('/etc/fstab');
  var f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

var fs = require('fs');

var readFile = function (fileName){
  return new Promise(function (resolve, reject){
    fs.readFile(fileName, function(error, data){
      if (error) reject(error);
      resolve(data);
    });
  });
};


# 一个 Generator 函数，依次读取两个文件

var gen = function* (){
  var f1 = yield readFile('/etc/fstab');
  var f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};


# 写成 async 函数，就是下面这样

var asyncReadFile = async function (){
  var f1 = await readFile('/etc/fstab');
  var f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

var sleep = function (time) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () {
            // 模拟出错了，返回 ‘error’
            reject('error');
        }, time);
    })
};

var start = async function () {
    try {
        console.log('start');
        await sleep(3000); // 这里得到了一个返回错误
        
        // 所以以下代码不会被执行了
        console.log('end');
    } catch (err) {
        console.log(err); // 这里捕捉到错误 `error`
    }　　
};

..省略以上代码

var start = async function () {
    for (var i = 1; i <= 10; i++) {
        console.log(`当前是第${i}次等待..`);
        await sleep(1000);
    }
};

..省略以上代码

let 一到十 = [1,2,3,4,5,6,7,8,9,10];

// 错误示范
一到十.forEach(function (v) {
    console.log(`当前是第${v}次等待..`);
    await sleep(1000); // 错误!! await只能在async函数中运行
});

// 正确示范
for(var v of 一到十) {
    console.log(`当前是第${v}次等待..`);
    await sleep(1000); // 正确, for循环的上下文还在async函数中
}

import fs      from 'fs';
import path    from 'path';
import request from 'request';

var movieDir = __dirname + '/movies',
    exts     = ['.mkv', '.avi', '.mp4', '.rm', '.rmvb', '.wmv'];


/////////////////
// 读取文件列表
/////////////////

var readFiles = function () {
    return