JavaScript面向对象编程指南（v2）- 3

函数 - 永不停歇的工厂

工厂：【原料】 => 【生产】 => 【产出】
函数：【参数】 => 【计算】 =>【返回结果】
函数式编程：【计算】只使用【参数】，强调粒子性，不污染外围空间, 明确返回处理结果。

// 累加器
function accu(num) {
    var temp = 0;
    for (var i = 0; i < num; i += 1) {
      temp += i;
    }
    return temp;
}
var count = accu(100);
// count = 4950

javascript 内置函数

顶层参数

Paste_Image.png

顶层属性

Paste_Image.png

匿名函数

一个没有名字的工厂

function () {
  console.log(123)
}

回调函数

商家对工厂a说：给你一批原料和联系方式，处理完后，告诉我结果

// 工厂a 处理原料
function a(param, cb) {
  var temp = param + 1;
  cb(temp );
}
// 给商家，汇报结果
function b(param) {
  console.log(param); // 11
}
// 商家给一批【原料，联系方式】给工厂a
a(10, b);

即时函数

定义后立即执行
格式：（函数体）（）

(function() {
  console.log(123) // 123
})()

内部（私有）函数

就是在函数体内部再定义函数

function a() {
  function b1() {}; // 不推荐语法
  var b2 = function() {} // 推荐语法
}

返回函数的函数

因为函数的返回值可以是任意值，那当然可以返回一个函数了

function a() {
  return function b() {}
}

能72变的函数

一个工厂根据市场情况，重构自己，理所当然的事

// 常用于判断运行环境后，运行指定功能，避免每次运行都需要判断的弊端。
function a () {
   // 判断浏览器类型，执行不同的代码
  var userAgent = navigator.userAgent;
  //判断是否Opera浏览器
  if (userAgent.indexOf("Opera") > -1) {
      console.log('Opera');
      a = function() {
        console.log('Opera');
      }
  } else {
    console.log('Not Opera');
    a = function() {
      console.log('Not Opera');
   }
  }
}

闭包 - 小偷

闭包在各大参考书中，都不是很容易理解的东西，就像要理解一个人活得好好的，非要作死一样。
在我的理解中：闭包就是小偷，偷走本不属于它领域的东西。
出现bug时，就跟警察查案一样困难

// 工厂F
var F = function() {
   // 一台机器b
  var frj = '缝纫机';
  // 一个员工a, 老实人，正常工作 
  var a = function () {
    console.log(32123)
  }
  // 一个员工b, 闭包（小偷）, 把frj【缝纫机】给自己用了
  var b = function () {
    return frj;
  }
  // 有一天，员工b离职了，也随便偷走了frj【缝纫机】
  return b;
}
// F() => b
// b() => 缝纫机   拿走了不属于它领域（作用域）的东西

闭包应用
解决变量提升问题(es6 中不存在)

// 问题代码:
var arr = [];
for (var i =0; i < 3; i += 1) {
  arr[ i ] = function () { return i };
}
// arr[ 0 ]()   // 3
// arr[ 1 ]()   // 3
// arr[ 2 ]()   // 3
//
//使用闭包,解决
var arr = [];
for (var i =0; i < 3; i += 1) {
    arr[ i ] = ( function (x) { 
                  return function() { return x }; 
               } )(i);
}
// arr[ 0 ]()   // 0
// arr[ 1 ]()   // 1
// arr[ 2 ]()   // 2