How to get function parameter names values dynamically

Question

Is there a way to get the function parameter names of a function dynamically   Let   s say my function looks like this   function doSomething param1  param2       paramN         fill an array with the parameter name and value       some other code      Now  how would I get a list of the parameter names and their values into an array from inside the function

User · Answer

Here is an updated solution that attempts to address all the edge cases mentioned above in a compact way:

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 [""]
}

Abbreviated test output (full test cases are attached 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 []

_x000D_

function $args(func) {  _x000D_
    return (func + '')_x000D_
      .replace(/[/][/].*$/mg,'') // strip single-line comments_x000D_
      .replace(/\s+/g, '') // strip white space_x000D_
      .replace(/[/][*][^/*]*[*][/]/g, '') // strip multi-line comments  _x000D_
      .split('){', 1)[0].replace(/^[^(]*[(]/, '') // extract the parameters  _x000D_
      .replace(/=[^,]+/g, '') // strip any ES6 defaults  _x000D_
      .split(',').filter(Boolean); // split & filter [""]_x000D_
}  _x000D_
_x000D_
// test cases  _x000D_
document.getElementById('console_info').innerHTML = (_x000D_
[  _x000D_
  // formatting -- typical  _x000D_
  function(a,b,c){},  _x000D_
  function(){},  _x000D_
  function named(a, b,  c) {  _x000D_
/* multiline body */  _x000D_
  },  _x000D_
    _x000D_
  // default values -- conventional  _x000D_
  function(a /* = 1 */, b /* = true */) { a = a||1; b=b||true; },  _x000D_
  function fprintf(handle, fmt /*, ...*/) { },  _x000D_
  _x000D_
  // default values -- ES6  _x000D_
  "function( a, b = 1, c ){}",  _x000D_
  "function (a=4*(5/3), b) {}",  _x000D_
  _x000D_
  // embedded comments -- sardonic  _x000D_
  function(a, // single-line comment xjunk) {}_x000D_
    b //,c,d_x000D_
  ) // single-line comment_x000D_
  {},  _x000D_
  function(a /* fooled you{*/,b){},  _x000D_
  function /* are you kidding me? (){} */(a /* function() yes */,  _x000D_
   /* no, */b)/* omg! */{/*}}*/},  _x000D_
  _x000D_
  // formatting -- sardonic  _x000D_
  function  (  A,  b  _x000D_
,c  ,d  _x000D_
  )  _x000D_
  {  _x000D_
  },  _x000D_
  _x000D_
  // by reference  _x000D_
  this.jQuery || function (a,b){return new e.fn.init(a,b,h)},_x000D_
  $args,  _x000D_
  _x000D_
  // inadvertent non-function values  _x000D_
  null,  _x000D_
  Object  _x000D_
].map(function(f) {_x000D_
    var abbr = (f + '').replace(/\n/g, '\\n').replace(/\s+|[{]+$/g, ' ').split("{", 1)[0] + "...";_x000D_
    return "    '" + abbr + "' // returns " + JSON.stringify($args(f));_x000D_
  }).join("\n") + "\n"); // output for copy and paste as a markdown snippet

_x000D_

<pre id='console_info'></pre>

_x000D_

User · Answer

Solution that is less error prone to spaces and comments would be   var fn   function    whoa     hi  you      fn toString      replace                    s S           s   mg        match   function s          s            m  1     split         hi    you

User · Answer

function a b c     toString   replace            ig     split              a    b    c

User · Answer

I ll give you a short example below   function test arg1 arg2       var funcStr   test toString       var leftIndex   funcStr indexOf           var rightIndex   funcStr indexOf           var paramStr   funcStr substr leftIndex 1 rightIndex-leftIndex-1       var params   paramStr split           for param of params           console log param        arg1 arg2          test

User · Answer

function parameter string value image dynamically from JSON  Since item product image2 is a URL string  you need to put it in quotes when you call changeImage inside parameter   My Function Onclick  items    lt img src   item product image1   id  saleDetailDivGetImg  gt    items    lt img src   item product image2    onclick  changeImage     item product image2        gt      My Function   lt script type  text javascript  gt  function changeImage img         document getElementById  saleDetailDivGetImg   src img      alert img      lt  script gt

User · Answer

function getArgs args        var argsObj            var argList               exec args callee  1       var argCnt   0      var tokens       while  tokens     s         g exec argList             argsObj tokens 1     args argCnt                return argsObj

User · Answer

I ve tried doing this before  but never found a praticial way to get it done  I ended up passing in an object instead and then looping through it     define like function test args        for var item in args            alert item           alert args item               then used like test       name  Joe       age 40      admin bool

User · Answer

Note  if you want to use ES6 parameter destructuring with the top solution add the following line   if  result 0           amp  amp  result result length - 1           result   result slice 1  -1

User · Answer

i would likke to suggest solution which supports arrow functions like i used this article for basic regular expression and https   davidwalsh name javascript-arguments and added arrow functions support  arg1 arg2    gt      or arg   gt        function getArgs func      if func length     0         return           let string   func toString       let args       First match everything inside the function argument parens  like  function  arg1 arg2      or  async function arg1 arg2         args   string match     async function  s                    1              arrow functions with multiple arguments  like   arg1 arg2    gt               string match    s             s   gt      1              arrow functions with single argument without parens like  arg   gt               string match    s          gt      1        Split the arguments string into an array comma delimited    return args split      map function arg           Ensure no inline comments are parsed and trim the whitespace      return arg replace                   trim         filter function arg           Ensure no undefined values are added      return arg

User · Answer

I have modified the version taken from AngularJS that implements a dependency injection mechanism to work without Angular  I have also updated the STRIP COMMENTS regex to work with ECMA6  so it supports things like default values in the signature    x000D   x000D  var FN ARGS     function s          s            m  x000D  var FN ARG SPLIT        x000D  var FN ARG      s           1 s     x000D  var STRIP COMMENTS                     s S           s                       r n                   r n         s            mg  x000D   x000D  function annotate fn    x000D    var  inject  x000D      fnText  x000D      argDecl  x000D      last  x000D   x000D    if  typeof fn     function     x000D      if     inject   fn  inject     x000D         inject       x000D        fnText   fn toString   replace STRIP COMMENTS       x000D        argDecl   fnText match FN ARGS   x000D        argDecl 1  split FN ARG SPLIT  forEach function arg    x000D          arg replace FN ARG  function all  underscore  name    x000D             inject push name   x000D              x000D            x000D        fn  inject    inject  x000D        x000D      else   x000D      throw Error  not a function   x000D      x000D    return  inject  x000D    x000D   x000D  console log  function a  b   annotate function a  b    x000D    console log a  b  c  d  x000D      x000D  console log  function a  b   0    c    d   annotate function a  b   0    c    d    x000D    console log a  b  c  d  x000D      x000D  annotate     x000D   x000D   x000D

User · Answer

Ok so an old question with plenty of adequate answers  here is my offering that does not use regex  except for the menial task of stripping whitespace    I should note that the  strips comments  function actually spaces them out  rather than physically remove them  that s because i use it elsewhere and for various reasons need the locations of the original non comment tokens to stay intact   It s a fairly lengthy block of code as this pasting includes a mini test framework       function do tests func         if  typeof func      function   return true      switch  typeof func tests            case  undefined    return true          case  object                    for  var k in func tests                     var test   func tests k                   if  typeof test    function                         var result   test func                       if  result   false                            console log test name  for  func name  failed                            return false                                                                     return true          case  function                  return func tests func             return true     function strip comments src         var spaces  s   gt           switch  s                case 0   return                 case 1   return                  case 2   return               default                return Array s 1  join                             var c1   src indexOf                 c2   src indexOf                 eol       var out            var killc2        gt                    out    src substr 0 c2                   eol    src indexOf   n  c2                   if  eol gt  0                        src   spaces eol-c2    n  src substr eol 1                     else                       src   spaces src length-c2                       return true                                  return false                   while   c1 gt  0      c2 gt  0              if  c1 gt  0                    c1 is a hit              if    c1 lt c2      c2 lt 0                           and it beats c2                  out    src substr 0 c1                    eol   src indexOf      c1 2                    if  eol gt  0                          src   spaces  eol-c1  2  src substr eol 2                      else                         src   spaces src length-c1                         break                                    else                     if  c2  gt  0                            c2 is a hit and it beats c1                      if  killc2    break                                               else                if  c2 gt  0                       c2 is a hit  c1 is a miss                  if  killc2    break                   else                       both c1  amp  c2 are a miss                  break                                      c1   src indexOf                  c2   src indexOf                           return out   src     function function args fn        var src   strip comments fn toString         var names src split      0  replace   s g     split      1  split           return names     function args tests           function test1                   function  al programmers will sometimes  strip comments tester   because some comments are annoying                  see this---      src     it s an annoying comment does not help anyone understand if the               code   really does                 sucks  much         who would put  comment   about a function like  this    comment   here                              var data   function args strip comments tester            return    data length  4   amp  amp                    data 0    src    amp  amp                    data 1    code    amp  amp                    data 2    sucks    amp  amp                    data 3    much                  do tests function args

User · Answer

Here s one way      Utility function to extract arg name-value pairs function getArgs args        var argsObj            var argList               exec args callee  1       var argCnt   0      var tokens      var argRe     s         g       while  tokens   argRe exec argList             argsObj tokens 1     args argCnt                return argsObj        Test subject function add number1  number2        var args   getArgs arguments       console log args         number1  3  number2  4          Invoke test subject add 3  4     Note  This only works on browsers that support arguments callee

User · Answer

I don t know how to get a list of the parameters but you can do this to get how many it expects   alert doSomething length

User · Answer

You can access the argument values passed to a function using the  arguments  property       function doSomething                 var args   doSomething arguments          var numArgs   args length          for var i   0   i  lt  numArgs   i                          console log  arg      i 1            args i                            console log works with firefox   firebug                        you can use an alert to check in other browsers                      doSomething 1   2    A 2    1 2 3

User · Answer

I have read most of the answers here  and I would like to add my one-liner  new RegExp       Function name    s                  exec Function toString   replace   n g       1  replace              g      replace    g       or function getParameters func      return new RegExp       func name    s      s               exec func toString   replace   n g       1  replace              g      replace    g          or for a one-liner function in ECMA6 var getParameters   func   gt  new RegExp       func name    s      s               exec func toString   replace   n g       1  replace              g      replace    g           Let s say you have a function function foo abc  def  ghi  jkl        code    The below code will return  quot abc def ghi jkl quot  That code will also work with the setup of a function that Camilo Martin gave  function     A   b  c       d      Also with Bubersson s comment on Jack Allan s answer  function a    fooled you    b        Explanation new RegExp       Function name    s      s               This creates a Regular Expression with the new RegExp       Function name    s      s                 I have to use new RegExp because I am injecting a variable  Function name  the name of the function being targeted  into the RegExp  Example If the function name is  quot foo quot   function foo     the RegExp will be  foo s             Function toString   replace   n g      Then it converts the entire function into a string  and removes all newlines   Removing newlines helps with the function setup Camilo Martin gave   exec      1  This is the RegExp prototype exec function  It basically matches the Regular Exponent  new RegExp    into the String  Function toString      Then the  1  will return the first Capture Group found in the Regular Exponent           replace              g      replace    g      This will remove every comment inside    and     and remove all spaces   This also now supports reading and understanding arrow    gt   functions  such as f    a  b    gt  void 0   in which Function toString   would return  a  b    gt  void 0 instead of the normal function s function f a  b    return void 0     The original regular expression would have thrown an error in its confusion  but is now accounted for  The change was from new RegExp Function name    s                 Function s             to new RegExp       Function name    s                       Function s                 If you want to make all the parameters into an Array instead of a String separated by commas  at the end just add  split

User · Answer

The proper way to do this is to use a JS parser  Here is an example using acorn   const acorn   require  acorn         function f a  b  c                 const argNames   acorn parse f  body 0  params map x   gt  x name   console log argNames       Output     a    b    c      The code here finds the names of the three  formal  parameters of the function f  It does so by feeding f into acorn parse

User · Answer

Below is the code taken from AngularJS which uses the technique for its dependency injection mechanism   And here is an explanation of it taken from http   docs angularjs org tutorial step 05     Angular s dependency injector provides services to your controller   when the controller is being constructed  The dependency injector also   takes care of creating any transitive dependencies the service may   have  services often depend upon other services        Note that the names of arguments are significant  because the injector   uses these to look up the dependencies            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        fnText        argDecl        last     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              inject push 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

User · Answer

Taking the answer from  jack-allan I modified the function slightly to allow ES6 default properties such as   function  a  b   1  c        to still return    a    b            Get the keys of the paramaters of a function         param  function  method  Function to get parameter keys for     return  array      var STRIP COMMENTS                      s S          mg  var ARGUMENT NAMES            s     s      g  function getFunctionParameters   func         var fnStr   func toString   replace STRIP COMMENTS           var argsList   fnStr slice fnStr indexOf      1  fnStr indexOf            var result   argsList match  ARGUMENT NAMES         if result     null            return               else           var stripped               for   var i   0  i  lt  result length  i                    stripped push  result i  replace    s   g                           return stripped

User · Answer

Try Manually   function something arg1  arg2      console log   arg1   arg2

User · Answer

Whatever the solution  it must not break on wierd functions  whose toString   looks just as wierd   function     A   b  c       d         Also  why use complex regular expressions  This can be done like   function getArguments f        return f toString   split     1  0  replace   s g     substr 9  split           This works everywhere with every function  and the only regex is whitespace removal that doesn t even process the whole string due to the  split trick

User · Answer

You can also use  esprima  parser to avoid many issues with comments  whitespace and other things inside parameters list   function getParameters yourFunction        var i             safetyValve is necessary  because sole  function                      is not a valid syntax         parsed   esprima parse  safetyValve       yourFunction toString             params   parsed body 0  expression right params          ret            for  i   0  i  lt  params length  i    1               Handle default params  Exe  function defaults a   0 b   2 c   3            if  params i  type     AssignmentPattern                 ret push params i  left name            else               ret push params i  name                        return ret      It works even with code like this   getParameters function  hello     foo      bar       world            hello    world

User · Answer

How I typically do it   function name arg1  arg2       var args   arguments     array   arg1  arg2      var objecArgOne   args 0  one    name  one   1   two   2     string      You can even ref the args by the functions name like    name arguments    Hope this helps

User · Answer

It s pretty easy   At the first there is a deprecated arguments callee     a reference to called function  At the second if you have a reference to your function you can easily get their textual representation  At the third if you calling your function as constructor you can also have a link via yourObject constructor  NB  The first solution deprecated so if you can t to not use it you must also think about your app architecture  If you don t need exact variable names just use inside a function internal variable arguments without any magic   https   developer mozilla org en-US docs JavaScript Reference Functions and function scope arguments callee  All of them going to call toString and replace with re so we can create a helper      getting names of declared parameters var getFunctionParams   function  func        return String func  replace                       m    1        Some examples      Solution 1  deprecated  don t use it  var myPrivateFunction   function SomeFuncName  foo  bar  buz        console log getFunctionParams arguments callee       myPrivateFunction  1  2       Solution 2  var myFunction   function someFunc  foo  bar  buz           some code    var params   getFunctionParams myFunction   console log params       Solution 3  var cls   function SuperKewlClass  foo  bar  buz           some code    var inst   new cls    var params   getFunctionParams inst constructor   console log params     Enjoy with JS   UPD  Jack Allan was provided a little bit better solution actually  GJ Jack

User · Answer

Wow so many answers already   Im pretty sure this gets buried  Even so I figured this might be useful for some   I wasn t fully satisfied with the chosen answers as in ES6 it doesn t work well with default values  And it also does not provide the default value information  I also wanted a lightweight function that does not depend on an external lib   This function is very useful for debugging purposes  for example  logging called function with its params  default param values and arguments   I spent some time on this yesterday  cracking the right RegExp to solve this issue and this is what I came up with  It works very well and I m very pleased with the outcome    x000D   x000D  const REGEX COMMENTS                      s S          mg  x000D  const REGEX FUNCTION PARAMS        s    function s         s                                       2   2        s         gt      m x000D  const REGEX PARAMETERS VALUES     s   w   s      s                  3             3      s    s                  6             6         w                s         gm x000D   x000D      x000D     Retrieve a function s parameter names and default values x000D     Notes  x000D      - parameters with default values will not show up in transpiler code  Babel  because the parameter is removed from the function  x000D      - does NOT support inline arrow functions as default values x000D          to clarify    name    string   add   defaultAddFunction     - is ok x000D                        name    string   add     a    gt  a   1          - is NOT ok x000D      - does NOT support default string value that are appended with a non-standard   word characters or     variable name x000D          to clarify    name    string    b           - is ok x000D                        name    string     b          - is ok x000D                        name    string    b           - is ok x000D                        name    string                - is NOT ok x000D      param  function  func x000D      returns  Array  - An array of the given function s parameter  key  default value  pairs  x000D      x000D  function getParams func    x000D   x000D    let functionAsString   func toString   x000D    let params      x000D    let match x000D    functionAsString   functionAsString replace REGEX COMMENTS      x000D    functionAsString   functionAsString match REGEX FUNCTION PARAMS  1  x000D    if  functionAsString charAt 0           functionAsString   functionAsString slice 1  -1  x000D    while  match   REGEX PARAMETERS VALUES exec functionAsString   params push  match 1   match 2    x000D    return params x000D   x000D    x000D   x000D   x000D   x000D     Lets run some tests  x000D   x000D  var defaultName    some name  x000D   x000D  function test1 param1  param2  param3    return  param1    gt  param1   param2   param3   x000D  function test2 param1  param2   4    5   3   param3     x000D  function test3 param1  param2     root     defaultName     jpeg   param3     x000D  function test4 param1  param2    a    gt  a   1     x000D   x000D  console log getParams test1    x000D  console log getParams test2   x000D  console log getParams test3   x000D  console log getParams test4   x000D   x000D          param1   undefined       param2   undefined       param3   undefined     x000D          param1   undefined       param2    4    5   3         param3   undefined     x000D          param1   undefined       param2      root     defaultName     jpeg         param3   undefined     x000D          param1   undefined       param2      a      x000D     -- gt  This last one fails because of the inlined arrow function  x000D   x000D   x000D  var arrowTest1    a   1    gt  a   4 x000D  var arrowTest2   a   gt  b   gt  a   b x000D  var arrowTest3    param1         defaultName    gt    return param1           x000D  var arrowTest4    param1         defaultName  param2   4  param3   null    gt         gt  param3   param3   param2   x000D   x000D  console log getParams arrowTest1   x000D  console log getParams arrowTest2   x000D  console log getParams arrowTest3   x000D  console log getParams arrowTest4   x000D   x000D          a    1      x000D          a   undefined     x000D          param1          defaultName      x000D          param1          defaultName        param2    4        param3    null      x000D   x000D   x000D  console log getParams  param1    gt  param1   1   x000D  console log getParams  param1    default     gt    return param1     jpeg      x000D   x000D          param1   undefined     x000D          param1      default        x000D   x000D   x000D    As you can tell some of the parameter names disappear because the Babel transpiler removes them from the function  If you would run this in the latest NodeJS it works as expected  The commented results are from NodeJS    Another note  as stated in the comment is that is does not work with inlined arrow functions as a default value  This simply makes it far to complex to extract the values using a RegExp   Please let me know if this was useful for you  Would love to hear some feedback

User · Answer

I don t know if this solution suits your problem  but it lets you redefine whatever function you want  without having to change code that uses it  Existing calls will use positioned params  while the function implementation may use  named params   a single hash param    I thought that you will anyway modify existing function definitions so  why not having a factory function that makes just what you want    lt  DOCTYPE html gt    lt html gt   lt head gt   lt meta charset  UTF-8  gt   lt title gt  lt  title gt   lt script type  text javascript  gt  var withNamedParams   function params  lambda        return function             var named               var max     arguments length           for  var i 0  i lt max  i                  named params i     arguments i                      return lambda named              var foo   withNamedParams   a    b    c    function params        for  var param in params            alert param          params param               foo 1  2  3    lt  script gt   lt  head gt   lt body gt    lt  body gt   lt  html gt    Hope it helps

User · Answer

The answer to this requires 3 steps    To get the values of the actual parameters passed to the function  let s call it argValues   This is straight forward as it will be available as arguments inside the function  To get the parameter names from the function signature  let s call it argNames   This not as easy and requires parsing the function  Instead of doing the complex regex yourself and worrying about edge cases  default parameters  comments        you can use a library like babylon that will parse the function into an abstract syntax tree from which you can obtain the names of parameters  The last step is to join the 2 arrays together into 1 array that has the name and value of all the parameters    The code will be like this  const babylon   require  babylon   function doSomething a  b  c           get the values of passed argumenst     const argValues   arguments         get the names of the arguments by parsing the function     const ast   babylon parse doSomething toString        const argNames    ast program body 0  params map node   gt  node name          join the 2 arrays  by looping over the longest of 2 arrays     const maxLen   Math max argNames length  argValues length      const args          for  i   0  i  lt  maxLen  i              args push  name  argNames i   value  argValues i              console log args          implement the actual function here    doSomething 1  2  3  4    and the logged object will be              name    a        value   1               name    c        value   3               value   4         And here s a working example https   tonicdev com 5763eb77a945f41300f62a79 5763eb77a945f41300f62a7a

User · Answer

I know this is an old question  but beginners have been copypasting this around as if this was good practice in any code  Most of the time  having to parse a function s string representation to use its parameter names just hides a flaw in the code s logic   Parameters of a function are actually stored in an array-like object called arguments  where the first argument is arguments 0   the second is arguments 1  and so on  Writing parameter names in the parentheses can be seen as a shorthand syntax  This   function doSomething foo  bar        console log  does something           is the same as   function doSomething         var foo   arguments 0       var bar   arguments 1        console log  does something        The variables themselves are stored in the function s scope  not as properties in an object  There is no way to retrieve the parameter name through code as it is merely a symbol representing the variable in human-language   I always considered the string representation of a function as a tool for debugging purposes  especially because of this arguments array-like object  You are not required to give names to the arguments in the first place  If you try parsing a stringified function  it doesn t actually tell you about extra unnamed parameters it might take   Here s an even worse and more common situation  If a function has more than 3 or 4 arguments  it might be logical to pass it an object instead  which is easier to work with   function saySomething obj      if obj message  console log  obj sender     Anon            obj message      saySomething  sender   user123   message   Hello world       In this case  the function itself will be able to read through the object it receives and look for its properties and get both their names and values  but trying to parse the string representation of the function would only give you  obj  for parameters  which isn t useful at all

User · Answer

As this has not yet been mentioned  if you are using Typescript you can emit meta-data when using Decorators which will allow you to get the parameter names and types  Metadata will only be emitted if the class function prop has a decorator on it  It doesn t matter which decorator  This feature can be enabled by setting emitDecoratorMetadata to true inside tsconfig json      quot compilerOptions quot          quot emitDecoratorMetadata quot   true        As the metadata is still an early proposal the reflect-metadata package must be installed or Reflect getMetadata will not be defined  npm install reflect-metadata  You can use it as follows  const AnyDecorator        MethodDecorator   gt        return target   gt         class Person       AnyDecorator       sayHello other  Person      const instance   new Person    const funcType   Reflect getMetadata  design type   instance sayHello   const funcParams   Reflect getMetadata  design paramtypes   instance sayHello    In newer versions of Angular for instance this is used to determine what to inject - gt  https   stackoverflow com a 53041387 1087372

User · Answer

See this       global var  naming bB var bB   5       Dependency Injection cokntroller var a   function str  fn        stringify function body   var fnStr   fn toString          Key  get form args to string   var args   fnStr match  function s                      console log args        if the form arg is  bB   then exec it  otherwise  do nothing   for  var i   0  i  lt  args length  i          if args i      bB           fn bB                  will do nothing a  sdfdfdfs    function some   alert some         will alert 5  a  sdfdsdsfdfsdfdsf    function bB   alert bB          see  this shows you how to get function args in string

User · Answer

This package uses recast in order to create an AST and then the parameter names are gathered from their  this allows it to support pattern matching  default arguments  arrow functions and other ES6 features   https   www npmjs com package es-arguments

User · Answer

The following function will return an array of the parameter names of any function passed in   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      Edit   With the invent of ES6 this function can be tripped up by default parameters   Here is a quick hack which should work in most cases   var STRIP COMMENTS                     s S           s                       r n                   r n         s            mg    I say most cases because there are some things that will trip it up  function  a 4  5 3   b        returns   a     Edit  I also note vikasde wants the parameter values in an array also   This is already provided in a local variable named arguments     excerpt from https   developer mozilla org en-US docs Web JavaScript Reference Functions and function scope arguments   The arguments object is not an Array  It is similar to an Array  but does not have any Array properties except length  For example  it does not have the pop method  However it can be converted to a real Array   var args   Array prototype slice call arguments     If Array generics are available  one can use the following instead   var args   Array slice arguments

User · Answer

A lot of the answers on here use regexes  this is fine but it doesn t handle new additions to the language too well  like arrow functions and classes   Also of note is that if you use any of these functions on minified code it s going to go   It will use whatever the minified name is  Angular gets around this by allowing you to pass in an ordered array of strings that matches the order of the arguments when registering them with the DI container  So on with the solution    var esprima   require  esprima    var     require  lodash     const parseFunctionArguments    func    gt           allows us to access properties that may or may not exist without throwing         TypeError  Cannot set property  x  of undefined     const maybe    x    gt   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   map params   name         This handles the original parse issue and a few more function types  e g  arrow functions   Here s an idea of what it can and can t handle as is       I usually use mocha as the test runner and chai as the assertion library describe  Extracts argument names from function signature          gt        const test    func    gt            const expectation     it    parses    me            const result   parseFunctionArguments toBeParsed           result should equal expectation               it  Parses a function declaration         gt            function toBeParsed it  parses  me             test toBeParsed                it  Parses a functional expression         gt            const toBeParsed   function it  parses  me             test toBeParsed                it  Parses an arrow function        gt            const toBeParsed    it  parses  me    gt              test toBeParsed                                     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        gt            function toBeParsed it 4  5 3   parses  me             test toBeParsed                   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        gt            function toBeParsed   it  parses  me             test toBeParsed                it  Parses object destructuring param definitions        gt            function toBeParsed   it  parses  me             test toBeParsed                   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        gt            class ToBeParsed               constructor it  parses  me                       test ToBeParsed                 Depending on what you want to use it for ES6 Proxies and destructuring may be your best bet  For example if you wanted to use it for dependency injection  using the names of the params  then you can 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    gt                console log 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    gt  container resolve name                       You shouldn t be able to set values on the injector                  set   target  name  value    gt                        throw new Error  Don t try to set   name                                                    return new klass paramParser                       It s not the most advanced resolver out there but it gives an idea of how you can use a Proxy to handle it if you want to use args parser for simple DI  There is however one slight caveat in this approach  We need to use destructuring assignments instead of normal params  When we pass in the injector proxy the destructuring is the same as calling the getter on the object    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      This outputs the following          tweeter              api                  client                            timeline              api                  client                          Its wired up the entire application  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  There is a lot of work that would need to be done to this before it would be ready for production use but it does give an idea of what it would look like   It s a bit late in the answer but it may help others who are thinking of the same thing

User · Answer

Since JavaScript is a scripting language  I feel that its introspection should support getting function parameter names   Punting on that functionality is a violation of first principles  so I decided to explore the issue further   That led me to this question but no built-in solutions   Which led me to this answer which explains that arguments is only deprecated outside the function  so we can no longer use myFunction arguments or we get   TypeError   caller    callee   and  arguments  properties may not be accessed on strict mode functions or the arguments objects for calls to them   Time to roll up our sleeves and get to work     Retrieving function parameters requires a parser because complex expressions like 4  5 3  can be used as default values   So Gaafar s answer or James Drew s answer are so far the best approaches   I tried the babylon and esprima parsers but unfortunately they can t parse standalone anonymous functions  as pointed out in Mateusz Charytoniuk s answer   I figured out another workaround though by surrounding the code in parentheses  so as not to change the logic   const ast   parser parse    n    func toString       n      The newlines prevent issues with     single-line comments      If a parser is not available  the next-best option is to use a tried-and-true technique like Angular js s dependency injector regular expressions   I combined a functional version of Lambder s answer with humbletim s answer and added an optional ARROW boolean for controlling whether ES6 fat arrow functions are allowed by the regular expressions     Here are two solutions I put together   Note that these have no logic to detect whether a function has valid syntax  they only extract the arguments   This is generally ok since we usually pass parsed functions to getArguments   so their syntax is already valid   I will try to curate these solutions as best I can  but without effort from the JavaScript maintainers  this will remain an open problem   Node js version  not runnable until StackOverflow supports Node js     x000D   x000D  const parserName    babylon   x000D     const parserName    esprima   x000D  const parser   require parserName   x000D   x000D  function getArguments func    x000D      const maybe   function  x    x000D          return x           optionals support x000D        x000D   x000D      try   x000D          const ast   parser parse    n    func toString       n     x000D          const program   parserName     babylon    ast program   ast  x000D   x000D          return program x000D               body 0  x000D               expression x000D               params x000D               map function node    x000D                  return node name    maybe node left  name            maybe node argument  name  x000D                  x000D        catch  e    x000D          return        could also return null x000D        x000D     x000D   x000D             TESTS            x000D   x000D  function logArgs func    x000D   let object       x000D   x000D   object func    getArguments func   x000D   x000D   console log object   x000D      console log   JSON stringify   getArguments func         x000D    x000D   x000D  console log      x000D  console log             MISC               x000D   x000D  logArgs  a  b    gt       x000D  logArgs  a  b   1    gt       x000D  logArgs  a  b     args    gt       x000D  logArgs function a  b     args       x000D  logArgs function a  b   1  c   4    5   3   d   2       x000D  logArgs async function a  b     args       x000D  logArgs function async a  b     args       x000D   x000D  console log      x000D  console log             FUNCTIONS               x000D   x000D  logArgs function a  b  c       x000D  logArgs function        x000D  logArgs function named a  b  c       x000D  logArgs function a      1     b      true          x000D  logArgs function fprintf handle  fmt                 x000D  logArgs function a  b   1  c       x000D  logArgs function a   4    5   3   b       x000D     logArgs function  a     single-line comment xjunk       x000D     logArgs function  a    fooled you      x000D     logArgs function  a    function   yes      n    no    b    omg          x000D     logArgs function   A  b  n c  d  n    n      x000D  logArgs function a  b       x000D  logArgs function  args func       x000D  logArgs null   x000D  logArgs function Object        x000D   x000D  console log      x000D  console log             STRINGS               x000D   x000D  logArgs  function  a b c        x000D  logArgs  function          x000D  logArgs  function named a  b  c        x000D  logArgs  function  a      1     b      true           x000D  logArgs  function fprintf handle  fmt                  x000D  logArgs  function  a  b   1  c         x000D  logArgs  function  a 4  5 3   b        x000D  logArgs  function  a     single-line comment xjunk        x000D  logArgs  function  a    fooled you       x000D  logArgs  function  a    function   yes      n    no    b    omg           x000D  logArgs  function   A  b  n c  d  n    n       x000D  logArgs  function  a b        x000D  logArgs  function  args func        x000D  logArgs  null    x000D  logArgs  function Object         x000D   x000D   x000D    Full working example   https   repl it repls SandybrownPhonyAngles  Browser version  note that it stops at the first complex default value     x000D   x000D  function getArguments func    x000D      const ARROW   true  x000D      const FUNC ARGS   ARROW      function   s          s            m      function  s          s            m  x000D      const FUNC ARG SPLIT        x000D      const FUNC ARG      s           1 s     x000D      const STRIP COMMENTS                      s S          mg  x000D   x000D      return   func        toString   replace STRIP COMMENTS      match FUNC ARGS                   2  x000D           split FUNC ARG SPLIT  x000D           map function arg    x000D              return arg replace FUNC ARG  function all  underscore  name    x000D                  return name split      0  trim    x000D                  x000D             x000D           filter String   x000D    x000D   x000D             TESTS            x000D   x000D  function logArgs func    x000D   let object       x000D   x000D   object func    getArguments func   x000D   x000D   console log object   x000D      console log   JSON stringify   getArguments func         x000D    x000D   x000D  console log      x000D  console log             MISC               x000D   x000D  logArgs  a  b    gt       x000D  logArgs  a  b   1    gt       x000D  logArgs  a  b     args    gt       x000D  logArgs function a  b     args       x000D  logArgs function a  b   1  c   4    5   3   d   2       x000D  logArgs async function a  b     args       x000D  logArgs function async a  b     args       x000D   x000D  console log      x000D  console log             FUNCTIONS               x000D   x000D  logArgs function a  b  c       x000D  logArgs function        x000D  logArgs function named a  b  c       x000D  logArgs function a      1     b      true          x000D  logArgs function fprintf handle  fmt                 x000D  logArgs function a  b   1  c       x000D  logArgs function a   4    5   3   b       x000D     logArgs function  a     single-line comment xjunk       x000D     logArgs function  a    fooled you      x000D     logArgs function  a    function   yes      n    no    b    omg          x000D     logArgs function   A  b  n c  d  n    n      x000D  logArgs function a  b       x000D  logArgs function  args func       x000D  logArgs null   x000D  logArgs function Object        x000D   x000D  console log      x000D  console log             STRINGS               x000D   x000D  logArgs  function  a b c        x000D  logArgs  function          x000D  logArgs  function named a  b  c        x000D  logArgs  function  a      1     b      true           x000D  logArgs  function fprintf handle  fmt                  x000D  logArgs  function  a  b   1  c         x000D  logArgs  function  a 4  5 3   b        x000D  logArgs  function  a     single-line comment xjunk        x000D  logArgs  function  a    fooled you       x000D  logArgs  function  a    function   yes      n    no    b    omg           x000D  logArgs  function   A  b  n c  d  n    n       x000D  logArgs  function  a b        x000D  logArgs  function  args func        x000D  logArgs  null    x000D  logArgs  function Object         x000D   x000D   x000D    Full working example   https   repl it repls StupendousShowyOffices

[javascript] How to get function parameter names/values dynamically?

Examples related to javascript

Examples related to reflection

Examples related to function-parameter