1

I am having trouble understanding how to return information to the first function from the second when there are multiple arguments. Now I know the following code works.

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

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

But what if I try to complicate things by adding arguments and a 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;
}

I'm not sure what to do with the newVal = line of code. I only want to return the newVal not x,y,z.

Improve this question
8
  • you can use return ++arg;.Save one line. Commented Oct 18, 2013 at 1:17
  • newVal = Too(newVal); won't even do what you are intending. You aren't passing X, Y, or Z at all. Why not do something like this: newVal = Too(null, null, null, newVal); Commented Oct 18, 2013 at 1:20
  • I have some other code that i'm using with three.js but it's really long so I just tried to simplify it here. Some one had answerd my question but it's gone now they advised I use arguments.length-1 or some thing like that. Commented Oct 18, 2013 at 1:24
  • more of less i'm trying to return info to the first function from the second but there are multiple arguments and I just want to return 1. Commented Oct 18, 2013 at 1:25
  • @mattedgod so I just have to replace the arguments that aren't being passed back with null? Commented Oct 18, 2013 at 1:30

2 Answers 2

Reset to default
3

This is what I think you're trying to ask:

How can I operate on the 4th argument to a function when only one argument is passed?

The answer to that question is this:

If you want to operate on the 4th argument of a function, at least 4 arguments must be passed to the function.

There are a few ways you can approach your problem differently.

#1

If there's one argument that is always necessary, make sure it's the first argument:

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

#2

Pass placeholder values for all the undefined or unknown arguments.

You might use null, undefined, or ''.

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

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

#3

Make a decision based on the number of arguments:

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

EDIT

"Will this update a variable in the first function?"

Let's use an actual example that demonstrates something:

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;
    }
}

Invoking one() will cause the following alerts:

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

Only the value of d is modified in function one().

That's because d is assigned the return value of two().

The changes to a, b, and c, inside two() have no effect on the values of a, b, and c inside one().

This would be the case even if the arguments for two() were named a, b, and c.

Here's a fiddle with the code above.

EDIT #2

Here is one way you could create functions that move a game object:

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);
}

Here's a fiddle that shows a working demo of another approach.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

Will this update a variable in the first function? Sorry about not being able to clearly ask the question. Over all i'm just trying to figure out how to return info to the first function.
@JohnBob - I'll add a separate section to my answer to try to answer that question...
Ok I think i'm starting to understand. So no matter which parameter is returned the value will be appended to d?
@JohnBob - In this case, only the value of d will be modified in one(). That is because it will be assigned the return value of two(). The term "appended" does not apply here. The term "append" is generally used with strings (or maybe files) and it means to "add something to the end of something else".
2

There are two concepts that are at play here.

1 . Variable number of function parameters (or optional parameters).

If you are going to call the same function with different number of parameters (this will eventually lead to a world of headache), you need to determine (inside the function) how this function was called. You can use arguments object available inside each function:

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 . Asynchronous code execution.

Realize that Too which is called when interval expires, executes well after One completes and returns. If you want Too to affect newVal variable, and somehow get at this new value afterwards, - make newVal variable global.

Improve this answer

3 Comments

Yea that's what i'm trying to do. I'm going to explain further. Sorry if this dose not make any sense. I'm using three.js to make a simple game. I use function one to spawn an enemy then the set interval passes the info to the function that moves the enemy. My problem is I need to activate and deactivate sections of the function to move the enemy around. for example if it moves forward I need to deactivate the code that moves it backward. so they don't interfere with each other. If I use a global variable it works but then if more than one enemy is spawned they share moments.
I'm using if statements like if (spriteName.position.x > 100) { spriteName.position.x -= 10;} but at times the if statements conflict so i'm trying to use variable's to control the progression of what executes. like if (spriteName.position.x > 100 && newVal == 1) { spriteName.position.x -= 10;}. but it has to be a local variable or it will effect all the enemy's spawned. So i'm trying to pass it from the first function.
@JohnBob - I'll add a simple code example to my answer to demonstrate an easy way to move game objects...

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.