How can I deal with optional parameters in JavaScript?

Question

I would like a function 'get' that takes an id, an optional property parameter and a callback function. It would be used like so:

get(14297, 'name', function processName(name) {...});
get(14297, function processStudent(student) {...});

I have included one possible implementation below

function get(id, property, callback) {
    var item = ...;
    // property is callback
    if (!callback) property(item);
    // callback is callback
    else callback(item[property])
}

It feels a little bit weird because

property(item);

Is actually a callback function depending on the context. Is there a better way to do this?

Which parameters are "required", only id, or callback as well? — Richard
– Richard, Commented May 15, 2012 at 8:39

Amberlamps · Accepted Answer · 2012-05-15 08:40:38Z

4

You should switch the parameters. Try this

function get(id, callback, property)
{
    if(typeof property === "undefined")
        callback(item);
    else
        callback(item[property]);
}

answered May 15, 2012 at 8:40

Amberlamps

40.7k6 gold badges46 silver badges54 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Alnitak Over a year ago

there are plenty of examples in the jQuery source where the middle parameters are optional - it doesn't have to be the last ones.

Alnitak Over a year ago

indeed not, just pointing out that it is not uncommon to have optional middle parameters

Amberlamps Over a year ago

If you need a framework to handle that, it might be uncommon in native JavaScript!

Alnitak Over a year ago

sigh - I'm not suggest that you need a framework for it! The jQuery API just happens to use this feature.

RobG · Accepted Answer · 2012-05-15 08:58:31Z

2

You can change the order of parameters, or test what the function is given to work out what they are. e.g.

function get(id, property, callback) {
  if (arguments.length == 2) {
    // second argument is callback
    callback = property;
    property = void 0;
  }
  ...
}

or

function get(id, property, callback) {
  if (typeof property == 'function') {
    // second argument is callback
    callback = property;
    property = void 0;
  }
  ...
}

and so on, but that type of overloading is not particularly liked.

edited May 15, 2012 at 8:58

answered May 15, 2012 at 8:53

RobG

148k32 gold badges180 silver badges216 bronze badges

Comments

Alnitak · Accepted Answer · 2012-05-15 08:58:28Z

2

This is the pattern used by jQuery:

function get(id, property, callback) {

    // if the 2nd parameter is a function, assume that
    // only two parameters were supplied
    if (typeof property === 'function') {
         callback = property;
         property = undefined;
    }

    ...
}

Effectively, if it sees unexpected parameter types it just shuffles their contents around until they match the alternative definition.

edited May 15, 2012 at 8:58

answered May 15, 2012 at 8:52

Alnitak

341k72 gold badges420 silver badges503 bronze badges

6 Comments

RobG Over a year ago

The arguments object isn't a pseudo–array, it's just an arguments object.

Alnitak Over a year ago

@RobG I've changed my answer, but AFAIK arguments is a pseudo-array. Is has .length and [n] properties, and subsequently can be coerced into a real array using [].prototype.slice().

Amberlamps Over a year ago

That does not handle empty middle parameter naturally. You have to know what to expect as value of the parameter. Maybe jQuery has to deal with this stuff so that the user can use their methods as they like. But if the OP is implementing the method himself, he should not implement it that way!

RobG Over a year ago

@Alnitak—pseudo actually means "false" or "pretend", something masquerading as something it isn't. The arguments object does have a length parameter, and it's members can be accessed by index, but that's where the similarity ends. Array.prototype methods are mostly (all?) specified as generic so as to work on any suitable native (and often host) object. It might be called a quasi–array, but maybe I'm being pedantic. ;-)

Alnitak Over a year ago

@RobG if it walks like a duck, and quacks like a duck, it's a pseudo-duck ;-) Unsure about your last sentence - by definition functions on Array.prototype cannot work directly on arguments since its prototype is wrong. Can you expand, or give an example?

|

Florian Margaine · Accepted Answer · 2012-05-15 08:58:20Z

0

The arguments object is immutable. But you can slice it in an array, pop the last argument and deal with the other arguments as you normally would, since you know the callback argument isn't in it anymore.

Here is a way to do this:

function get() {
    // Copy the `arguments` object in an array, since it's immutable
    var args = Array.prototype.slice.call( arguments, 1 ),

    // Pop the last argument of the arguments
        callback = args.pop();

    // Then deal with other arguments
    // For example, check for the existence of the second argument
    if ( args[1] ) {
    }

    // Then, you can call the callback function
    callback();
}

edited May 15, 2012 at 8:58

answered May 15, 2012 at 8:52

Florian Margaine

61.2k15 gold badges94 silver badges120 bronze badges

Collectives™ on Stack Overflow

How can I deal with optional parameters in JavaScript?

4 Answers 4

4 Comments

Comments

6 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

4 Comments

Comments

6 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related