# Get a function's arity

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
}
`````` ``````> 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
}
`````` 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
`````` 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`````` 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){}

``````

Note: the number of parameters passed in a function call does not affect the function's arity. 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.