1

当有多个参数时，我无法理解如何将信息从第二个函数返回到第一个函数。现在我知道以下代码有效。

function One() {
    var newVal = 0;
    newVal = Too(newVal);
    console.log(newVal);
}

function Too(arg) {
    ++arg;
    return arg;
}

但是，如果我尝试通过添加参数和 setinterval 来使事情复杂化怎么办。

function One() {
    var newVal = 0;
    var z = 3;
    var y = 3;
    var x = 1;
    newVal = Too(newVal);
    var StopAI2 = setInterval(function () {
        Too(x, y, z, newVal)
    }, 100);
}

function Too(Xarg, Yarg, Zarg, newValarg) {
    Xarg*Xarg;
    Yarg*Yarg;
    Zarg*Zarg;
    ++newValarg;
    return newValarg;
}

我不确定如何处理 newVal = 代码行。我只想返回 newVal 而不是 x,y,z。

4

2 回答 2

3

这就是我认为您要问的问题：

当只传递一个参数时，如何对函数的第四个参数进行操作？

这个问题的答案是这样的：

如果要对函数的第 4 个参数进行操作，则必须将至少 4 个参数传递给函数。

有几种方法可以让您以不同的方式解决问题。

#1

如果有一个参数总是必要的，请确保它是第一个参数：

 function Too(mandatoryArg, optionalArg1, optionalArg2) {
    alert(++mandatoryArg);
    if (optionalArg1) {
        alert(++optionalArg1);
    }
}

#2

为所有未定义或未知的参数传递占位符值。

您可以使用null,undefined或''.

alert(Too(null, null, 4));

function Too(optArg1, optArg2, mandatoryArg) {
    alert(++mandatoryArg);
}

#3

根据参数的数量做出决定：

function Too(optArg1, optArg2, optArg3) {
    var numArgs = arguments.length;
    if (numArgs === 1) {
        alert(++optArg1);
    }
    if (numArgs === 3) {
        alert(++optArg3);
    }
}

编辑

“这会更新第一个函数中的变量吗？”

让我们用一个实际的例子来展示一些东西：

function one() {
    var a = 0;
    var b = 25;
    var c = 50;
    var d = -1;

    d = two(a, b, c);

    alert("a: " + a);
    alert("b: " + b);
    alert("c: " + c);
    alert("d: " + d);
}

function two(a, b, c) {
    ++a;
    ++b;
    ++c;
    if (arguments.length === 1) {
        return a;
    }
    if (arguments.length === 3) {
        return c;
    }
}

调用one()将导致以下警报：

a: 0
b: 25
c: 50
d: 51

d在函数one()中仅修改 的值。

那是因为分配了two()d的返回值。

two()内部对 , 和 ,a的b更改对one()内部的,和 , 和内部的值没有影响。 cabc

即使two()的参数被命名为a、b和 也是如此c。

这是上面代码的一个小提琴。

编辑#2

这是创建移动游戏对象的函数的一种方法：

var FORWARD = 0;
var BACK = 1;
var LEFT = 2;
var RIGHT = 3;

// use an object with three values to represent a position
var pos = {
    x: 0,
    y: 0,
    z: 0
};

pos = moveObject(pos, FORWARD);
printPosition(pos);

pos = moveObject(pos, LEFT);
printPosition(pos);

pos = moveObject(pos, FORWARD);
printPosition(pos);

pos = moveObject(pos, LEFT);
printPosition(pos);

// invoking moveObject() with one argument
// will move the object forward

pos = moveObject(pos);
printPosition(pos);

function moveObject(position, direction) {

    // assume FORWARD if no direction is specified
    if (typeof direction === 'undefined') {
        direction = FORWARD;
    }

    if (direction === FORWARD) {
        ++position.z;
    }
    if (direction === BACK) {
        --position.z;
    }
    if (direction === LEFT) {
        --position.x;
    }
    if (direction === RIGHT) {
        ++position.x;
    }

    return position;
}

function printPosition(pos) {
    alert(pos.x + ", " + pos.y + ", " + pos.z);
}

这是一个小提琴，显示了另一种方法的工作演示。

于 2013-10-18T01:33:05.027 回答
2

这里有两个概念在起作用。

1. 可变数量的函数参数（或可选参数）。

如果你打算用不同数量的参数调用同一个函数（这最终会导致一个令人头疼的世界），你需要确定（在函数内部）这个函数是如何被调用的。您可以arguments在每个函数中使用可用的对象：

function Too() {
  if (arguments.length == 4) {
    arguments[0]*arguments[0];
    arguments[1]*arguments[1];
    arguments[2]*arguments[2];
    return ++arguments[3];
  } else if (arguments.length == 1) {
    return ++arguments[0];
  } else {
    // you decide what to do here
  }
}

2. 异步代码执行。

实现Too间隔到期时调用的，One完成后执行良好并返回。如果你想Too影响newVal变量，然后以某种方式获得这个新值， - 使newVal变量成为全局变量。

于 2013-10-18T01:46:06.867 回答