javascript对象arguments的学习笔记

//利用arguments对象可以实现重载，利用arguments.length可以获取函数的参数个数
//不需要明确指出参数名，就能访问它们
//arguments对象不能显式创建,只有函数开始时才可用
//并不是一个数组，访问单个参数的方式与访问数组元素的方式相同。
//索引 n 实际上是 arguments 对象的 0…n 属性的其中一个参数。
function h1(){
if(arguments.length==1){
alert(arguments[0]);
}
else if(arguments.length==2){
alert(arguments[0] + arguments[1]);
}
}


console.log(h1(1,2));




function ArgTest(a, b){
var i, s = "The ArgTest function expected ";
var numargs = arguments.length;     // 获取被传递参数的数值。
var expargs = ArgTest.length;       // 获取期望参数的数值。
if (expargs < 2)
s += expargs + " argument. ";
else
s += expargs + " arguments. ";
if (numargs < 2)
s += numargs + " was passed.";
else
s += numargs + " were passed.";
s += "\n\n"
for (i =0 ; i < numargs; i++){      // 获取参数内容。
s += "  Arg " + i + " = " + arguments[i] + "\n";
}
return(s);                          // 返回参数列表。
}


function format(string) {   


var args = arguments;   
//我们提供了一个模板字符串，你可以用”%1”到“%9”给返回值添加一个占位符。然后提供给九个其他参数插入
var pattern = new RegExp("%([1-" + arguments.length + "])", "g");   


return String(string).replace(pattern, function(match, index) {   


return args[index];   


});   


}; 
format("And the %1 want to know whose %2 you %3", "papers", "shirt", "wear");
//And the papers want to know whose shirt you wear






//虽然arguments对象不是一个真正的javascript数组，但是我们还是可以轻易的把它转换成标准的数据 ，然后进行数组操作。
var args = Array.prototype.slice.call(arguments);
//args变量现在就含有一个标准数组的对象




//这边附上一个makeFunc函数的定义。这个函数允许我们去提供一个函数引用和这个函数的所有参数。
//他将返回一个匿名函数去调用你规定的函数，也提供了匿名函数调用时所附带的参数。
function makeFunc(){
var args = Array.prototype.slice.call(arguments);
var func = args.shift();
return function(){
return func.apply(null,args.concat(Array.prototype.slice.call(arguments)));
}
}
//虽然makeFunc没有形参，但还是可以凭借arguments传递参数的；
var majorTom = makeFunc(format, "This is Major Tom to ground control. I’m %1.");




//可以这样调用上面的函数
majorTom("stepping through the door");   
majorTom("floating in a most peculiar way");
//“This is Major Tom to ground control. I’m stepping through the door.”   
//“This is Major Tom to ground control. I’m floating in a most peculiar way.”




//寻找传给的参数里面最大值
function max()
{
    //根据我上一篇日志，这已经是JavaScript内最小的数字了
    var m = Number.NEGATIVE_INFINITY;
    for(var i = 0; i < arguments.length; i++)
    {
        //只要有任何一个参数比m大，那么m就变成了这个参数的值
        if(arguments[i] > m)
            m = arguments[i];
    }
    return m;
}


console.log(max(0,5,7,2,44444));


//arguments的callee属性：
//arguments的callee属性是用来引用当前正在执行的函数，这对未命名的函数调用自身非常有好处。
var result = function(x){
    if(x<=1) return 1;
    return x*arguments.callee(x-1);
};
//这个方法实现的是阶乘
console.log(result(5))//120




//第一个参数是待摧毁的数组，其余的参数是待摧毁的值。


function destroyer(arr) { 
// Remove all the values 
var args = arguments;//这是所有传入的参数
//console.log(args);
return arr.filter(function(val){ 
//console.log(val);//val是传入参数第一个数组里面的值
//这里是对除传入的第一个参数进行循环，
for(var i=1;i<args.length;i++){ 
if(val == args[i]){ 
return false; 
}
}
return true; 
});
} 
destroyer([1, 2, 3, 1, 2, 3], 2, 3,1);




//避免将argument对象泄露出去，否则会造成性能的损失
//以下就是arguments泄露出去的例子
function getArgs() {
    return arguments;
}
function getArgs() {
    const args = [].slice.call(arguments);
    return args;
}
function getArgs() {
    const args = arguments;
    return function() {
        return args;
    };
}


/*
那就很好奇了，我们每次使用 arguments 时通常第一步都会将其转换为数组，
同时 arguments 使用不当还容易导致性能损失，那么为什么不将 arguments 直接设计成数组对象呢？
这需要从这门语言的一开始说起。arguments 在语言的早期就引入了，
当时的 Array 对象具有 4 个方法： toString、 join、 reverse 和 sort。
arguments 继承于 Object 的很大原因是不需要这四个方法。而现在，Array 添加了很多强大的方法，
比如 forEach、map、filter 等等。那为什么现在不在新的版本里让 arguments 重新继承自 Array呢？
其实 ES5 的草案中就包含这一点，但为了向前兼容，最终还是被委员会否决了。
*/


//在严格模式下，函数中的参数与 arguments 对象没有联系，修改一个值不会改变另一个值。
//严格模式下的例子
function foo(a) {
    "use strict";
    console.log(a, arguments[0]);
    a = 10;
    console.log(a, arguments[0]);
    arguments[0] = 20;
    console.log(a, arguments[0]);
}
foo(1);//1 1
   //10 1
    //10 20


//而在非严格模式下，两个会互相影响。下面是非严格模式
function foo(a) {
    console.log(a, arguments[0]);
    a = 10;
    console.log(a, arguments[0]);
    arguments[0] = 20;
    console.log(a, arguments[0]);
}
foo(1);//1 1
       //10 10
       //20 20
   
   


//下面是将参数从一个函数传递到另一个函数的推荐做法。
function foo() {
    var aa = bar.apply(this, arguments);
//当执行foo()方法时候就执行了bar()方法，还可以把foo里面的参数给带到bar里面去

}
function bar(a, b, c) {
    console.log(a)
console.log(b)
console.log(c)
}