JavaScript variable number of arguments to function

JavaScript variable number of arguments to function

Is there a way to allow “unlimited” vars for a function in JavaScript?
load(var1, var2, var3, var4, var5, etc…)


Solution 1:

Sure, just use the arguments object.

function foo() {
  for (var i = 0; i < arguments.length; i++) {

Solution 2:

In (most) recent browsers, you can accept variable number of arguments with this syntax:

function my_log(...args) {
     // args is an Array
     // You can pass this array as parameters to another function

Here’s a small example:

function foo(x, ...args) {
  console.log(x, args, ...args, arguments);

foo('a', 'b', 'c', z='d')


Array(3) [ "b", "c", "d" ]
b c d
​    0: "a"
    ​1: "b"
    ​2: "c"
    ​3: "d"
    ​length: 4

Documentation and more examples here:

Solution 3:

Another option is to pass in your arguments in a context object.

function load(context)
    // do whatever with, context.address, etc

and use it like this


This has the advantage that you can add as many named arguments as you want, and the function can use them (or not) as it sees fit.

Solution 4:

I agree with Ken’s answer as being the most dynamic and I like to take it a step further. If it’s a function that you call multiple times with different arguments – I use Ken’s design but then add default values:

function load(context) {

    var defaults = {
        parameter1: defaultValue1,
        parameter2: defaultValue2,

    var context = extend(defaults, context);

    // do stuff

This way, if you have many parameters but don’t necessarily need to set them with each call to the function, you can simply specify the non-defaults. For the extend method, you can use jQuery’s extend method ($.extend()), craft your own or use the following:

function extend() {
    for (var i = 1; i < arguments.length; i++)
        for (var key in arguments[i])
            if (arguments[i].hasOwnProperty(key))
                arguments[0][key] = arguments[i][key];
    return arguments[0];

This will merge the context object with the defaults and fill in any undefined values in your object with the defaults.

Solution 5:

Yes, just like this :

function load()
  var var0 = arguments[0];
  var var1 = arguments[1];


Solution 6:

It is preferable to use rest parameter syntax as Ramast pointed out.

function (a, b, ...args) {}

I just want to add some nice property of the …args argument

  1. It is an array, and not an object like arguments. This allows you to apply functions like map or sort directly.
  2. It does not include all parameters but only the one passed from it on. E.g. function (a, b, …args) in this case args contains
    argument 3 to arguments.length