4

I have a JavaScript function which accepts a function as a parameter, like this:

var myFunction = function(funParameter) {
    // funParameter is a function
};

I can call this function like this:

myFunction(function (aParameter, anotherOne) {
    // do stuff
});

Inside the body of myFunction, how can I retrieve the parameters that funParameter is supposed to receive? I want to know the parameters declared with the function passed to myFunction (in the above case, I want to know the the parameter function accepts aParameter and anotherOne.

Only way I know of doing this is by parsing appropriately funParameter.toString(), but I feel like it's kind of hacky.

It should be like in Mocha tests:

it('should test something synchronously', function () {...});
it('should test something asynchronously', function (done) {
    // test...
    done();
});

You have to be able to behave differently if the function you pass to it accepts a done parameter or not.

Improve this question
3
  • I think you're stuck with toString... AFAIK no there's no other way . Commented Sep 4, 2013 at 21:49
  • 2
    I'm intrigued by the question (so +1), but I look at it and can't help but think (along the lines of) "good grief, what on earth are you doing, and why?" Commented Sep 4, 2013 at 21:51
  • @DavidThomas :) That's ok, it's quite uncomfortable for me too. But hey, look at the it function from the Mocha test suit: how the hell do they do that? Commented Sep 4, 2013 at 21:53

3 Answers 3

Reset to default
3

What you want is this. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length

Unless the parameter names are guaranteed to be consistent throughout the code and will never be tempered by any means, you do not want to check if the parameter is named, 'done', Most of cases, developers should be free to name their function parameters.

Besides, javascript code (for browser) is usually uglified and mangled, and parameter names are shortened. If the names are changed, it is going to break your function.

However, what you rather want to do is to decide how many parameters are specified by the function and that can be done by Function.length.

Yet, this is not a reliable solution either, because you can always not specify anything and still get the parameter values using arguments.

In JavaScript, it is usually bad idea to assume that something will work in the way I intended. Because you never know who's going to do what with their codes.

The language itself is so dynamic in so many ways, you have to be really careful before designing your functions / API.

from MDN:

console.log( (function () {}).length );  /* 0 */
console.log( (function (a) {}).length ); /* 1 */
console.log( (function (a, b) {}).length ); /* 2 etc. */
console.log( (function (...args) {}).length ); /* 0, rest parameter is not counted */
Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

This is a way to solve the problem, but you could need the named parameters, like in AngularJS (as mentioned in previous answers).
"You do not want to check if the parameter is named 'done'"-- Well, it all depends on what you're trying to do. AngularJS does something like what OP is asking for dependency injection. The number of parameters and the order is trivial, what matters is the name. Another example is John Resig's tmpl used toString on function to find the super class.
It is not a reliable solution. what if the code is uglified and parameter names are changed?
Perhaps I phrased that badly; I meant to say that if the OP has a situation in which the name of the parameter is important (and without further information as to why, it becomes difficult to argue against the need), then I tend to believe that it's necessary. By all means offer an argument against the need, or the use, or suggest alternatives; but to declare You do not want to check if the parameter is named, 'done' is a little presumptuous (and your argument against doesn't really carry significant weight, albeit 'imho' and so forth).
Again, "John Resig did it" does not make it right. I respect John Resig and what he has done, but the solution he presented should not be used in libraries for browsers.
|
1

If you're looking for specifically how Mocha does it, look at the source code.

I dug into a bit and found that Mocha is simply checking the length property of the passed function as you see in this source file. They then do an if check for the async property, shown below. If async is true, it calls the test function in a different way to handle the async nature of the test function.

this.async = fn && fn.length
Improve this answer

Comments

0

Getting function parameters by Function.prototype.toString is hacky indeed. So far, despite not being in the specs, it is very well supported by all browsers I have tested, and is used by AngularJS to map requested controller capabilities by unordered parameter name.

function myFunction(func) {
    var params = func.toString()
        .match(/function\s*.*\((.+)\)/)[1]
        .split(',');

    return params;  // ['aParameter', 'anotherOne']
}

*source modeified from 'functools'

Improve this answer

2 Comments

Ok, I was afraid of that. Anyway, your function is kind of buggy if the function has no parameters or spaced parameters? This should be better: function pars(fun) { return fun.toString.match(/function.*?\((.*?)\)/)[1].split(',').map(function (el) { return el.trim(); }) }
Wow, it doesn't look that good in a comment. I'll edit your answer.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.