var add = function (a, b) {
  return a + b;
}

var myObject = {
  value: 0,//屬性
  increment: function (inc) {//方法
    this.value += typeof inc === 'number' ? inc : 1;
  }
};
myObject.increment();
console.log(myObject.value);//1
myObject.increment(2);
console.log(myObject.value);//3

var add = function (a, b) {
  return a + b;
}
var sum = add(3, 4);//7；this 被綁定到全局對象

myObject.double = function () {
  var that = this;//讓內(nèi)部函數(shù)可以通過這個變量訪問到 this (myObject)
  var helper = function () {
    that.value = add(that.value, that.value);
  };
  helper();//以函數(shù)形式調(diào)用 helper
};
myObject.double();//以方法形式調(diào)用 helper
console.log(myObject.value);//6

/**
 * 構(gòu)造器調(diào)用模式（不推薦）
 */
var Quo = function (string) {//定義構(gòu)造器函數(shù)；按照約定，變量名首字母必須大寫
  this.status = string;//屬性
};
/**
 * 為 Quo 的所有實(shí)例提供一個名為 get_status 的公共方法
 * @returns {*}
 */
Quo.prototype.get_status = function () {
  return this.status;
};
var myQuo = new Quo("confused");//定義一個 Quo 實(shí)例
console.log(myQuo.get_status());//"confused"

//相加
var array = [3, 4];
var sum = add.apply(null, array);//7
console.log(sum);
//調(diào)用 Quo 的 get_status 方法，給 this 綁定 statusObject 上下文
var statusObject = {
  status: 'A-OK'
};
var status = Quo.prototype.get_status.apply(statusObject);
console.log(status);//'A-OK'

//構(gòu)造一個能夠接收大量參數(shù)，并相加的函數(shù)
var sum = function () {
  var i, sum = 0;
  for (i = 0; i < arguments.length; i += 1) {
    sum += arguments[i];
  }
  return sum;
};
console.log(sum(4, 5, 6, 7, 8, 9));//39

var add = function (a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw{
      name: 'TypeError',
      message: 'add needs numbers'
    };
  }
  return a + b;
}

var try_it = function () {
  try {
    add("seven");
  } catch (e) {
    console.log(e.name + ": " + e.message);
  }
};
try_it();

/**
 * 為 Function.prototype 新增 method 方法
 * @param name 方法名稱
 * @param func 函數(shù)
 * @returns {Function}
 */
Function.prototype.method = function (name, func) {
  if (!this.prototype[name])//沒有該方法時，才添加
    this.prototype[name] = func;
  return this;
};

Number.method('integer', function () {
  return Math[this < 0 ? 'ceil' : 'floor'](this);
});

String.method('trim', function () {
  return this.replace(/^\s+|\s+$/g, '');
});

Function.prototype.method = function (name, func) {
  if (!this.prototype[name])//沒有該方法時，才添加
    this.prototype[name] = func;
  return this;
};

/**
 * 漢若塔
 * @param disc 圓盤編號
 * @param src 源柱子
 * @param aux 輔助用的柱子
 * @param dst 目的柱子
 */
var hanoi = function (disc, src, aux, dst) {
  if (disc > 0) {
    hanoi(disc - 1, src, dst, aux);
    console.log('Move disc ' + disc + ' from ' + src + ' to ' + dst);
    hanoi(disc - 1, aux, src, dst);
  }
};
hanoi(3, 'Src', 'Aux', 'Dst');

/**
 * 從某個節(jié)點(diǎn)開始，按照 HTML 源碼中的順序，訪問該樹的每一個節(jié)點(diǎn)
 * @param node 開始的節(jié)點(diǎn)
 * @param func 被訪問到的每一個節(jié)點(diǎn)，會作為參數(shù)傳入這個函數(shù)，然后這個函數(shù)被調(diào)用
 */
var walk_the_DOM = function walk(node, func) {
  func(node);
  node = node.firstChild;
  while (node) {
    walk(node, func);
    node = node.nextSibling;
  }
};

/**
 * 查找擁有某個屬性的元素
 * @param att 屬性名稱字符串
 * @param value 匹配值（可選）
 * @return 匹配的元素數(shù)組
 */
var getElementsByAttributes = function (att, value) {
  var results = [];
  walk_the_DOM(document.body, function (node) {
    var actual = node.nodeType === 1 && node.getAttribute(attr);
    if (typeof actual === 'string' && (actual === value) || typeof value != 'string') {
      results.push(node);
    }
  });
  return results;
};

/**
 * 求階乘（帶尾遞歸的函數(shù)）
 *
 * JavaScript 當(dāng)前沒有對尾遞歸進(jìn)行優(yōu)化，所以如果遞歸過深會導(dǎo)致堆棧溢出
 * @param i
 * @param a
 * @returns {*} 返回自身調(diào)用的結(jié)果
 */
var factorial = function factorial(i, a) {
  a = a || 1;
  if (i < 2) {
    return a;
  }
  return factorial(i - 1, a * i);
};
console.log(factorial(4));

var foo = function () {
  var a = 3, b = 5;
  var bar = function () {
    var b = 7, c = 11;
    console.log("a:" + a + ";b:" + b + ";c:" + c);//a:3;b:7;c:11
    a += b + c;
    console.log("a:" + a + ";b:" + b + ";c:" + c);//a:21;b:7;c:11
  };
  console.log("a:" + a + ";b:" + b);//a:3;b:5
  bar();
  console.log("a:" + a + ";b:" + b);//a:21;b:5
};
foo();

