Is it bad to pass more arguments than the function declares?

javascript

Solution

JavaScript allows this, you can pass any arbitrary number of arguments to a function.

They are accessible in the `arguments` object which is an array-like object that has numeric properties containing the values of the arguments that were used when the function was invoked, a `length` property that tells you how many arguments have been used on the invocation also, and a `callee` property which is a reference to the function itself, for example you could write:

function sum(/*arg1, arg2, ... , argN  */) { // no arguments defined
  var i, result = 0;
  for (i = 0; i < arguments.length; i++) {
    result += arguments[i];
  }
  return result;
}
sum(1, 2, 3, 4); // 10

The `arguments` object may look like an array, but it is a plain object, that inherits from `Object.prototype`, but if you want to use Array methods on it, you can invoke them directly from the `Array.prototype`, for example, a common pattern to get a real array is to use the Array `slice` method:

function test () {
  var args = Array.prototype.slice.call(arguments);
  return args.join(" ");
}
test("hello", "world"); // "hello world"

Also, you can know how many arguments a function expects, using the `length` property of the function object:

function test (one, two, three) {
  // ...
}
test.length; // 3

Problem

I have a function ``` function callback(obj){...} ``` Is it okay to pass in more objects than were declared in the function signature? e.g. call it like this: ``` callback(theObject, extraParam); ``` I tried it out on Firefox and it didn't seem to have a problem, but is it bad to do this?

Original source