ECMAScript 的 arguments 对象

arguments 对象

在函数代码中,使用特殊对象 arguments,开发者无需明确指出参数名,就能访问它们。

例如,在函数 sayHi() 中,第一个参数是 message。用 arguments[0] 也可以访问这个值,即第一个参数的值(第一个参数位于位置 0,第二个参数位于位置 1,依此类推)。

因此,无需明确命名参数,就可以重写函数:

function sayHi() {
  if (arguments[0] == "bye") {
    return;
  }

  alert(arguments[0]);
}

检测参数个数

还可以用 arguments 对象检测函数的参数个数,引用属性 arguments.length 即可。

下面的代码将输出每次调用函数使用的参数个数:

function howManyArgs() {
  alert(arguments.length);
}

howManyArgs("string", 45);
howManyArgs();
howManyArgs(12);

上面这段代码将依次显示 "2"、"0" 和 "1"。

注释:与其他程序设计语言不同,ECMAScript 不会验证传递给函数的参数个数是否等于函数定义的参数个数。开发者定义的函数都可以接受任意个数的参数(根据 Netscape 的文档,最多可接受 255 个),而不会引发任何错误。任何遗漏的参数都会以 undefined 传递给函数,多余的函数将忽略。

模拟函数重载

用 arguments 对象判断传递给函数的参数个数,即可模拟函数重载:

function doAdd() {
  if(arguments.length == 1) {
    alert(arguments[0] + 5);
  } else if(arguments.length == 2) {
    alert(arguments[0] + arguments[1]);
  }
}

doAdd(10);	//输出 "15"
doAdd(40, 20);	//输出 "60"

当只有一个参数时,doAdd() 函数给参数加 5。如果有两个参数,则会把两个参数相加,返回它们的和。所以,doAdd(10) 输出的是 "15",而 doAdd(40, 20) 输出的是 "60"。

虽然不如重载那么好,不过已足以避开 ECMAScript 的这种限制。



了解这个对象之前先来认识一下javascript的一些功能:

其实Javascript并没有重载函数的功能,但是Arguments对象能够模拟重载。Javascrip中每个函数都会有一个Arguments对象实例arguments,它引用着函数的实参,可以用数组下标的方式"[]"引用arguments的元素。arguments.length为函数实参个数,arguments.callee引用函数自身。

 

arguments他的特性和使用方法

特性:

arguments对象和Function是分不开的。因为arguments这个对象不能显式创建,arguments对象只有函数开始时才可用。

使用方法:

虽然arguments对象并不是一个数组,但是访问单个参数的方式与访问数组元素的方式相同

例如:

arguments[0], arguments[1],。。。。。。。。arguments[n],

 

在js中 不需要明确指出参数名,就能访问它们,例如:

function test() {
        var s = "";
        for (var i = 0; i < arguments.length; i++) {
            alert(arguments[i]);
            s += arguments[i] + ",";
        }
        return s;
    }
    test("name", "age")

输出结果:

name,age

 

我们知道每一个对象都有自己的属性,arguments对象也不例外,首先arguments的访问犹如Array对象一样,
用0到arguments.length-1来枚举每一个元素。


callee属性

下面我们来看看callee属性,返回正被执行的Function 对象,
也就是所指定的 Function 对象的正文。callee 属性是 arguments 对象的一个成员,仅当相关函数正在执行时才可用。
callee 属性的初始值就是正被执行的 Function 对象,这允许匿名的递归函数。

arguments对象中有一个非常有用的属性:callee。arguments.callee返回此arguments对象所在的当前函数引用。在使用函数递归调用时推荐使用arguments.callee代替函数名本身。

var sum = function (n) {
        if (1 == n) {
            return 1;
        } else {
            return n + arguments.callee(n - 1);
        }
    }
    alert(sum(6));

 通俗一点就是,arguments此对象大多用来针对同个方法多处调用并且传递参数个数不一样时进行使用。根据arguments的索引来判断执行的方法。

 

arguments 的用法和特性基本就是这么多了。可能callee属性用到的比较少。但是如果自己封装或者写一些js的时候 除了callee的东西基本都会用到。有不对的地方希望朋友们多多支出。大家共同进步。


Javascript没有重载函数的功能,但通过Arguments对象能够模拟重载。

Javascript的每个函数都会有一个Arguments对象实例arguments,它引用着函数的实参,它也有类似于数组的length属性。

(1)、arguments.length 为函数实参个数。

(2)、arguments.callee 引用函数自身。


1、借用arguments.length 可以来查看实参和形参的个数是否一致:

[javascript] view plain copy
  1. function add(a, b) {  
  2.   var realLen = arguments.length;  
  3.   console.log("realLen:", arguments.length);  
  4.   var len = add.length;  
  5.   console.log("len:", add.length);  
  6.   if (realLen == len) {  
  7.     console.log('实参和形参个数一致');  
  8.   } else {  
  9.     console.log('实参和形参个数不一致');  
  10.   }  
  11. };  
  12. add(1,2,3,6,8);  

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

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


好了现在让我们来实现文章开头提到的那个函数(求传入的若干个数字(不能用数组显示传入)的和)。

1、借用arguments.length属性来实现

[javascript] view plain copy
  1. function add() {  
  2.     //console.log("length", arguments.length);  
  3.     var len = arguments.length;  
  4.     var sum = 0;  
  5.     for (var i = 0; i < len; ++i) {  
  6.         sum += arguments[i];  
  7.     }  
  8.     return sum;  
  9. };  
  10. add(1,2,3,6,8);  

2、借用prototype属性来实现:

[javascript] view plain copy
  1. function add() {  
  2.   return Array.prototype.reduce.call(arguments, function(n1, n2) {  
  3.     return n1 + n2;  
  4.   });     
  5. };  
  6. add(1,2,3,6,8);  
arguments 的作用

一、实现重载

我们都知道,在JavaScript中并没有函数重载的功能,但是Arguments对象能够模拟重载,比如,最简单的一种方式,根据参数的个数进行重载。如下图

如上图代码所示,打印出来的就是2。这样就实现了函数重载。

当然,利用Arguments对象实现函数重载的方式可以有几种,除了根据参数的个数,还可以根据传入参数的类型来执行不同的操作,也可以利用参数中特殊的参数值来进行不同的操作。

二、同数组下标访问实参

JavaScript中每个函数都会有一个Arguments对象的实例arguments,它引用着函数的实参,而且可以用数组下标的方式来引用arguments的元素。如下图

如上图代码所示,arguments.length为函数实参的个数,要注意的是,arguments对象并不是一数组,它也不具有数据的所有方法,但是访问单个参数的方式与访问数组元素的方式相同,如上图代码中argument[0]...。

三、属性callee指向自己

对象都是有自己的属性和方法的,Arguments对象也是一样,callee就是它的方法,这个方法用的不多,很容易被我们忽略,它指向的是正在被执行的Function对象,最常用的例子就是用来做递归了。如下图

如上图代码所示,实现了6+5+4+3+2+1的操作。

最后总结:

在平时的封装和使用JS过程中,callee方法用的比较少,其它一般都会用到,现在,我在用几句话在来总结一下对arguments的理解:

1、arguments像数组,是一个Arguments对象实例。

2、arguments有length属性,代表传给函数的参数个数。

3、可以数组下标访问参数,如arguments[0],无数组其它方法。

4、存储的是实参不是行参。

5、可以使用callee属性调用自身。


发布了430 篇原创文章 · 获赞 415 · 访问量 925万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览