Array.prototype.push.apply(a,b)和Array.prototype.slice.call(arguments)

Array.prototype.push.apply(a,b)

时常看到在操作数组的时候有这样的写法：

var a = [1,2,3];
var b = [4,5,6];

a.push.apply(a, b);

console.log(a) //[1,2,3,4,5,6]

其实这样的写法等价于：

var a = [1,2,3];
var b = [4,5,6];

Array.prototype.push.apply(a, b);

console.log(a) //[1,2,3,4,5,6]

这样写法等价的原因是因为在实例上寻找属性的时候，现在这个实例自己身上找，如果找不到，就根据内部指针__proto__随着原型链往上找，直到找到这个属性。

在这里就是寻找push方法，两种写法最后找到的都是Array构造函数对应的prototype的原生方法push。所以说两种写法是等价的。

但是为什么要使用a.push.apply(a,b);这种写法呢？为什么不直接使用push()？

如果直接push：

var a = [1,2,3];
var b = [4,5,6];

a.push(b);

console.log(a) //[1, 2, 3, Array(3)]

这样就看出来区别了，原生push方法接受的参数是一个参数列表，它不会自动把数组扩展成参数列表，使用apply的写法可以将数组型参数扩展成参数列表，这样合并两个数组就可以直接传数组参数了。

但是合并数组为什么不直接使用Array.prototype.concat()呢？

因为concat不会改变原数组，concat会返回新数组，而上面apply这种写法直接改变数组a。

同理，Math.max和Math.min也可以使用apply这种写法来传入数组参数。

比如这样：

Math.max.apply(null,a)

这样就可以很方便的传入数组参数了。

Array.prototype.slice.call(arguments)

类似的还有这样的写法，MDN解释slice方法可以用来将一个类数组（Array-like）对象/集合转换成一个新数组。你只需将该方法绑定到这个对象上。 

所以可以使用slice将函数的参数变成一个数组，然后就可以当做数组来操作了。

Object.prototype.hasOwnProperty.call(object,prop)

类似还有这样的写法，这样写是因为js没有保护hasOwnProperty 属性名，hasOwnProperty 有可能被修改为其他方法，所以这样写可以调用到原生的Objext原型上的hasOwnProperty 方法。这样写等价于({}).hasOwnProperty.call(object,prop)

Object.prototype.toString.call()

这样的写法是为了判断一个变量是什么类型的数据：

var toString = Object.prototype.toString;

toString.call(123); //"[object Number]"
toString.call('abcdef'); //"[object String]"
toString.call(true); //"[object Boolean]"
toString.call([1, 2, 3, 4]); //"[object Array]"
toString.call({name:'wenzi', age:25}); //"[object Object]"
toString.call(function(){ console.log('this is function'); }); //"[object Function]"
toString.call(undefined); //"[object Undefined]"
toString.call(null); //"[object Null]"
toString.call(new Date()); //"[object Date]"
toString.call(/^[a-zA-Z]{5,20}$/); //"[object RegExp]"
toString.call(new Error()); //"[object Error]"

使用Object.prototype.toString.call()的方式来判断一个变量的类型是最准确的方法。