When leveraging the utilities provided by Underscore or Lo-dash, determining if an Array, String or Object is empty is quite simple via the isEmpty() method.
The isEmpty() method and Objects
In the context of an Object, it is important to keep in mind that _.isEmpty() is implemented such that it determines an Object as being empty in a literal sense. That is, objects are traversed to determine the existence of any own properties – irrespective of their actual values. Thus, _.isEmpty() will return false if an object contains any own properties, even if all property values are undefined, otherwise it will return true.
While these details may seem obvious, it is important to be mindful of them in order to avoid potential false positives when trying to determine if an object’s properties are all undefined.
For example, consider the following object:
1 2 3 4 5 6 | var obj = { 'firstName': undefined , 'lastName' : undefined }; |
Technically, the above object is not empty, as it contains two own properties. Thus, invoking _.isEmpty() with this object will return false, which is correct, though one may have mistakenly assumed it to have returned true since all of the object’s properties are undefined.
1 2 3 4 5 6 7 | var obj = { 'firstName': undefined , 'lastName' : undefined }; _.isEmpty(obj); // false |
Extending Underscore / Lo-dash
With an understanding in mind of how _.isEmpty() is implemented in the context of objects, should one need to determine if an object is empty based on the values of it’s own properties being undefined, a simple extension, such as the following, can be mixed into Underscore or Lo-dash to provide both the default implementation as well as an extended implementation which takes this into account:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | /* * Provides a convenience extension to _.isEmpty which allows for * determining an object as being empty based on either the default * implementation or by evaluating each property to undefined, in * which case the object is considered empty. */ _.mixin( function() { // reference the original implementation var _isEmpty = _.isEmpty; return { // If defined is true, and value is an object, object is considered // to be empty if all properties are undefined, otherwise the default // implementation is invoked. isEmpty: function(value, defined) { if (defined && _.isObject(value)) { return !_.any( value, function(value, key) { return value !== undefined; }); } return _isEmpty(value); } } }()); |
Given the above, we can then invoke the original isEmpty implementation, as well as the extended implementation as follows:
1 2 3 4 5 6 7 8 9 10 11 | var obj = { 'firstName': undefined , 'lastName' : undefined }; // invoke the original implementation _.isEmpty(obj); // false // invoke the extended implementation, by passing true _.isEmpty(obj, true); // true |
The ease with which libraries such as Underscore and Lo-dash allow for adding extensions and overriding default implementations is a key design feature which makes them not only extremely flexible, but also quite enjoyable to work with as well.