CODEWITHSUNDEEP
javascript
ajsie
ajsie

Reputation: 79816

Pass unknown number of arguments into JavaScript function

Is there a way to pass an unknown number of arguments like:

var print_names = function(names) {
    foreach(name in names) console.log(name); // something like this
}

print_names('foo', 'bar', 'baz');

Also, how do I get the number of arguments passed in?

Upvotes: 104

Views: 119616

Answers (13)

Anup Kumar
Anup Kumar

Reputation: 81

Here is the best answer using spread operator :)

function sum(...nums)
{
    let total =0;
     for(num of nums)
     {
         total+=num;
     }
    console.log(total)
}
console.log(sum(2,4,5,6,7));

Upvotes: 0

ShZ
ShZ

Reputation: 6606

ES3 (or ES5 or oldschool JavaScript)

You can access the arguments passed to any JavaScript function via the magic arguments object, which behaves similarly to an array. Using arguments your function would look like:

var print_names = function() {
     for (var i=0; i<arguments.length; i++) console.log(arguments[i]);
}

It's important to note that arguments is not an array. MDC has some good documentation on it: https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Functions#Using_the_arguments_object

If you want to turn arguments into an array so that you can do things like .slice(), .push() etc, use something like this:

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

ES6 / Typescript

There's a better way! The new rest parameters feature has your back:

var print_names = function(...names) {
    for (let i=0; i<names.length; i++) console.log(names[i]);
}

Upvotes: 181

Sekhar552
Sekhar552

Reputation: 71

let x = function(){
  return [].slice.call(arguments);
};

console.log(x('a','b','c','d'));

Upvotes: 0

mabulu
mabulu

Reputation: 274

You can create a function using the spread/rest operator and from there on, you achieved your goal. Please take a look at the chunk below.

const print_names = (...args) => args.forEach(x => console.log(x));

Upvotes: 0

Lajos Arpad
Lajos Arpad

Reputation: 77045

You can use the spread/rest operator to collect your parameters into an array and then the length of the array will be the number of parameters you passed:

function foo(...names) {
    console.log(names);
    return names;
}

console.log(foo(1, 2, 3, 4).length);

Using BabelJS I converted the function to oldschool JS:

"use strict";

function foo() {
  for (var _len = arguments.length, names = new Array(_len), _key = 0; _key < _len; _key++) {
    names[_key] = arguments[_key];
  }

  console.log(names);
  return names;
}

Upvotes: 0

Kurtis Streutker
Kurtis Streutker

Reputation: 1316

Rest parameters in ES6

const example = (...args) => {
  for (arg in args) {
    console.log(arg);
  }
}

Note: you can pass regular parameters in before the rest params

const example = (arg1, ...args) => {
  console.log(arg1);
  for (arg in args) {
    console.log(arg);
  }
}

Upvotes: 2

RationalDev likes GoFundMonica
RationalDev likes GoFundMonica

Reputation: 12693

ES6/ES2015

Take advantage of the rest parameter syntax.

function printNames(...names) {
  console.log(`number of arguments: ${names.length}`);
  for (var name of names) {
    console.log(name);
  }
}

printNames('foo', 'bar', 'baz');

There are three main differences between rest parameters and the arguments object:

  • rest parameters are only the ones that haven't been given a separate name, while the arguments object contains all arguments passed to the function;
  • the arguments object is not a real array, while rest parameters are Array instances, meaning methods like sort, map, forEach or pop can be applied on it directly;
  • the arguments object has additional functionality specific to itself (like the callee property).

Upvotes: 29

Santiago Posada
Santiago Posada

Reputation: 23

Much better now for ES6

function Example() {
    return {
        arguments: (...args) =>{
            args.map(a => console.log());
        }
    }
}

var exmpl = new Example();
exmpl.arguments(1, 2, 3, 'a', 'b', 'c');

I hope this helps

Upvotes: 2

public override
public override

Reputation: 982

var 
print_names = function() {
    console.log.apply( this, arguments );
};

print_names( 1, 2, 3, 4 );

Upvotes: 14

Colin Sullivan
Colin Sullivan

Reputation: 153

I like to do this:

This will not help if you don't know the number of arguments, but it helps if you don't want to remember the order of them.

/**
 *  @param  params.one        A test parameter
 *  @param  params.two        Another one  
 **/
function test(params) {

    var one = params.one;
    if(typeof(one) == 'undefined') {
        throw new Error('params.one is undefined');
    }

    var two = params.two;
    if(typeof(two) == 'undefined') {
        throw new Error('params.two is undefined');
    }
}

Upvotes: -4

Jacob Relkin
Jacob Relkin

Reputation: 163308

There is a hidden object passed to every function in JavaScript called arguments.

You would just use arguments.length to get the amount of arguments passed to the function.

To iterate through the arguments, you would use a loop:

for(var i = arguments.length; i--) {
   var arg = arguments[i];
}

Note that arguments isn't a real array, so if you needed it as an array you would convert it like this:

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

Upvotes: 6

Gabi Purcaru
Gabi Purcaru

Reputation: 31564

function print_args() {
    for(var i=0; i<arguments.length; i++)
        console.log(arguments[i])
}

Upvotes: 7

meder omuraliev
meder omuraliev

Reputation: 186742

arguments.length. you can use a for loop on it.

(function () {
    for (var a = [], i = arguments.length; i--;) {
        a.push(arguments[i]);
    };
    return a;
})(1, 2, 3, 4, 5, 6, 7, 8)

Upvotes: 4

Related Questions