_.transform Applies a function to perform transformation on the object

[ming-codes]

The goal is to supply a function to work with the object itself. Most underscore functions work with collections and treats objects as only associative array. #1068 may be related, but that pull request still work the object as an associative array.

The main use case is during chaining that you'll want to apply a certain function to the wrapped object.

// The goal of this snippet is to select cells in table,
// do filter on them, then wrap it back as a jQuery object
_.chain($('td')) // One of the great thing about underscore is
                     // that it work with any array-like object
  .groupBy('cellIndex')
  .sortBy(function(__, key) {
    return Number(key)
  })
  .first()
  .transform($)
  .value()
  .css('background-color', 'red')

Alternative solution without _.transform may be ugly because it disrupts the structure flow.

$(_.chain($('td'))
  .groupBy('cellIndex')
  .sortBy(function(__, key) {
    return Number(key)
  })
  .first())
  .value()
  .css('background-color', 'red')

Naming-wise, it may be more appropriate to call it apply. But since the _ object is itself a function and we don't want to override Function.prototype.apply, I came up with the transform alternative.

Alternatively, the functionality may be merged with either _.chain().value(function) or _.tap(function) by making the chain returns tap's function return value if it does return something. Something like this

_.tap = function(obj, inter) {
  return inter(obj) || obj
}

[jashkenas]

Very interesting. This is only useful in the middle of a _.chain, correct?

[ming-codes]

@jashkenas While that is true, I like to think of it as playing friendly with other libraries. :)

Also, before this, the only way to apply your own function on the wrapped object while still keeping it under wrap is through _.mixin. This may not be the optimal solution when the function you want to apply is a curried function.

[ming-codes]

But that would mask the other map, and they do have the same signature.

On Jun 20, 2013, at 6:59 AM, "Mario T. Lanza" [email protected] wrote:

transform is essentially map applied to a single object. Perhaps it makes sense to use the term map for consistency?

—
Reply to this email directly or view it on GitHub.

[jdalton]

I think the name passthru is more descriptive.

[ming-codes]

@mlanza _.map is already overloaded to accept either an array or hash object. I don't know how you can overload it more without adding another flag param

http://underscorejs.org/#map

I'm liking _.passthru best so far. It appropriately describes what it do without name clashing with other functions.

[jdalton]

The reason passthru is a better choice is because the func function doesn't necessarily have to transform the value passed to it. For example:

// the number is passed thru `Object` and converted to an object
_(2).chain().passthru(Object).isObject().value(); // true

// the object is passed thru `Object` and returned unmodified
_({a: 1}).chain().passthru(Object).isObject().value(); // true

[jashkenas]

Neat. I don't think it's quite useful enough to merit the complexity of explaining how to use it.

Most of the time, to transform, you'll want to map in the middle of your chain to do so. In cases like this, where you've called first, or want to transform the entire collection, it's not too bad to break out of the chain to do so.

[ming-codes]

For anyone that's still looking for this function, lodash now has it.

http://lodash.com/docs#transform