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

←→

Underscore Chain A Formidable Labs tech talk by Ryan Roemer