Allow _.result to be passed arguments

[caseywebdev]

I also changed the test file to include the uncompressed underscore, seemed odd that it was using the minified version...

[jashkenas]

The reason why we didn't allow result to be passed arguments is because it breaks the parity.

_.result(object, 'key', 1, 2, function(callback){ ... });

If object.key happens to be a value instead of a function, then the arguments are completely ignored. I can't think of many situations in which the property may be a value or a function (the only use case in which _.result is useful) and you'd also want to pass arguments.

[caseywebdev]

Possibly for things like Backbone options or cases where one property for objA is more complex than that prop for objB?

peeps = [
  name: 'Cher'
,
  name: (full) -> "Arnold#{if full then ' Schwarzenegger' else ''}"
]
names = _.map peeps, (peep) -> _.result peep, 'name'
fullNames = _.map peeps, (peep) -> _.result peep, 'name', true

I think it could be useful. Also, this is also where that _.f function would have been handy as _.invoke only does functions, and _.pluck only does values, but _.f would do whichever is appropriate (e.g. _.map peeps, _.f 'name', true).

[eastridge]

Note that if this get's merged in I'd like to see the signature be:

_.result(obj, key [,scope] [,...])

Totally self serving but I think if this level of granularity is added it may as well act as an apply alias on top of the existing functionality.

[StreetStrider]

I think that _.result method must do only one thing: check property, and invoke if it a function. Don't break Single responsibility principle.
Consider some object on which we wanna use _.result. We can use Function.bind to set context for functions and also set parameters if we need. Result of binding will be the function that have signature with no parameters and it can be simply invoked with _.result.

var x = { basis: 42 };
x.prop = function (param) { return this.basis * param; };

Use binding:

x.prop = x.prop.bind(x, -1);
_.result(x, 'basis');
// 42
_.result(x, 'prop');
// -42

[jashkenas]

Yep -- closing for the reason explained above. We don't want to allow you to pass arguments to a value that's not a function, and have them be ignored.

[opensas]

Just to make it clear (it's not stated in the documentation, but I can see it in the source)

The context of the function will be set to this, right?

Cause I thought it might be useful to pass the object itself as a parameter, but I see you can access it with the this keyword. (BTW, this should be added to the documentation)

Anyway, if we would pass the object as a parameter, we could bind the function to some other context instead...

[akre54]

@opensas yep: https://github.com/documentcloud/underscore/blob/1.4.4/underscore.js#L1063

The function is called with the object argument passed as the context. You should be able to do exactly as you suggested.

[opensas]

Thanks a lot, I've just sent a pull request to update the documentation. #1007

[maratbn]

If object.key happens to be a value instead of a function, then the arguments are completely ignored...

true, but that should be fine.

The use case for which this would be necessary is to be able to proxy options to 'url(...)' via 'fetch(...)'. More discussion of that in this issue: jashkenas/backbone#3108