js相关hook

混淆中常见

    /*apply()方法*/
    function.apply(thisObj[, argArray])
    
    /*call()方法*/
    function.call(thisObj[, arg1[, arg2[, [,...argN]]]]);

this常用用法
1.在一般函数方法中使用 this 指代全局对象
2.作为对象方法调用，this 指代上级对象
3.作为构造函数调用，this 指代new 出的对象
4.apply 调用 ，apply方法作用是改变函数的调用对象，此方法的第一个参数为改变后调用这个函数的对象，this指代第一个参数

连续赋值

用内存和引用的思想理解

var a = {
    
    n: 1};
var b = a;  
a.x = a = {
    
    n: 2};
console.log(a.x);  
console.log(b.x);

我们知道js的赋值运算顺序永远都是从右往左的，不过由于“.”是优先级最高的运算符，所以这行代码先“计算”了a.x,给对象添加了一个x属性，也就是b指的，接着赋值从右往左，a重新指向，并把a重新指向的赋值 给x属性。
b指向的对象不变
a指向的对象变化了
结果 a:{n:2} b:{n:1,x: {n: 2}}

hook

在原先hook基础上，做了下优化处理

function Hooks() {
    
    
    return {
    
    
        initEnv: function() {
    
    
            function getFuncName(fn) {
    
    
                // 获取函数名
                var strFunc = fn.toString();
                var _regex = /function\s+(\w+)\s*\(/;
                var patten = strFunc.match(_regex);
                if (patten) {
    
    
                    return patten[1];
                }
                return '';
            }

            Function.prototype.hook = function(hookFunc, context) {
    
    
                var _context = context || window;
                var _funcName =  getFuncName(this);;
                if (!_funcName || _context[_funcName].prototype && _context[_funcName].prototype.isHooked) {
    
    
                    console.log("Already has been hooked,unhook first");
                    return false;
                }
                _context['realFunc_' + _funcName] = this;
                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_" + _funcName + "'].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(context) {
    
    
                var _context = context || window;;
                var _funcName = getFuncName(this);
                if (!_funcName || !_context[_funcName].prototype.isHooked) {
    
    
                    console.log("No function is hooked on");
                    return false;
                }
                _context[_funcName] = _context['realFunc_' + _funcName];
                delete _context['realFunc_' + _funcName];
                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() {
    
    
    console.log(arguments[0]);
}
// 这个是钩子函数
function hookFunc() {
    
    
    console.log("hookFunc");
}

// hookFunc钩住test
test.hook(hookFunc, window);
test.hook(hookFunc, window);
test("haha");
test.unhook();
test("haha");