var myObject = (function () {
  var value = 0;//只對 increment 與 getValue 可見
  return {
    increment: function (inc) {
      value += typeof inc === 'number' ? inc : 1;
    },
    getValue: function () {
      return value;
    }
  }
}());

/**
 * quo 構(gòu)造函數(shù)
 * @param status 私有屬性
 * @returns {{get_status: Function}}
 */
var quo = function (status) {
  return {
    get_status: function () {//方法
      return status;
    }
  };
};
var myQuo = quo("amazed");
console.log(myQuo.get_status());//amazed

/**
 * 設(shè)置一個 DOM 節(jié)點(diǎn)為黃色，然后漸變?yōu)榘咨?
 * @param node
 */
var fade = function (node) {
  var level = 1;
  var step = function () {
    var hex = level.toString(16);//轉(zhuǎn)換為 16 位字符
    node.style.backgroundColor = '#FFFF' + hex + hex;
    if (level < 15) {
      level += 1;
      setTimeout(step, 100);
    }
  };
  setTimeout(step, 100);
};
fade(document.body);

var add_the_handlers_error = function (nodes) {
  var i;
  for (i = 0; i < nodes.length; i += 1) {
    nodes[i].onclick = function (e) {
      alert(i);//綁定的是變量 i 本身，而不是函數(shù)在構(gòu)造時的變量 i 的值?。?！
    }
  }
};

/**
 * 給數(shù)組中的節(jié)點(diǎn)設(shè)置事件處理程序（點(diǎn)擊節(jié)點(diǎn)，會彈出一個顯示節(jié)點(diǎn)序號的對話框）
 * @param nodes
 */
var add_the_handlers = function (nodes) {
  var helper = function (i) {//輔助函數(shù)，綁定了當(dāng)前的 i 值
    return function (e) {
      alert(i);
    };
  };
  var i;
  for (i = 0; i < nodes.length; i += 1) {
    nodes[i].onclick = helper(i);
  }
};

request = prepare_the_request();
response = send_request_synchronously(request);
display(response);

request = prepare_the_request();
send_request_asynchronously(request, function(response){
 display(response);
)};

String.method('deentityify', function () {
  //字符實(shí)體表：映射字符實(shí)體的名字到對應(yīng)的字符
  var entity = {
    quot: '"',
    lt: '<',
    gt: '>'
  };
  //返回 deentityify 方法
  return function () {
    /**
     * 返回以'&'開頭 和 以';'結(jié)尾的子字符串
     */
    return this.replace(/&([^$;]+);/g, function (a, b) {
      var r = entity[b];//b：映射字符實(shí)體名字
      return typeof r === 'string' ? r : a;//a：原始字符串
    });
  };
}());

/**
 * 產(chǎn)生唯一字符串的對象（安全的對象）
 * 唯一字符串由 (前綴 + 序列號) 組成
 * @returns {{set_prefix: Function, set_seq: Function, gensym: Function}}
 */
var serial_number = function () {
  var prefix = '';
  var seq = 0;
  return {
    /**
     * 設(shè)置前綴
     * @param p
     */
    set_prefix: function (p) {
      prefix = String(p);
    },
    /**
     * 設(shè)置序列號
     * @param s
     */
    set_seq: function (s) {
      seq = s;
    },
    /**
     * 產(chǎn)生唯一的字符串
     * @returns {string}
     */
    gensym: function () {
      var result = prefix + seq;
      seq += 1;
      return result;
    }
  };
};
var seqer = serial_number();
seqer.set_prefix('Q');
seqer.set_seq(1000);
var unique = seqer.gensym();
console.log(unique);//Q1000

getElement('myDiv')
 .move(350,150)
 .width(100);

Function.method('curry', function () {
  var slice = Array.prototype.slice,
    args = slice.apply(arguments),//創(chuàng)建一個真正的數(shù)組
    that = this;
  return function () {
    return that.apply(null, args.concat(slice.apply(arguments)));
  };
});
var add1 = add.curry(1);
console.log(add1(6));//7

var fiboncci = function () {
  var memo = [0, 1];//存儲結(jié)果（已經(jīng)計(jì)算過的值）
  var fib = function (n) {
    var result = memo[n];
    if (typeof result !== 'number') {
      result = fib(n - 1) + fib(n - 2);
      memo[n] = result;
    }
    return result;
  };
  return fib;
}();
for (var i = 0; i <= 10; i += 1) {
  console.log(i + ": " + fiboncci(i));
}

/**
 * 帶記憶功能的函數(shù)
 * @param memo 初始的 memo 數(shù)組
 * @param formula 公式函數(shù)
 * @returns {Function}
 */
var memoizer = function (memo, formula) {
  var recur = function (n) {
    var result = memo[n];
    if (typeof result != 'number') {
      result = formula(recur, n);
      memo[n] = result;
    }
    return result;
  };
  return recur;
};

/**
 * 斐波那契
 * @type {Function}
 */
var fibonacci = memoizer([0, 1], function (recur, n) {
  return recur(n - 1) + recur(n - 2);
});
console.log(fibonacci(10));//55

/**
 * 階乘
 * @type {Function}
 */
var factorial = memoizer([1, 1], function (recur, n) {
  return n * recur(n - 1);
});
console.log(factorial(10));//3628800