Underscore Chain
A Formidable Labs tech talk by Ryan Roemer

Underscore Chain

Underscore is a library we use everyday.

Today, we'll look at the enormously useful chain method.

Familiar Underscore Methods

We can take all the methods we normally use:

filter
object
keys
map
first

... and chain them!

Basic Chains

var arr = [1, 2, 3],
  double = function (x) { return 2 * x; },
  
  // Single. map.
  map1 = _.map(arr, double),
  
  // Converted to a chain.
  map2 = _.chain(arr).map(double).value();
  
console.log("maps: ", map1, map2);

A Little More Complex

// Keep values starting with "b", sort and upper case.
var ret = _.chain(["bug", "foo", "bar", "baz"])
  .filter(function (val) { return /^b/.test(val); })
  .sortBy(function (val) { return val; })
  .map(function (val) { return val.toUpperCase(); })
  .value()
  
console.log("results: ", ret);

Objects

// Remove property with value "c".
var ret = _.chain({ foo: "a", bar: "b", baz: "c" })
  .map(function (v, k) { return [k, v]; })
  .filter(function (p) { return p[1] !== "c"; })
  .object()
  .value()
  
console.log("results: ", ret);

Reductions

// Sum lengths of string values.
var ret = _.chain({ foo: "foo", bar: "b", baz: "car" })
  .map(function (v) { return v.length; })
  .reduce(function (m, v) { return m + v; })
  .value()
  
console.log("results: ", ret);

Object Traversal

// Traverse and object by string path
var obj = { foo: { bar: { baz: "hi" }} };
var traverse = function (path) {
  return _.reduce(path.split("."), function (o, k) {
    return k ? o[k] : o;
  }, obj);
};

console.log("\"\": ", traverse(""));
console.log("foo: ", traverse("foo"));
console.log("foo.bar: ", traverse("foo.bar"));
console.log("foo.bar.baz: ", traverse("foo.bar.baz"));

Object Creation

// Create object with nested value.
var create = function (path, val) {
  var obj = {}
  _.reduce(path.split("."), function (cur, key, idx, list) {
    // Set each part to new {} except for last.
    return (cur[key] = idx + 1 === list.length ? val : {});
  }, obj);
  return obj;
};

console.log("foo: ", create("foo", "hi"));
console.log("foo.bar: ", create("foo.bar", "hi"));
console.log("foo.bar.baz: ", create("foo.bar.baz", "hi"));

A Practical Example

var obj = {"Foo-Item": "a", "Foo-Customer": "b", "Bar-Item": "c"},
  keys = ["Customer", "CustomerCart", "Item"];
  
var _iter = function () {
  var count = 0;
  for (var idx = 0; idx < keys.length; idx++) {
    for (var key in obj) {
      if (obj.hasOwnProperty(key) && key === "Foo-" + keys[idx]) {
        count++;
      }
    }
  }
  return count;
}

var _chain = function () {
  return _.chain(keys)
    .filter(function (k) { return _.has(obj, "Foo-" + k); })
    .reduce(function (m) { return m + 1; }, 0)
    .value();
}

console.log("_iter:  " + _iter());
console.log("_chain: " + _chain());

And Everything Else!

Chain nearly any other methods from Underscore.

var obj = [];
var ret = _.chain(obj)
  .value()
  
console.log("results: ", ret);

Thanks!

Read more about chain at: http://underscorejs.org/#chain

formidablelabs.github.io/underscore-chain-talk

github.com/FormidableLabs/underscore-chain-talk

←→

1/12

Underscore Chain A Formidable Labs tech talk by Ryan Roemer