1. bind
   实现思路：将函数参数分两部分，一部分在执行 bind 时传入，一部分在执行函数是传入，最后使用 apply 执行函数
   细节修正：如果 bind 后的函数被当做构造函数，则绑定 this 指针；让新函数原型链继承原函数

Function.prototype.myBind = function (obj) {
    var func = this
    var args = Array.prototype.slice.call(arguments, 1)
    var returnFunc = function() {
        args = args.concat(Array.prototype.slice.call(arguments))
        return func.apply(this instanceof returnFunc ? this : obj, args)
    }
    var Dump = function (){}
    Dump.prototype = func.prototype
    returnFunc.prototype = new Dump()
    return returnFunc
}

1. call
   实现思路：将要执行的函数设置为对象的 fn 属性，使用 eval 关键字执行 fn 函数
   细节修正：执行完毕后删除对象的 fn 属性；为防止对象本来就具有 fn 属性，先把它原来的 fn 属性保存起来

Function.prototype.myCall = function (obj) {
    var obj = obj || window
    //var flag = false, temp
    //if (obj.hasOwnProperty('fn')){
    //  flag = true;
    //  temp = obj.fn
    //}
    obj.fn = this

    var args = []
    for (var i = 1; i < arguments.length; i++)
        args.push('arguments[' + i + ']')
    var result = eval('obj.fn(' + args + ')')
    delete obj.fn
    //if (flag) 
    //  obj.fn = temp
    return result
}

1. new
   实现思路：新建空对象、让对象的 __proto__ 指向函数的 prototype、执行构造函数、返回该对象
   细节修正：如果构造函数返回的值是对象或函数，则返回构造函数返回的对象或函数

function objectFactory() {
    var obj = new Object()
    var Constructor = Array.prototype.shift.call(arguments)
    obj.__proto__ = Constructor.prototyep
    var ret = Constructor.apply(obj, arguments)
    return (typeof ret === 'object' || typeof ret === 'function') ? ret : obj
}