66

In Javascript, how can one determine the number of formal parameters defined for a function?

Note, this is not the arguments parameter when the function is called, but the number of named arguments the function was defined with.

function zero() {
    // Should return 0
}

function one(x) {
    // Should return 1
}

function two(x, y) {
    // Should return 2
}
JasonSmith
  • 72,674
  • 22
  • 123
  • 149

5 Answers5

81
> zero.length
0
> one.length
1
> two.length
2

Source

A function can determine its own arity (length) like this:

// For IE, and ES5 strict mode (named function)
function foo(x, y, z) {
    return foo.length; // Will return 3
}

// Otherwise
function bar(x, y) {
    return arguments.callee.length; // Will return 2
}
JasonSmith
  • 72,674
  • 22
  • 123
  • 149
Josh Lee
  • 171,072
  • 38
  • 269
  • 275
  • I intended to answer my own question since it wasn't on Stack Overflow but you beat me to it! I will update your answer with technique for a function to determine its own arity. – JasonSmith Jan 31 '11 at 06:28
  • You mean `arguments.callee.length`? – Phrogz Jan 31 '11 at 06:28
  • 9
    Note that this is not the same as `arguments.length`, which is the number of arguments actually received. – Josh Lee Jan 31 '11 at 06:30
  • Yes, that is why I said "arity," so people who know what they are searching for don't have to wade through the beginner stuff about `arguments`. – JasonSmith Jan 31 '11 at 06:35
  • 6
    @jhs: Note also that `arguments.callee` throws an error in ECMAScript 5 strict mode, meaning it has effectively been removed from the language. – Tim Down Jan 31 '11 at 09:59
  • @jhs: The way to do it in ES5 strict will be to use a function declaration or named function expression to allow you to refer to the function by name: `var foo = function bar(x, y, z) { return bar.length; };`. Because of issues in IE, it's best to avoid named function expressions in non-ES5 environments. – Tim Down Jan 31 '11 at 10:08
  • Thanks, Tim. I was wondering because I had heard that `arguments.callee` breaks a very useful security environment that a function closure would set up. I will amend the answer. – JasonSmith Jan 31 '11 at 13:13
  • @TimDown, please, can you explain about IE bug ? – kirugan Jun 07 '13 at 13:16
  • With the introduction of default params in ES6, the length property would not work as expected: (function foo(a, b = 'default', c) {}).length // 1, only parameters before the first one with a default value are counted – Andres Zapata Jul 31 '22 at 06:21
14

As is covered in other answers, the length property tells you that. So zero.length will be 0, one.length will be 1, and two.length will be 2.

As of ES2015, we have two wrinkles:

  • Functions can have a "rest" parameter at the end of the parameter list which gathers up any arguments given at that position or afterward into a true array (unlike the arguments pseudo-array)
  • Function parameters can have default values

The "rest" parameter isn't counted when determining the arity of the function:

function stillOne(a, ...rest) { }
console.log(stillOne.length); // 1

Similarly, a parameter with a default argument doesn't add to the arity, and in fact prevents any others following it from adding to it even if they don't have explicit defaults (they're assumed to have a silent default of undefined):

function oneAgain(a, b = 42) { }
console.log(oneAgain.length);    // 1

function oneYetAgain(a, b = 42, c) { }
console.log(oneYetAgain.length); // 1
T.J. Crowder
  • 1,031,962
  • 187
  • 1,923
  • 1,875
  • 1
    Thanks! This is a great update. I think for `...rest`, while it hides the true arity, the `.length` property is still useful. But in the case of default parameters, do you know any workarounds, or even just a way to detect that default parameters are being used at all? – JasonSmith Dec 19 '16 at 10:00
  • 2
    @JasonSmith: Nothing that doesn't rely on decompilation (e.g., `Function#toString`). – T.J. Crowder Dec 19 '16 at 10:03
12

A function's arity is stored in its .length property.

function zero() {
    return arguments.callee.length;
}

function one(x) {
    return arguments.callee.length;
}

function two(x, y) {
    return arguments.callee.length;
}

> console.log("zero="+zero() + " one="+one() + " two="+two())
zero=0 one=1 two=2
JasonSmith
  • 72,674
  • 22
  • 123
  • 149
-1

The arity property used to return the number of arguments expected by the function, however, it no longer exists and has been replaced by the Function.prototype.length property.

Dan
  • 1,077
  • 7
  • 6
-2

A function arity is the number of parameters the function contains.It can be attained by calling the length property.

Example:

function add(num1,num2){}
console.log(add.length); // --> 2

function add(num1,num2,num3){}
console.log(add.length); // --> 3

Note: the number of parameters passed in a function call does not affect the function's arity.

changhwan
  • 1,000
  • 8
  • 22
Nikhil
  • 7
  • 2