One of my favorite answers on stackoverflow

I’ll add the entire post below, but please also read it on stackoverflow the answer deserves the attention.

Thank you Jon for some great code and explanation.

Introducing: a very generalized solution for PHP 5.3+

I ‘d like to add my own solution here, since it offers features that other answers do not.

Specifically, advantages of this solution include:

  1. It’s reusable: you specify the sort column as a variable instead of hardcoding it.
  2. It’s flexible: you can specify multiple sort columns (as many as you want) — additional columns are used as tiebreakers between items that initially compare equal.
  3. It’s reversible: you can specify that the sort should be reversed — individually for each column.
  4. It’s extensible: if the data set contains columns that cannot be compared in a “dumb” manner (e.g. date strings) you can also specify how to convert these items to a value that can be directly compared (e.g. aDateTime instance).
  5. It’s associative if you want: this code takes care of sorting items, but you select the actual sort function (usort or uasort).
  6. Finally, it does not use array_multisort: while array_multisort is convenient, it depends on creating a projection of all your input data before sorting. This consumes time and memory and may be simply prohibitive if your data set is large.

The code


  function make_comparer() {
    // Normalize criteria up front so that the comparer finds everything tidy
    $criteria = func_get_args();
    foreach ($criteria as $index => $criterion) {
        $criteria[$index] = is_array($criterion)
            ? array_pad($criterion, 3, null)
            : array($criterion, SORT_ASC, null);
    }

    return function($first, $second) use (&$criteria) {
        foreach ($criteria as $criterion) {
            // How will we compare this round?
            list($column, $sortOrder, $projection) = $criterion;
            $sortOrder = $sortOrder === SORT_DESC ? -1 : 1;

            // If a projection was defined project the values now
            if ($projection) {
                $lhs = call_user_func($projection, $first[$column]);
                $rhs = call_user_func($projection, $second[$column]);
            }
            else {
                $lhs = $first[$column];
                $rhs = $second[$column];
            }

            // Do the actual comparison; do not return if equal
            if ($lhs < $rhs) {
                return -1 * $sortOrder;
            }
            else if ($lhs > $rhs) {
                return 1 * $sortOrder;
            }
        }

        return 0; // tiebreakers exhausted, so $first == $second
    };
}

How to use

Throughout this section I will provide links that sort this sample data set:


$data = array(
    array('zz', 'name' => 'Jack', 'number' => 22, 'birthday' => '12/03/1980'),
    array('xx', 'name' => 'Adam', 'number' => 16, 'birthday' => '01/12/1979'),
    array('aa', 'name' => 'Paul', 'number' => 16, 'birthday' => '03/11/1987'),
    array('cc', 'name' => 'Helen', 'number' => 44, 'birthday' => '24/06/1967'),
);

The basics

The function make_comparer accepts a variable number of arguments that define the desired sort and returns a function that you are supposed to use as the argument to usort or uasort.

The simplest use case is to pass in the key that you ‘d like to use to compare data items. For example, to sort$data by the name item you would do

usort($data, make_comparer('name'));

See it in action.

The key can also be a number if the items are numerically indexed arrays. For the example in the question, this would be

usort($data, make_comparer(0)); // 0 = first numerically indexed column

See it in action.

Multiple sort columns

You can specify multiple sort columns by passing additional parameters to make_comparer. For example, to sort by “number” and then by the zero-indexed column:

usort($data, make_comparer('number', 0));

See it in action.

Advanced features

More advanced features are available if you specify a sort column as an array instead of a simple string. This array should be numerically indexed, and must contain these items:


0 => the column name to sort on (mandatory)
1 => either SORT_ASC or SORT_DESC (optional)
2 => a projection function (optional)

Let’s see how we can use these features.

Reverse sort

To sort by name descending:

usort($data, make_comparer(['name', SORT_DESC]));

See it in action.

To sort by number descending and then by name descending:


usort($data, make_comparer(['number', SORT_DESC], ['name', SORT_DESC]));

See it in action.

Custom projections

In some scenarios you may need to sort by a column whose values do not lend well to sorting. The “birthday” column in the sample data set fits this description: it does not make sense to compare birthdays as strings (because e.g. “01/01/1980” comes before “10/10/1970”). In this case we want to specify how to project the actual data to a form that can be compared directly with the desired semantics.

Projections can be specified as any type of callable: as strings, arrays, or anonymous functions. A projection is assumed to accept one argument and return its projected form.

It should be noted that while projections are similar to the custom comparison functions used with usort and family, they are simpler (you only need to convert one value to another) and take advantage of all the functionality already baked into make_comparer.

Let’s sort the example data set without a projection and see what happens:

usort($data, make_comparer('birthday'));

See it in action.

That was not the desired outcome. But we can use date_create as a projection:

usort($data, make_comparer(['birthday', SORT_ASC, 'date_create']));

See it in action.

This is the correct order that we wanted.

There are many more things that projections can achieve. For example, a quick way to get a case-insensitive sort is to use strtolower as a projection.

That said, I should also mention that it’s better to not use projections if your data set is large: in that case it would be much faster to project all your data manually up front and then sort without using a projection, although doing so will trade increased memory usage for faster sort speed.

Finally, here is an example that uses all the features: it first sorts by number descending, then by birthday ascending:

usort($data, make_comparer(
    ['number', SORT_DESC],
    ['birthday', SORT_ASC, 'date_create']
));

See it in action.

Tagged , , ,

2 thoughts on “One of my favorite answers on stackoverflow

  1. Chaz says:

    Tim, I realize you are not the author of the code, but unfortunately I don’t have enough ‘reputation’ to post a comment/question on stackoverflow, so I figured I’d take a shot here out of desperation.

    The code is gorgeous, and perfectly suited to what I need to accomplish. Unfortunately it’s throwing an error when I try to use advanced options.

    On my server (running PHP 5.3.28) this works properly:

    usort($data, make_comparer(
    'wins',
    'losses'
    ));

    But when I try to pass arrays to the function I get a PHP error caused by the brackets:

    usort($data, make_comparer(
    ['wins', SORT_DESC],
    'losses'
    ));

    Result:
    PHP Parse error: syntax error, unexpected '[', expecting ')' in /home/sitedir/public_html/index.php on line xxx

    I’ve tried everything I can think of — putting the advanced params in an array or a variable, swapping double quotes for single . . . nothing works.

    Maybe you or another reader my have a tip? Any and all advice will be greatly appreciated!

  2. timdinh says:

    Sorry, I was so late, I’ve been getting spam from bots only lately!

    You need to be running PHP 5.4+ to use shorthand arrays! 🙂

    Try upgrading PHP or use

    usort($data, make_comparer(
    array('wins',SORT_DESC),
    'losses'
    ));

Leave a Reply