<br />javascript拥有简洁的表达，使你可以专心于算法攻略。就好像黑白机上的闯关游戏，你拾取了宝剑，只需要不停地点A就可以了。你唯一要思考的就是如何不停地跳躲Boss的大招。
javascript成为浏览器的唯一语言，并且成为世界标准许多年，是有非常重要的理由的。《JavaScript: The Good Parts》做出了非常清晰地解释。
JavaScript:The World's Most Misunderstood Programming Language
然而，想要掌握javascript的正确编写方式并不容易。尤其是当你从教科书开始的时候，大部分给你的信息都是面向对象的东西：new， prototype，class，extend，...
这些都不是正确编写javascript的方式，当然你可以这么做，但是你会恨上javascript，这样编写的感觉会让你觉得你在写java却不能拥有java一样的计算速度。
想要喜欢上javascript并且享受programming的快感，你需要放下一切对面向对象的理解，走进函数和求值的世界。你的所有代码只有function，这是简单的并且灵活的。
<br />
什么是函数？
<br />如同数学界，函数function即代表了求值。然而，从另一个角度来讲，函数function也是值：
g = f(x)
我们认为g是一个值，来自f函数的计算，输入是x。然而，我们可以把值g作为一个函数，输入y，再次进行求值：
v = g(y)
把函数function赋予值的定位，可以使计算充满了灵活：
v = f(x)(y) = k(f, x, y)
<br />
什么是柯里化Currying？
<br />f(x)(y)就是柯里化：使用函数f，输入x，计算，获得一个新的函数，再次输入y，计算，获取结果。f(x)(y)(z)(a)(b)(c)，你完全可以写这样的函数。每次进行一次计算时，都返回一个新的函数。当然，你也可以写成这样的方式g(x, y, z, a, b, c)。
function f (x) {
return function (y) {
return function (z) {
return function (a) {
return function (b) {
return function (c) {
console.log(x + y + z + a + b + c);
};
};
};
};
};
}
计算6个数字相加为什么要费这么大的周折？原因在于可以获得拥有内部记忆的函数: g = f(1)可以获得一个新的函数g。可以使用g编写多种不同的求值组合，而使第一个输入始终是1:
g(2)(3)(4)(5)(6);
g(3)(3)(4)(5)(6);
g(9)(9)(1)(2)(3);
<br />
什么是闭包Closure？
<br />上边的函数就是闭包，确切的说，利用柯里化机制的函数function就是闭包函数。通过柯里化，获取一个拥有记忆功能的函数，简化后续的多种计算操作，这就是闭包。
function move(start) {
var pos = start;
return function () {
console.log('Move to ' + (pos += 2) + '.');
}
}
var move_next = move(6);
move_next(); // Move to 8.
move_next(); // Move to 10.
<br />
进阶：记忆
<br />下面我们来看一下经典的缓存函数。开始有两个输入参数，一个是数组sets，一个是求值函数f：
function memorize(sets, f) {
var cache = {};
return function (x) {
console.log('cache: %j', cache);
return x in cache
? cache[x]
: cache[x] = f(sets[x]);
}
}
首先，我们在memorize的内部空间放置了一个记忆单元：cache，是一个Object类型，这样我们就可以用来存储任何我们想要的数据。Object类型可以看做是简化并且统一版的C语言中的struct：不需要考虑链接，不需要考虑类型，解释器会为你完成。
接下来，我们运用柯里化返回一个函数。这个函数有一个输入参数，指定了sets数组中的第几项进行计算。我们首先使用console.log打印当时内部空间的记忆单元cache的值，然后判断输入参数是不是在cache的键中。如果已经存在，直接返回记忆的内容，如果没有存在，使用函数f对输入参数sets[x]求值，然后把结果记忆到内部空间的记忆单元：cache中。
通过记忆，每次使用求值函数f计算后，都将结果保存在cache中，这样可以极大的降低重复计算：
var g = memorize([1000, 2000, 3000], function (x) { return x * x; });
g(0); // cache: {}，计算1000*1000
g(0); // cache: {"0":1000000}，来自记忆
g(0); // cache: {"0":1000000}，来自记忆
g(0); // cache: {"0":1000000}，来自记忆
g(1); // cache: {"0":1000000}，计算2000*2000
g(1); // cache: {"0":1000000, "1":4000000}，来自记忆
g(1); // cache: {"0":1000000, "1":4000000}，来自记忆
<br />
进阶：让函数循环起来
<br />我们已经看到了柯里化(闭包)的好处和妙处，同时这些也都是函数function概念帮助我们完成了一系列繁琐的工作。下面我们将把函数function运用到循环中，进一步了解函数的好处和妙处。
function map(sets, f) {
var i = 0, len = sets.length, result = [], val;
while (i < len) {
val = f(sets[i]);
result.push(val);
++i;
}
return result;
}
函数map使用两个输入参数：一个数组sets，一个求值函数f。
首先，我们计算数组sets的长度，设定一个位置符i。然后对sets进行循环的操作，把其中的sets[i]进行求值，然后压入result中，最后将result返回。
通过这样的设定，我们使函数f在循环中运转。我们还可以进一步，再放入一个条件函数，只有条件成功的时候才进行求值：
function map(sets, condf, f) {
var i = 0, len = sets.length, result = [], val, set;
while (i < len) {
set = sets[i];
if (condf(set)) {
val = f(set);
result.push(val);
}
++i;
}
return result;
}
上边我们刚刚讨论了柯里化，所以把这个函数改一改，变成柯里化：
function map(sets, f) {
return function (condf) {
var i = 0, len = sets.length, result = [], val, set;
while (i < len) {
set = sets[i];
if (condf(set)) {
val = f(set);
result.push(val);
}
++i;
}
return result;
}
}
现在，函数map在循环中进一步增加了灵活性，我们可以这样方便的使用：
var mymap = map([1,2,3,4,5,6], function (set) { return set + 1; });
mymap(function (set) { return set % 2 === 0 }); // 偶数
mymap(function (set) { return set > 9 }); // 大于9
// 如果你熟悉Ecmascript 6，那么代码会非常有趣
var mymap = map([1,2,3,4,5,6], set => set + 1);
mymap(set => set % 2 === 0); // 偶数
mymap(set => set > 9 ); // 大于9
