原文地址：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
// ......欢迎继续讨论~