媒介

在日常平凡的开辟中，经常会碰到一些特殊情况，就须要一些招式来应对。这里总结一下本身常用到的一些小招式，有不足迎接人人指出。

模块

    var fuc1 = (function() {
        var a = 'hello ';
        return function(str) {
            return a + str;
        }
    })()
    fuc1('world'); // hello world

模块情势的平常情势是：一个定义了私有变量和函数；运用闭包建立能够接见私有变量和函数的特权函数；末了返回这个特权函数，或许把它们保留到一个可接见的处所。

该招式有以下运用场景

谐和异步

代码须要在两个异步fuc1与fuc2都实行完毕后再实行，

var manager = (function() {
    var count = 0;
    return function() {
        if(++count === 2){
            // logic 3
        }
    }
})()
function fuc1() {
    //...
}
function fuc2() {
    //...
}
setTimeout(function() {
   fuc1();
   manager();
}, 10)
setTimeout(function() {
   fuc2();
   manager();
}, 10)

兼容测试

var createXHR = (function () {
    if(typeof XMLHttpRequest != "undefined") {
        return function () {
            return new XMLHttpRequest();
        }
    }else if(typeof ActiveXObject != "undefined") {
        return function () {
            if(typeof arguments.callee.activeXString != "string") {
                var versions = ["MSXML2.XMLHttp.6.0", "MSXML2.XMLHttp.3.0", "MSXML2.XMLHttp"],
                    i,len;
                for(1 = 0, len = versions.length; i < len; i++){
                    try{
                        new ActiveXObject(versions[i]);
                        arguments.callee.activeXString = versions[i];
                        break;
                    }catch(ex){
                        // ...
                    }
                }
            }
            return new ActiveXObject(arguments.callee.activeXString);
        }
    }else{
        return function() {
            throw new Error("NO XHR object available.");
        }
    }
})();

运用私有变量

var parse = (function() {
    var config = ['I', 'II', 'III', 'IV'];
    return function(num) {
        return config[num - 1]
    }
})()
parse(1); // I
parse(4); // IV

柯里化

柯里化听起来很嵬峨上，但是也就是Currying的音译，万万别被称号吓跑了。
它是把接收多个参数的函数中的参数拆分红两次挪用来通报并返回效果的新函数。
举一个简朴的例子明白一下：

var add = function(a, b) {
    return a + b
}
add(1, 2) // 3

var currying = function(a) {
    return function(b) {
        return a + b
    }
}
currying(1)(2) // 3

add 为 接收多个参数的函数,currying是将add中的参数分两次挪用传入并返回效果的新函数。

细致想一想，它实际上是模块的衍生招式。模块的私有变量是预先定义好的，而柯里化是保留第一次挪用时传入的参数为私有变量。因而它俩的区别是私有变量定义机遇差别。

下面是一个运用柯里化完成的累加要领

var currying = function (fn) {
    var args = [];
    return function () {
        var innerArgs = Array.prototype.slice.call(arguments);
        if(innerArgs.length === 0){
            return fn.apply(null, args)
        }
        args = args.concat(innerArgs);
        return arguments.callee;
    }
}

var mutil = function () {
    var num = 0, i = 0;
    while(arguments[i]){
        num += arguments[i++]
    }
    return num
}

var add = currying(mutil);

add(1,2)(3);
add(4);

add();  // 10

函数撙节

某些代码不能够在没有中断的情况下一连反复实行，一切就须要撙节。比方：拖动某DOM元素时，须要动态转变元素的 x y ,就须要用到撙节函数了。

function throttle(method, delay) {
    var timer = null;
    return function () {
        var that = this, args = arguments;
        clearTimeout(method.tId);
        timer = setTimeout(function () {
            method.apply(that, args);
            clearTimeout(timer);
        }, delay);
    }
}
window.onresize = throttle(resizeHandle, 50)

运用该函数时你会发明一个题目：不停拖动元素的过程当中元素是不动的，只要停留一下元素才随着动。
如许的体验很蹩脚，为了进步机能、改良体验，须要晋级一下撙节函数。设置一个最大时候距离来确保在拖动的过程当中，元素能够追随挪动。

function throttle(method, context, delay, maxInterval) {
    var _start,_diff,timer;
    return function () {
        var that = this,
            args = arguments,
            _now  = +new Date();
        clearTimeout(timer);
        _start || (_start = _now);
        if(_now - _start >= maxInterval){
            method.apply(that, args)
        }else{
            timer = setTimeout(function () {
                method.apply(that, args)
            }, delay)
        }
    }
}
window.onresize = throttle(resizeHandle, 50, 100)

耽误加载处置惩罚

在营业中经常会碰到一些不须要同步处置惩罚的，又比较耗时的逻辑。关于这些逻辑能够采纳数据分块（array chunking）的手艺，小块小块地处置惩罚数组，一般每次一小块。能够建立一个“待办事项”行列，然后运用定时器逐一掏出“事项”，接着设置另一个定时器。

function chunk(array, process, context) {
    setTimeout(function() {
        var item = array.shift();
        process.call(context, item);

        if(array.length > 0){
            setTimeout(arguments.callee, 100);
        }
    }, 100)
}

影象函数

函数能够将先前操纵的效果记录在某个对象里，从而防止反复运算，比方盘算阶乘函数。

function memoizer(memory, handle) {
    return function (n) {
        var result = memory[n],
            recur  = arguments.callee;
        // 已运算过则直接返回
        if(!result){
            result = handle(recur ,n);
            memory[n] = result;
        }
        return result;
    }
}

var memory    = [1, 1],
    factorial = memoizer(memory, function (recur, n) {
        return n * recur(n - 1)
    });

factorial(4);

console.log(memory);  // [1, 1, 2, 6, 24]

（未完待续……）