写在前面
不知不觉写到第10篇了。这篇写起来很忐忑，终于和高级搭上边了（呵呵），这篇我们 主要 说一下 JS 方法的部分高级用法（我知道的），笔者水平有限，难免有错。废话不多少，进入正文。
初始化
我们在看一些别人写的优秀的代码，特别是组件时，我们经常能发现有init或initializa这样的方法，它一般执行的都是初始化。那初始化一般都有几种呢，我们来一一介绍：
初始化对象
初始化对象，顾名思义，就是对带着一堆具体逻辑的对象进行初始化。直接上代码：
```javascript
var Wr = {
name: "WeiRan",
age: 21,
init: function() {
// body ...
console.log("初始化完成！");
}
}
Wr.init(); //初始化完成！
```
这种方法，有个弊端就是可能会污染全局作用域。这样有时候就可以采用另一种方法来初始化：
```javascript
({
name: "WeiRan",
age: 21,
init: function() {
// body ...
console.log("初始化完成！");
}
}).init(); //初始化完成！
```
这种方法的有点和上篇所说的即时函数的有点是相同的：可以在执行一次性的初始化任务时保护全局命名空间，如果初始化任务更加复杂，他会使整个初始化过程显得更有结构化。
值得注意的是，这种模式主要适用于一次性的任务，而且在init完毕以后也没有该对象的访问（如果想有，也可以有，在init方法底部加个return this即可）
初始化分支
初始化分支也叫做加载时分支[load-time branching] ,是一种优化模式。当知道某些属性在整个程序生命周期中都不会发生变化时，该模式就显得很重要了。浏览器特性嗅探就是一个典型的例子，通常情况下在site上写JavaScript要考虑到兼容性，例如addEventListener在早期的IE上就是不支持的，在IE上支持的是attachEvent（更早的甚至是on+type），而如果我们每次绑定事件的时候都要做个判断，这样会产生大量的冗[rǒng]余代码，但是初始化分支可以很好的解决这个问题。代码如下：
```javascript
//初始化分支
if(typeof window.addEventListener === "function"){
utils.addListener = function(el, type, fn){
el.addEventListener(type, fn, false);
}
utils.removeListener = function(el, type, fn){
el.removeEventListener(type, fn, false);
}
}
// if IE
else if(typeof document.attachEvent === "function"){
utils.addListener = function(el, type, fn){
el.attachEvent('on' + type, fn);
}
utils.removeListener = function(el, type, fn){
el.detachEvent('on' + type, fn);
}
}
//long long ago Browser
else{
utils.addListener = function(el, type, fn){
el['on' + type] = fn;
}
utils.removeListener = function(el, type, fn){
el['on' + type] = null;
}
}
```
初始化模块
在上一篇中，我写了一个叫做暴露接口的用法，在 @北川 的纠正下，我发现我写的不是很严谨，对于用法也写的太含糊，特意去详细了解了下 Module模式。在这里谢谢北川的指正。关于详细的Module模式，我会在后面专门写一篇。在回到我们的正文，在模块化编程中（利用r.js 或者 seaJS），我们经常要对某个模块进行初始化，而这时，这种模式就显得更有用了。代码如下：
```javascript
function Wr(n){
var name;
return {
init : function(n){
name = n;
},
getName : function(){
console.log(name);
}
}
}
var wr1 = new Wr();
wr1.init("Weiran");
wr1.getName(); //WeiRan
```
上面init很简单，但是具体到工作中，可能初始化做的就不会这么简单，总之它很好的提高了模块的可扩展性。让我们的代码结构更加清晰。
缓存函数结果
对于一些操作非常非常复杂的函数，我们没必要每次都去真的执行一遍。举个例子，我们在百度搜索一个关键词，百度并不是真的去搜一遍，而是去看以前有木有查过，然后才返回结果（这就是有时候，百度的结果有点旧了）。在函数中也是一样，对于逻辑极度复杂，但是参数变化不大的函数（结果也不经常变化），我们可以缓存计算结果。代码如下：
```javascript
var fun1 = function(param){
if(!fun1.cache[param]){
var result = {};
// 复杂的逻辑 ...
fun1.cache[param] = result; //把计算结果缓存
}
return fun1.cache[param];
}
```
上面的代码假定该函数只需要一个参数，如果有更多及更复杂的参数，通常的做法是将参数序列化。代码如下：
```javascript
var func2 = function(){
//JSON 序列化
var cacheKey = JSON.stringify(Array.prototype.slice.call(arguments)),
result;
if(!func2.cache[cacheKey]){
result = {};
// 复杂的逻辑
func2.cache[cacheKey] = result;
}
return func2.cache[cacheKey];
};
func2.cache = {};
```
值得注意的是，在JSON序列化的过程中，因为本质上都是被序列化成了字符串，所有对象也被序列化成了字符串，对于两个不同对象但具有相同的属性，这两个对象就会被当成同一个，共享一条缓存条目。
柯里化
柯里化（curry），貌似很高端的样子，那他是什么呢，我们先假设有一个需求（这里我借用腾讯的案例。）：
假设在实现一个计算每月花费的函数, 每天结束前我们都要记录今天花了多少钱, 但我们只关心月底的花费总值, 无需每天都计算一次.
如果使用curry怎么实现，废话不多说，直接上代码：
```javascript
var curry = function(fn){
var args = [];
return function(){
if(arguments.length === 0){
return fn.apply(this,args);
}
args.push.apply(args, arguments);
return fn;
}
}
var exc = curry(function(){
var nums = [].slice.call(arguments),
result = 0;
nums.forEach(function(val){
result += val;
});
return result;
});
exc(500);
exc(1000);
console.log(exc()); //1500
```
初看上去还是有点绕的，我们切开来看，我们传给curry一个匿名函数，curry返回一个经过处理的函数。而重点来了，我们来看curry是怎么处理的，首先是个判断，判断这个函数接受的参数是否是空[arguments.length === 0] 如果不为空，把当前的参数push到args里面去，这里要注意的是curry 返回的是一个方法，所以就形成了一个闭包，而闭包的一个特性就是可以访问返回他的函数的变量和方法，故这个方法可以改变args的值（把当前参数push到返回他的函数的args里去），如果为空的话，他才会执行fn并把参数数组通过apply的形式传给fn。
这种方式的最大好处就是可以延迟到最后一刻才一起计算, 在很多场合可以避免无谓的计算, 节省性能, 也是实现惰性求值的一种方案.
柯里化就是用闭包原理实现函数参数的合并，然后再运行函数。
如果以上还不够明确，我们在来看一个例子：
```javascript
//Curry
var curry = function(fn){
var slice = Array.prototype.slice,
storedArgs = slice.call(arguments, 1);
return function(){
var newArgs = slice.call(arguments);
var args = storedArgs.concat(newArgs);
return fn.apply(null, args);
};
}
var result = curry(function(x, y){
return x + y;
}, 5)(10);
console.log(result); //15
```
上面的代码，需要注意的是 storedArgs = slice.call(arguments, 1) 这段代码的意思是把fn之外的参数存储起来（我们第一次传个curry的那个5），然后我们调用这个经过curry处理过后的函数时，他会把我们新传的参数和原来我们传的那个5结合组成新的参数数组进行处理[var args = storedArgs.concat(newArgs)]，具体处理的代码是fn.apply(null, args)。
当我们发现正在调用一个函数，并且传递的大部分参数都是相同的，那么该函数使用curry化是一个很好的方案。可以通过将一个curry化，从而动态产生一个新的函数，这个新的函数会保存重复的参数（因此不必每次都传递这些参数），并且还会使用预填充原始函数所期望的完整参数列表。
结语
本来准备也把反柯里化写了，奈何最后发现，对于这东西，自己还不知道怎么把它完整的表诉清楚，可能还是自己没完全吃透吧，所以也暂时不写了，JS的路还很长啊。
如果你在文中发现错误，欢迎指正。