介绍下js中函数内置类数组对象：arguments

在js中一切都是对象，连函数也是对象，函数名其实是引用函数定义对象的变量，我们介绍下js中函数内置类数组对象：arguments。

什么是arguments？

这个函数体内的arguments非常特殊，实际上是所在函数的一个内置类数组对象，可以用数组的[i]和.length。

每个函数都有一个arguments属性，表示函数的实参集合，这里的实参是重点，就是执行函数时实际传入的参数的集合。arguments不是数组而是一个对象，但它和数组很相似，所以通常称为类数组对象，以后看到类数组其实就表示arguments。arguments对象不能显式的创建，它只有在函数开始时才可用。

arguments有length属性，arguments.length 为函数实参个数，可以用arguments[length]显示调用参数：

function func(){
       for(var i=0;i<arguments.length;i++){
       console.log(arguments[i]);
   }     
}

arguments的应用

arguments.callee为引用函数自身。我们可以借用arguments.length可以来查看实参和形参的个数是否一致。

function add(a, b) { 
  var realLen = arguments.length; 
  console.log("realLen:", arguments.length); 
  var len = add.length; 
  console.log("len:", add.length); 
  if (realLen == len) { 
    console.log('实参和形参个数一致'); 
  } else { 
    console.log('实参和形参个数不一致'); 
  } 
}; 
add(1,2,3,6,8);

2．我们可以借用arguments.callee来让匿名函数实现递归

var sum = function(n) { 
    if(n == 1) { 
        return 1; 
  } else { 
    return n + arguments.callee(n-1); 
　} 
} 
console.log("sum =", sum(5));

3.编写一个函数求传入的若干个数字（不能用数组显示传入）的和

function add() { 
    //console.log("length", arguments.length); 
    var len = arguments.length; 
    var sum = 0; 
    for (var i = 0; i < len; ++i) { 
        sum += arguments[i]; 
    } 
    return sum; 
}; 
add(1,2,3,6,8);

4.如何将arguments转成了一个实实在在的数组

Array.prototype.slice.call(arguments)能将具有length属性的对象转成数组，

首先我们看看call是干啥的，举个例子：

ar obj1={
      name:"java"
  }
  window.name="javascript";
  var func=function(){
      console.log(this.name);
  }
func();  //javasript
func.call(obj1); //java

我们可以很清楚的看到，call的一个作用是可以改变函数运行的作用域，func中的this指向了obj1。

那Array.prototype.slice.call(arguments)是干啥的呢，首先我们猜测Array.prototype.slice是一个方法，将它call(arguments)之后，Array.prototype.slice中的this就指向了arguments对象了。

其实Array.slice是一个数组复制函数，它接受两个参数(strat,[end]);从下标为start复制到下标为end，举个栗子：

var numArr=[1,2,3,4,5];
console.log(numArr.slice(0,4)); //[1,2,3,4]
console.log(numArr.slice()); //[1,2,3,4,5]
console.log(numArr.slice(1)) //[2,3,4,5]

我们可以大胆的猜测一下slice函数的内部实现：
Array.prototype.slice = function(start,end){
      var result = new Array();
      start = start || 0;
      end = end || this.length; //this指向调用的对象，当用了call后，能够改变this的指向，也就是指向传进来的对象，这是关键
      for(var i = start; i < end; i++){
           result.push(this[i]);
      }
      return result;
}

注意当中的result.push(this[i]),当Array.prototype.slice.call(arguments)后，就变成了result.push(arguments[i])，这样就将arguments转成了一个实实在在的数组了。