javascript 实现加法分离。 plus(3)(4); // => 得到 7

原文地址：http://cnodejs.org/topic/5230d5f0101e574521c86ff4

JavaScript 的设计是典型的函数式的编程范式
匿名函数

JSON数据本身就是字符串，经过JSON.parse才转化为javascript对象，你在console中输入的是对象，而不是JSON字符串。另外对象的key也可看作是字符串，例如一个对象{1：1}，其中的属性名——1实际上是string类型，属性值——1则是number类型

什么是匿名函数？就是没有名字的函数。上一篇文章中举的例子：

setTimeout(function () {
  // some code...
}, 1000);

其中的function就是一个匿名函数（因为它没有名字）

如果这么写：

setTimeout(function something () {
  // some code...
}, 1000);

或者这么写：

var something = function () {
  // some code...
};

setTimeout(something, 1000);

这样就给这个函数起名为something，所以就不是匿名函数了。而且，因为有了名字，我们就可以在别的地方，比如函数内部调用它，从而实现代码的复用或者递归调用。

**注意：**上面两种写法虽然都给函数起名为something，但是这个名字的作用域不同，倒数第二种写法把something的作用域限制在了他本身，也就是只能在函数内部递归调用，而倒数第一种写法中something的作用域就是最外部的作用域，这也是setTimeout可以把它作为参数的原因。

所以，匿名函数并没有什么神奇，和有名字的函数没什么本质区别。不过，按照Felix’s Node.js Style Guide的推荐，最好给大多数函数都起上名字，这样有利于代码的维护。也就是按照上面倒数第二种写法。

---

函数自调用

所谓的函数自调用，就是在定义函数的时候直接调用。

比如：

var result = function (x) { return x + 1; }(3); // => result 的值为4

这段代码的本质是：

var plusOne = function (x) {
  return x + 1;
};

var result = plusOne(3);

这样写就很清楚了，我们先定义了一个函数plusOne，然后调用它，并提供实参「3」。

而上面的自调用的写法就是把这两件事放在一起完成了。

通过function (x) { return x + 1; }这一段代码，相当于写了一个「函数字面量」，而后面紧接着的(3)就是给这个「函数字面量」一个参数来调用它。

换句话说，所有函数类对象，不论是一个现场定义的匿名函数，还是一个之前定义的有名字的函数，他们在不加括号的时候都代表了这个函数对象本身，而加了括号就代表调用这个函数，也就是这个函数return的对象。

你可能会问，既然我在定义函数的时候直接调用它，我为什么不直接写函数里的代码呢？

// var result = function (x) { return x + 1; }(3); // => result 的值为4

var result = 3 + 1;

这样不是更好吗？

在有些情况下的确是这样更简洁，但在另一些情况下，我们希望递归调用，或者希望创造一个闭包，就需要使用函数自调用的技巧了。至于什么是闭包，后面会有解释。

---

返回函数的函数

重温刚才的例子：

var plusOne = function (x) {
  return x + 1;
};

var result = plusOne(3);

这里的函数plusOne返回参数加一以后的值。

实际上一个函数是可以返回任何对象的，我可以给plusOne再套一层：

var plusOne = function () {
  var realFunction = function (x) {
    return x + 1;
  };
  return realFunction; // 这里不能加括号，因为我们要返回`realFunction`函数本身
};

var result = plusOne()(3);

// 等价于
// var newFunction = plusOne();
// var result = newFunction(3);

这个很好理解，plusOne是第一个真正被调用的函数，通过plusOne()加括号，我们得到了plusOne函数return的对象，也就是realFunction函数，再通过plusOne()(3)加括号，我们就得到了realFunction这个函数传了参数「3」以后的return的值，也就是4。（注意对于最后一行plusOne()来说，realFunction这个名字已经不存在）

我们也可以把x放在外面：

var plusOne = function (x) {
  var realFunction = function () {
    return x + 1;
  };
  return realFunction; // 这里不能加括号，因为我们要返回`realFunction`函数本身
};

var result = plusOne(3)(); 

// 等价于
// var newFunction = plusOne(3);
// var result = newFunction();

