鈎子（HOOK）函數

什么是鈎子函數？

鈎子函數是Windows消息處理機制的一部分，通過設置“鈎子”，應用程序可以在系統級對所有消息、事件進行過濾，訪問在正常情況下無法訪問的消息。鈎子的本質是一段用以處理系統消息的程序，通過系統調用，把它掛入系統 --- 百度百科的定義

我的理解是：鈎子函數可以 鈎住 我喜歡的東西（在window中就是我喜歡的消息），這應該就是鈎子函數叫鈎子函數的原因吧。。？

鈎子函數的意義（用處）在於：我寫了一個window程序，在程序中我寫了一段代碼（調用window的api來實現鈎子），這段代碼被系統通過系統調用，把其掛入系統中，然后我就可以對我感興趣的消息進行處理，

我寫的這段代碼包含有一個回調函數，當有我喜歡的消息發出時，這個回調函數就會執行，所以說，鈎子就是指的回調函數

下面是一個程序掛載全局鈎子從而被360攔截的例子（其實360也有鈎子，不然怎么知道別人要掛載鈎子呢？即360可以攔截“掛載鈎子”的消息。這個彈窗就是在360的鈎子函數中創建的）

那么對於前端，什么是鈎子函數呢？

對於前端來說，鈎子函數就是指再所有函數執行前，我先執行了的函數，即 鈎住 我感興趣的函數，只要它執行，我就先執行。此概念（或者說現象）跟AOP（面向切面編程）很像

一個鈎子函數的例子

function Hooks(){
    return {
        initEnv:function () {
            Function.prototype.hook = function (realFunc,hookFunc,context,funcName) {
                var _context = null; //函數上下文
                var _funcName = null; //函數名

                _context = context || window;
                _funcName = funcName || getFuncName(this);
                _context[realFunc] = this;

                if(_context[_funcName].prototype && _context[_funcName].prototype.isHooked){
                    console.log("Already has been hooked,unhook first");
                    return false;
                }
                function getFuncName (fn) {
                    // 獲取函數名
                    var strFunc = fn.toString();
                    var _regex = /function\s+(\w+)\s*\(/;
                    var patten = strFunc.match(_regex);
                    if (patten) {
                        return patten[1];
                    };
                    return '';
                }
                try{
                    eval('_context[_funcName] = function '+_funcName+'(){\n'+
                        'var args = Array.prototype.slice.call(arguments,0);\n'+
                        'var obj = this;\n'+
                        'hookFunc.apply(obj,args)\n'+
                        'return _context[realFunc].apply(obj,args);\n'+
                        '};');
                    _context[_funcName].prototype.isHooked = true;
                    return true;
                }catch (e){
                    console.log("Hook failed,check the params.");
                    return false;
                }
            }
            Function.prototype.unhook = function (realFunc,funcName,context) {
                var _context = null;
                var _funcName = null;
                _context = context || window;
                _funcName = funcName;
                if (!_context[_funcName].prototype.isHooked)
                {
                    console.log("No function is hooked on");
                    return false;
                }
                _context[_funcName] = _context[realFunc];
                delete _context[realFunc];
                return true;
            }
        },
        cleanEnv:function () {
            if(Function.prototype.hasOwnProperty("hook")){
                delete Function.prototype.hook;
            }
            if(Function.prototype.hasOwnProperty("unhook")){
                delete Function.prototype.unhook;
            }
            return true;
        }
    };
}

var hook = Hooks();
hook.initEnv();

// 這個是要執行的正常的函數
function test(){
    alert('test');
}

// 這個是鈎子函數。此鈎子函數內心戲：
// 我只喜歡test函數，所以我必須出現在她前面（在她前面執行），這樣她才能看到我。
function hookFunc(){
    alert('hookFunc');
}

// hookFunc鈎住test
test.hook(test,hookFunc,window,"test");

window.onload = function(){
  // 由於鈎子函數hookFunc鈎住了test函數，所以test執行時，會先執行hookFunc。
  test();
}