A javascript plugin to create a comparator for one or more properties of an object. Comparators are useful for sorting arrays of objects, and for general comparisons in, for example, if statements. The comparison is done only if the types of both objects'

objectcomparator.joelpurra.js

/*!
 * @license ObjectComparator
 * Copyright © 2012 Joel Purra <http://joelpurra.se/>
 * Released under MIT, BSD and GPL license. Comply with at least one.
 *
 * A javascript plugin to create a comparator for one or more properties of an object.
 * Comparators are useful for sorting arrays of objects, and for general comparisons
 * in, for example, if statements.
 * The comparison is done only if the types of both objects' property matches.
 */
// https://gist.github.com/2984763
//
// USAGE
//  var comparator = JoelPurra.createComparator("propertyName");
//  var reverseComparator = JoelPurra.createComparator("!propertyName");
//  var comparators = JoelPurra.createComparators(["propertyName1", "propertyName2"]);
//  var mixedComparators = JoelPurra.createComparators(["propertyName1", "!propertyName2"]);
// EXAMPLE
// var people = [
//  // Age in years, length in centimeters
//     { name: "John", age: 30, height: 187 },
//     { name: "Bilbo", age: 111, height: 112 },
//     { name: "Jane", age: 30, height: 165 },
//     { name: "Gollum", age: 570, height: 112 }
// ];
// // Sort by height (ascending) only
// var shortToLongComparator = JoelPurra.createComparator("height");
// people.sort(shortToLongComparator);
// // => Bilbo, Gollum, Jane, John
// // Sort by height (ascending) and age (descending)
// var shortToLongOldToYoungComparator = JoelPurra.createComparators(["height", "!age"]);
// people.sort(shortToLongOldToYoungComparator);
// => Gollum, Bilbo, Jane, John
//
/*jslint white: true*/

// Set up namespace, if needed
var JoelPurra = JoelPurra || {};

(function(namespace) {
    "use strict"; // jshint ;_;
    namespace.createNormalComparator = function(property) {
        // This comparison is not as relaxed as normal comparisons. The type is checked first, and it has
        // to match in order to continue.
        //
        // https://developer.mozilla.org/en/JavaScript/Guide/Expressions_and_Operators#Comparison_operators
        // "The operands can be numerical, string, logical, or object values.
        //  Strings are compared based on standard lexicographical ordering, using Unicode values.
        //  In most cases, if the two operands are not of the same type, JavaScript attempts to convert
        //  the operands to an appropriate type for the comparison."
        return function(a, b) {
            if (typeof(a) !== typeof(b)) {
                throw new Error("object property \"" + property + "\" was not of the same type in a and b.");
            }

            // Using strict comparison now that the object types are the same
            if (a[property] === b[property]) {
                return 0;
            }

            if (a[property] < b[property]) {
                return -1;
            }

            if (a[property] > b[property]) {
                return 1;
            }

            throw new Error("Could not compare objects and find a matching result");
        };
    };

    namespace.createReverseComparator = function(property) {
        // Calling the parent function actually allows for properties like
        // "!!age" for "reverse reverse age comparator" ;)
        var comparator = namespace.createComparator(property);

        return function(a, b) {
            return comparator(b, a);
        };
    };

    namespace.createComparator = function(property) {
        var comparator;

        if (property.substring(0, 1) === "!") {
            property = property.substring(1);
            comparator = namespace.createReverseComparator(property);
        } else {
            comparator = namespace.createNormalComparator(property);
        }

        return comparator;
    };

    namespace.createComparators = function(properties) {
        var comparators = [],
            i;

        for (i = 0; i < properties.length; i += 1) {
            comparators.push(namespace.createComparator(properties[i]));
        }

        return function(a, b) {
            var result = 0,
                i, comparator;

            for (i = 0; i < comparators.length; i += 1) {
                comparator = comparators[i];

                result = comparator(a, b);

                if (result !== 0) {
                    break;
                }
            }

            return result;
        };
    };

}(JoelPurra));