这里，我们相当于先把「3」告诉plusOne函数，然后由realFunction负责把plusOne获得的参数加一，并返回。所以我们需要在第一个括号里传3，第二个括号为空。

利用上面所说的返回函数的函数，我们可以做一些很有趣的事情。

比如，我们想写一个做两个数相加的工作的函数。传统的方法是：

function plus (a, b) {
  return a + b;
}

plus(3, 4); // => 得到 7

现在我们可以这么写：

function plus (a) {
  return function (b) {
    return a + b;
  };
}

plus(3)(4); // => 得到 7

这样写的好处在于我可以把加法动作分成两部完成，而不一定要同时知道加号两边的数字。这样就可以做到：

var anotherNumberIs = plus(3);

// some code...

anotherNumberIs(4); // => 得到 7

把一个动作分成两步完成还可以实现一定的私密性。想象一下，我们需要两个密码打开一把锁，但是我们又不希望其中任何一个人知道另一个人的密码。如果我们用类似传统的加法方式实现，那必定会有一个环境，是两个密码的作用域重叠的，比如：

function unlock(pw1, pw2) {
  // unlocking
  if (pw1 + pw2 === 'niubi') return true;
  else return false;
}

var password1 = 'niu';
var password2 = 'bi';

unlock(password1, password2); // => true

而如果我们这么写：

function unlock (pw1) {
  return function (pw2) {
    if (pw1 + pw2 === 'niubi') return true;
    else return false;
  };
}

var myLock;

function () {
  var password1 = 'niu';
  myLock = unlock(password1);
}();

function () {
  var password2 = 'bi';
  myLock = myLock(password2);
}()

myLock; // => true

就能把两个密码的作用域完全分隔，保证两个密码的独立和安全。当然，这只是一个比喻，真正的安全问题比这复杂的多。

---

闭包（Closure）

闭包是经常被复杂化的概念。如果你仔细阅读并理解了上面的所有内容，其实你已经明白了闭包是怎么回事。

在上面的锁的例子中，我们用myLock = unlock(password1)把密码1包在了此时的myLock函数中，这个函数走到哪里，就把password1带到哪里。比如带到了这里：myLock = myLock(password2)。但是在用密码2解锁的时候，这个环境下无法得知myLock里装着的password1是什么，却可以把password2交给myLock函数来解锁。所以我们称它为「闭包」。

当然闭包不一定要那么复杂。非常粗略地说，如果一个函数包含着一些变量，函数走到哪里变量就走到哪里，但是这个变量从外面无法读取，那这就是一个闭包。

举个最简单的例子：

function incrementClosure () {
  var current = 0;
  return function () {
    current = current + 1;
    return current;
  };
}

var inc = incrementClosure();

inc(); // => 1
inc(); // => 2
inc(); // => 3
inc(); // => 4
// ......

这就是最简单的一个闭包的例子，current这个变量会一直跟着inc函数走，所以每次inc()都会对这个current执行加一的操作，但是在调用inc的时候，完全看不到里面发生了什么。所以使用闭包十分安全。

这时候，我们再回去看刚才的一个例子：

var plusOne = function (x) {
  var realFunction = function () {
    return x + 1;
  };
  return realFunction; // 这里不能加括号，因为我们要返回`realFunction`函数本身
};

var result = plusOne(3)();

这里其实也创造了一个闭包，通过plusOne(3)把「3」这个参数存了下来，之后只要直接加()就可以给3加1了。

闭包也有不足的地方，那就是这个变量会长期占用内存，因为运行环境不知道哪年哪月又会调用inc()，所以这个current就只能一直保留着，以备不时之需。

---

上面这几个概念都是 JavaScript 中非常重要也很常用的概念，在这里总结一下，供初学者参考。欢迎交流！

评论：

全局变量这个概念是依托作用域的概念的，一个东西即使一直存在内存里，但是当前的上下文无法访问，还是不能称为全局变量。

而且即使父函数不存在了这个current应该还是会存在的。

比如：

var inc = function () {
  var current = 0;
  return function () {
    current = current + 1;
    return current;
  };
}();

inc(); // => 1
inc(); // => 2
inc(); // => 3
inc(); // => 4
// ......

欢迎继续讨论~