Javascript check arguments for zero value

Question

I'm writing a function that checks if arguments are zero, and it doesn't seem to work correctly. Note: Using Chrome as my browser, but this code should be cross-browser supported.

// check all arguments, and make sure they aren't zero

function zeroCheck(arg1, arg2) {
    var i, argsLen = arguments.length;
    for (i = 0; i <= argsLen; i += 1) {
        if (arguments[i] === 0) {
            // This is where it doesn't behave as I expected
            arguments[i] = 1; // make arg1 = 1
        }
    }
    console.log(arg1); // arg1 = 0
}

zeroCheck(0, 2);

I was expecting arg1 to be equal to 1, but it is still equal to 0.

Answer 1

Though some browsers appear to work the way you want (Chrome and Firefox), it isn't obvious to me from the ECMAScript spec that it will always be this way. It makes it sounds like the arguments array is probably just a reference to the named arguments in non-strict mode and it specifically says that the two should have no connection to one another in strict mode (in other words what you want to do is specifically NOT supposed to work in strict mode).

You can see in this jsFiddle http://jsfiddle.net/jfriend00/bG5xp/ that Chrome appears to implement it as the spec describes. There is linkage between arguments[0] and arg1 in non strict mode and there is no linkage between them in strict mode. A careful reading of the spec doesn't say that javascript is required to have linkage between the two in non-strict mode, but it does make it sound like it is likely. If you wanted to rely on that and you were sure you never needed your code to work in strict mode, then you would have to test a bunch of browsers to see if the behavior you desire is widely supported.

It is also not clear from the spec if the arguments array is always meant to be modifiable though that seems more likely given that it's implemented with a javascript object (not an actual array).

The safe way to modify the arguments array is to make a copy first and modify the copy. That will, of course, not modify any named arguments. You could modify those manually if you wanted to.

A common way to make a copy of the arguments array is:

var args = Array.prototype.slice.call(arguments, 0);

One generally uses either the arguments array or the named arguments and not both since any named argument is also in a known position in the arguments array so you don't really need to worry about a named argument changing value when you modify the arguments array.

Answer 2

Try it like this. arg1 with value 0 evaluates to false/falsy, so you can use this shortcut boolean evaluation:

function zeroCheck(arg1,arg2) {
    arg1 = arg1 || 1; 
    console.log(arg1); //=> 1
}

zeroCheck(0,2);

A generic function to check for all arguments (returns an Array)

function zeroCheckArgs(args){
  return [].slice.call(args).map(function(a){return a || 1;});
}

//more conservative
function zeroCheckArgsAlt(args){
  var retArgs = [];
  for (var i=0;i<args.length;i+=1){
    retArgs.push(args[i] || 1);
  }
  return retArgs;
}

function some(){
  var args = zeroCheckArgs(arguments);
  console.log(args);
}

function someAlt(){
  var args = zeroCheckArgsAlt(arguments);
  console.log(args);
}

some(1,0,0,12,12,14,0,1);    //=> [1, 1, 1, 12, 12, 14, 1, 1]
someAlt(1,0,0,12,12,14,0,1); //=> [1, 1, 1, 12, 12, 14, 1, 1]

Answer 3

From the ECMA-262 spec:

"For non-strict mode functions the array index (defined in 15.4) named data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function’s execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object‘s properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values."

But if you read the technical details of how the arguments object is set I think you'll find it is based on how many arguments are actually passed to the function when it is called, not how many named arguments are declared, so using arguments and a loop to check the value of each named parameter might not work if they're not all passed in. Though in your case if you're testing specifically for 0 it should work since parameters that are not passed will be undefined rather than 0.

Having said that, exactly how the arguments object actually behaves depends on the browser. Chrome doesn't follow the spec.

Answer 4

It works for me, check this example fiddle

Answer 5

@nnnnnn -

"For non-strict mode functions the array index (defined in 15.4) named data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function’s execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object‘s properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values."

Your citation actually answers my original question. The reason that my code as posted below does not work as expected is because I was actually using "strict" mode.

// check all arguments, and make sure they aren't zero

function zeroCheck(arg1,arg2) {
    var i, argsLen = arguments.length;
    for (i = 0; i <= argsLen; i += 1) {
        if (arguments[i] === 0) {
            // This is where it doesn't behave as I expected
            arguments[i] = 1; // make arg1 = 1
        }
    }
    console.log(arg1); // arg1 = 0
}

zeroCheck(0,2);

It worked in for xdazz, Jeroen Moons, and jFriend00 - because they did not include the strict: http://jsfiddle.net/nSJGV/ (non-strict) http://jsfiddle.net/HDjWx/ (strict)