Remove empty properties / falsy values from Object

Question

I have an object with several properties. I would like to remove any properties that have falsy values.

This can be achieved with compact on arrays, but what about objects?

Answer 1

You can create a shallow clone:

_(obj).reduce(function(a,v,k){ 
     if(v){ a[k]=v; } 
     return a; 
},{});

Answer 2

With lodash's transform,

_.transform(obj, function(res, v, k) {
  if (v) res[k] = v;
});

Answer 3

To add to gion_13's answer:

_.mixin({
  compactObject : function(o) {
     var newObject = {};
     _.each(o, function(v, k) {
       if(v !== null && v !== undefined) {
         newObject[k] = v
       }
     });
     return newObject;
  }
});

This one creates a new object and adds keys and values instead of cloning everything and deleting key-value pairs. Minor difference.

But more importantly, checks explicitly for null and undefined instead of falsey, which will delete key-value pairs that have false as a value.

Answer 4

Since Underscore version 1.7.0, you can use _.pick:

_.pick(sourceObj, _.identity)

Explanation

The second parameter to _.pick can be a predicate function for selecting values. Values for which the predicate returns truthy are picked, and values for which the predicate returns falsy are ignored.

pick _.pick(object, *keys)

Return a copy of the object, filtered to only have values for the whitelisted keys (or array of valid keys). Alternatively accepts a predicate indicating which keys to pick.

_.identity is a helper function that returns its first argument, which means it also works as a predicate function that selects truthy values and rejects falsy ones. The Underscore library also comes with a bunch of other predicates, for instance _.pick(sourceObj, _.isBoolean) would retain only boolean properties.

If you use this technique a lot, you might want to make it a bit more expressive:

var pickNonfalsy = _.partial(_.pick, _, _.identity); // Place this in a library module or something
pickNonfalsy(sourceObj);

Underscore version 1.6.0 provided _.pick as well, but it didn't accept a predicate function instead of a whitelist.

Answer 5

Suddenly I needed create a function to remove recursively falsies. I hope this helps. I'm using Lodash.

var removeFalsies = function (obj) {
    return _.transform(obj, function (o, v, k) {
        if (v && typeof v === 'object') {
            o[k] = _.removeFalsies(v);
        } else if (v) {
            o[k] = v;
        }
    });
};

_.mixin({ 'removeFalsies': removeFalsies });

Then you can use it:

var o = _.removeFalsies({
  foo: 'bar',
  a: 0,
  b: false,
  c: '',
  d: null,
  e: undefined,
  obj: {
    foo: 'bar',
    a: 0,
    b: false,
    c: '',
    d: null,
    e: undefined
  }
});

// {
//   foo: 'bar',
//   obj: {
//     foo: 'bar'
//   }
// }

Answer 6

Although _.compact is documented for use in arrays. It seems to work for objects too. I just ran the following in chrome, opera and firefox consoles:

var obj = {first: 1, second: null, third: 3, fourth: function(){return 5}}
undefined
_.compact(obj)

[1, 3, function()]

UPDATE: As the sample indicates calling _.compact on an object will drop the keys and return a compacted array.