Coder Perfect

How can I dynamically acquire the names and values of function parameters?


Is there a method to dynamically get the names of a function’s function parameters?

Let’s pretend my function is as follows:

function doSomething(param1, param2, .... paramN){
   // fill an array with the parameter name and value
   // some other code 

How would I go about getting a list of argument names and values into an array from within the function?

Asked by vikasde

Solution #1

Any function passed in will return an array of parameter names with the following function.

var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
var ARGUMENT_NAMES = /([^\s,]+)/g;
function getParamNames(func) {
  var fnStr = func.toString().replace(STRIP_COMMENTS, '');
  var result = fnStr.slice(fnStr.indexOf('(')+1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
  if(result === null)
     result = [];
  return result;

Example usage:

getParamNames(getParamNames) // returns ['func']
getParamNames(function (a,b,c,d){}) // returns ['a','b','c','d']
getParamNames(function (a,/*b,c,*/d){}) // returns ['a','d']
getParamNames(function (){}) // returns []


This function can now be tripped up by default parameters, thanks to the invention of ES6. Here’s a fast tip that should work in most situations:

var STRIP_COMMENTS = /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\\'|[^'\r\n])*')|("(?:\\"|[^"\r\n])*"))|(\s*=[^,\)]*))/mg;

I say most cases because there are a few factors that can cause problems.

function (a=4*(5/3), b) {} // returns ['a']

I’ve noticed that vikasde also expects the parameter values in an array. This is already available in the form of a local variable called arguments.

excerpt from

There isn’t an Array in the arguments object. It resembles an Array, however it lacks all of the Array’s attributes except length. It does not, for example, contain the pop function. It can, however, be transformed to a real Array:

var args =;

If Array generics are available, the following can be used instead:

var args = Array.slice(arguments);

Answered by Jack Allan

Solution #2

The code below is from AngularJS, which employs the approach as part of its dependency injection mechanism.

Here’s a link to an explanation: 05

 * @ngdoc overview
 * @name AUTO
 * @description
 * Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.

var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /^\s*(_?)(.+?)\1\s*$/;
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
function annotate(fn) {
  var $inject,

  if (typeof fn == 'function') {
    if (!($inject = fn.$inject)) {
      $inject = [];
      fnText = fn.toString().replace(STRIP_COMMENTS, '');
      argDecl = fnText.match(FN_ARGS);
      forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg){
        arg.replace(FN_ARG, function(all, underscore, name){
      fn.$inject = $inject;
  } else if (isArray(fn)) {
    last = fn.length - 1;
    assertArgFn(fn[last], 'fn')
    $inject = fn.slice(0, last);
  } else {
    assertArgFn(fn, 'fn', true);
  return $inject;

Answered by Lambder

Solution #3

Here’s an updated method that tries to solve all of the above-mentioned edge cases in a concise manner:

function $args(func) {  
    return (func + '')
      .replace(/[/][/].*$/mg,'') // strip single-line comments
      .replace(/\s+/g, '') // strip white space
      .replace(/[/][*][^/*]*[*][/]/g, '') // strip multi-line comments  
      .split('){', 1)[0].replace(/^[^(]*[(]/, '') // extract the parameters  
      .replace(/=[^,]+/g, '') // strip any ES6 defaults  
      .split(',').filter(Boolean); // split & filter [""]

Test results in abbreviated form (complete test cases are provided below):

'function (a,b,c)...' // returns ["a","b","c"]
'function ()...' // returns []
'function named(a, b, c) ...' // returns ["a","b","c"]
'function (a /* = 1 */, b /* = true */) ...' // returns ["a","b"]
'function fprintf(handle, fmt /*, ...*/) ...' // returns ["handle","fmt"]
'function( a, b = 1, c )...' // returns ["a","b","c"]
'function (a=4*(5/3), b) ...' // returns ["a","b"]
'function (a, // single-line comment xjunk) ...' // returns ["a","b"]
'function (a /* fooled you...' // returns ["a","b"]
'function (a /* function() yes */, \n /* no, */b)/* omg! */...' // returns ["a","b"]
'function ( A, b \n,c ,d \n ) \n ...' // returns ["A","b","c","d"]
'function (a,b)...' // returns ["a","b"]
'function $args(func) ...' // returns ["func"]
'null...' // returns ["null"]
'function Object() ...' // returns []

Answered by humbletim

Solution #4

The following is a less error-prone solution for spaces and comments:

var fn = function(/* whoa) */ hi, you){};


["hi", "you"]

Answered by bubersson

Solution #5

Many of the answers on here utilize regexes, which is OK, however it doesn’t accommodate new language additions very well (like arrow functions and classes). It’s also worth noting that if you use any of these functions on minified code, they’ll fail. Whatever the minified name is, it will be used. When registering arguments with the DI container, Angular allows you to pass in an ordered array of strings that matches the order of the parameters. Now for the solution:

var esprima = require('esprima');
var _ = require('lodash');

const parseFunctionArguments = (func) => {
    // allows us to access properties that may or may not exist without throwing 
    // TypeError: Cannot set property 'x' of undefined
    const maybe = (x) => (x || {});

    // handle conversion to string and then to JSON AST
    const functionAsString = func.toString();
    const tree = esprima.parse(functionAsString);
    console.log(JSON.stringify(tree, null, 4))
    // We need to figure out where the main params are. Stupid arrow functions 👊
    const isArrowExpression = (maybe(_.first(tree.body)).type == 'ExpressionStatement');
    const params = isArrowExpression ? maybe(maybe(_.first(tree.body)).expression).params 
                                     : maybe(_.first(tree.body)).params;

    // extract out the param names from the JSON AST
    return, 'name');

This takes care of the initial parse problem as well as a couple more function types (e.g. arrow functions). Here’s an example of what it can and can’t do right now:

// I usually use mocha as the test runner and chai as the assertion library
describe('Extracts argument names from function signature. 💪', () => {
    const test = (func) => {
        const expectation = ['it', 'parses', 'me'];
        const result = parseFunctionArguments(toBeParsed);

    it('Parses a function declaration.', () => {
        function toBeParsed(it, parses, me){};

    it('Parses a functional expression.', () => {
        const toBeParsed = function(it, parses, me){};

    it('Parses an arrow function', () => {
        const toBeParsed = (it, parses, me) => {};

    // ================= cases not currently handled ========================

    // It blows up on this type of messing. TBH if you do this it deserves to 
    // fail 😋 On a tech note the params are pulled down in the function similar 
    // to how destructuring is handled by the ast.
    it('Parses complex default params', () => {
        function toBeParsed(it=4*(5/3), parses, me) {}

    // This passes back ['_ref'] as the params of the function. The _ref is a 
    // pointer to an VariableDeclarator where the ✨🦄 happens.
    it('Parses object destructuring param definitions.' () => {
        function toBeParsed ({it, parses, me}){}

    it('Parses object destructuring param definitions.' () => {
        function toBeParsed ([it, parses, me]){}

    // Classes while similar from an end result point of view to function
    // declarations are handled completely differently in the JS AST. 
    it('Parses a class constructor when passed through', () => {
        class ToBeParsed {
            constructor(it, parses, me) {}

ES6 Proxies and destructuring may be your best bet depending on what you want to do with it. For instance, if you wanted to utilize it for dependency injection (by leveraging the param names), you could do it as follows:

class GuiceJs {
    constructor() {
        this.modules = {}
    resolve(name) {
        return this.getInjector()(this.modules[name]);
    addModule(name, module) {
        this.modules[name] = module;
    getInjector() {
        var container = this;

        return (klass) => {
            var paramParser = new Proxy({}, {
                // The `get` handler is invoked whenever a get-call for
                // `injector.*` is made. We make a call to an external service
                // to actually hand back in the configured service. The proxy
                // allows us to bypass parsing the function params using
                // taditional regex or even the newer parser.
                get: (target, name) => container.resolve(name),

                // You shouldn't be able to set values on the injector.
                set: (target, name, value) => {
                    throw new Error(`Don't try to set ${name}! 😑`);
            return new klass(paramParser);

It’s not the most advanced resolver out there, but it shows how you can handle it with a Proxy if you want to utilize args parser for simple DI. However, there is one little limitation to this strategy. Instead of using regular params, we must utilize destructuring assignments. Destructuring is the same as calling the getter on the object when we pass in the injector proxy.

class App {
   constructor({tweeter, timeline}) {
        this.tweeter = tweeter;
        this.timeline = timeline;

class HttpClient {}

class TwitterApi {
    constructor({client}) {
        this.client = client;

class Timeline {
    constructor({api}) {
        this.api = api;

class Tweeter {
    constructor({api}) {
        this.api = api;

// Ok so now for the business end of the injector!
const di = new GuiceJs();

di.addModule('client', HttpClient);
di.addModule('api', TwitterApi);
di.addModule('tweeter', Tweeter);
di.addModule('timeline', Timeline);
di.addModule('app', App);

var app = di.resolve('app');
console.log(JSON.stringify(app, null, 4));

The following is the result:

    "tweeter": {
        "api": {
            "client": {}
    "timeline": {
        "api": {
            "client": {}

The complete application has been connected up. The best bit is that the app is easy to test (you can just instantiate each class and pass in mocks/stubs/etc). Also if you need to swap out implementations, you can do that from a single place. All this is possible because of JS Proxy objects.

Note: This would require a lot of work before it could be used in production, but it does give you an idea of how it might appear.

It’s a little late in the response, but it might be useful to others who are considering the same issue.

Answered by James Drew

Post is based on