Question

请接受我对成为JS初学者的道歉。我停止研究JS，关于传递参数时函数内部发生的正确答案是什么，让我们通过代码片段进行描述。

function myFun(x){
   console.log(arguments);
   console.log(x);
}
myFun(1);

根据上面的例子，发生的正确行动是：

示例1

when passing calling myFun(1) this will do : 
    function myFunction(x){
    var x = 1
    }

或 示例2

 function myFunction(x,y,z){
    x=arguments[0];
    y=arguments[1];
    z=arguments[2];
    }

根据main documentation，我没有找到所需的方法，我在参数对象创建过程中发现的是：

重复indx＆gt; = 0，设val是0起源列表位置indx的args元素。

我无法指定这与分配值的过程有关。

所以根据以上所述，

哪种解决方案正确？ 如何为参数分配参数？如果我们将值1作为参数传递，在函数范围中，1将被赋值给x还是1将被赋值给参数Object？

Answer 1

让我们说你有这样的功能：

function oneParam(x)
{
    console.log(arguments[0]);
    console.log(x);
}

调用它：oneParam(1);将传入的第一个参数放入arguments数组中。如果运行上面的代码，您将获得两次打印的相同值，因为它们是相同的。

1

现在让我们来看一个有多个参数的函数：

function myFunction(x,y,z)
{
    console.log(arguments[0], arguments[1], arguments[2]);

    x=arguments[0];
    y=arguments[1];
    z=arguments[2];

    console.log(x, y, z);
}

您会注意到，调用此函数（如myFunction("a","b","c");）将产生两个类似的输出。

a b c

基本上，这两种情况都是正确的。只是取决于你在调用函数时传入的内容。

编辑：为了澄清，参数对象将包含您传入的所有参数。这些参数将按顺序分配给函数签名中的命名变量。

所以你甚至可以拥有oneParam(1, 2, 3);并且arguments对象将拥有所有三个参数，但只有第一个参数1将被赋值给函数变量x。

fiddle here

Answer 2

如果您在函数中为参数命名如下：

function myFunction(x,y,z)
{
    console.log(x, y, z);
}

然后直接通过他们的名字访问它们会更好如果您在定义函数时不知道参数的数量，则可以使用argumens，例如Math.max()。

ES6比以前更容易使用参数，但它非常相似。请记住，arguments 不是数组，因此如果您想要访问所有数组的方法，则必须将其转换为数组。

function myFunc_ES6() {
    var args = [...arguments];
    // or
    //var args = Object.values(arguments)

    args.forEach(arg => console.log(arg));
}

function myFunc_ES5() {
    var args = Array.prototype.slice.apply(arguments);

    args.forEach(function(arg) {
        console.log(arg);
    });
}

myFunc_ES6(1,2,3,4);
myFunc_ES5(6,7,8,9);

Answer 3

参数对象   JavaScript函数有一个名为arguments对象的内置对象。

参数对象包含函数时使用的参数数组   被调用（被调用）。

如https://www.w3schools.com/js/js_function_parameters.asp

中所述当您不想明确指定函数的参数时，可以使用

arguments。这在许多情况下都很有用。例如

不同参数的不同行为计数

function foo() {
   if(arguments.length == 2){
     // do something
   }else{
     //do something else
   }
}

扩展一些方法

var oldMethod = Object.prototype.method;
Object.prototype.method = function() {
 // some extended functionality
 // then call the original
 oldMethod.apply(this, arguments);
}

使用未知数量的参数

function average(){
  var i, s=0;

  if(!arguments.length){
     throw('Division by zero.');
  }

  for(i=0;i<arguments.length;i++){
    s+=arguments[i];
  }
  return s/arguments.length;
}

关于分配值的方式，如果我们有一个功能：

function foo(x){}

无论你传递什么作为参数，这都将是真的：

x === arguemnts[0]

这几乎就像x在参数中引用了staticaLly，因为对参数的操作也会改变refs：

arguments[0]++;
x === arguments[0] // true

但是删除参数[0]不会修改显式参数值

delete arguments[0]
x !== undefined

当我们在函数本身内传递参数时会发生什么？

3 个答案: