PHPackages                             tuck/sort - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. tuck/sort

ActiveLibrary[Utility & Helpers](/categories/utility)

tuck/sort
=========

Syntactic sugar for PHP's sorting

v0.1.0(7y ago)11547.3k↓47.9%8[1 PRs](https://github.com/rosstuck/sort/pulls)MITPHPPHP >=7.0

Since Aug 3Pushed 2y ago8 watchersCompare

[ Source](https://github.com/rosstuck/sort)[ Packagist](https://packagist.org/packages/tuck/sort)[ RSS](/packages/tuck-sort/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (1)Dependencies (1)Versions (3)Used By (0)

Tuck\\Sort
==========

[](#tucksort)

[![Build Status](https://camo.githubusercontent.com/8183996e355985d87e634ace690c2c75bcd91187cfc82fde0569451f86b48162/68747470733a2f2f7472617669732d63692e6f72672f726f73737475636b2f736f72742e7376673f6272616e63683d6d6173746572)](https://travis-ci.org/rosstuck/sort)[![Latest Stable Version](https://camo.githubusercontent.com/61a1e3a7f72a691e4e0a66e92f834c8b54c3f0e4dec8929b7d32ef790160d05e/68747470733a2f2f706f7365722e707567782e6f72672f7475636b2f736f72742f762f737461626c652e706e67)](https://packagist.org/packages/WyriHaximus/react-http-middleware-session)[![Total Downloads](https://camo.githubusercontent.com/feb17001b6778960a3654cd6da411bf98dac80a36612e17e8b449d2daa3a20dd/68747470733a2f2f706f7365722e707567782e6f72672f7475636b2f736f72742f646f776e6c6f6164732e706e67)](https://packagist.org/packages/tuck/sort)[![License](https://camo.githubusercontent.com/b3e31874a68797c31bf12eb4fb8bdfe5bd486b6669dd6b3163b178f3597f4b92/68747470733a2f2f706f7365722e707567782e6f72672f7475636b2f736f72742f6c6963656e73652e706e67)](https://packagist.org/packages/WyriHaximus/react-http-middleware-session)

Syntactic sugar for PHP's built in sorting.

Examples
--------

[](#examples)

Basic sorting functions

```
use Tuck\Sort\Sort;

Sort::values(['foo', 'bar', 'baz']);                    // returns ['bar', 'baz', 'foo']
Sort::keys(['x' => 'foo', 'm' => 'bar']);               // returns ['m' => 'bar', 'x' => 'foo']
Sort::natural(['img12.jpg', 'img2.jpg', 'img1.jpg']);   // returns ['img1.jpg', 'img2.jpg', 'img12.jpg']
Sort::user(
    [3, 2, 5, 6],
    function () { /* custom sorting */ }
);
```

Why?
----

[](#why)

This library tries to smooth out the built-in API, specifically the following issues:

### PHP requires variables.

[](#php-requires-variables)

If you want to sort the result of a method, you need to assign it to an intermediate variable.

```
$results = $metrics->getTotals();
sort($results);
```

With this library, you can pass results directly:

```
Sort::values($metrics->getTotals());
```

### PHP modifies in-place

[](#php-modifies-in-place)

Perhaps you'd prefer sort to return a modified list, rather than mutating the original. Unfortunately, the return value of `sort()` is a success boolean, not the reordered list.

With this library, the results are returned directly and the original list is not modified:

```
$x = [3, 1, 2];

var_dump(Sort::values($x)); // 1, 2, 3
var_dump($x);               // 3, 1, 2
```

### PHP's naming is confusing

[](#phps-naming-is-confusing)

PHP's sorting functions don't always have the most intuitive names:

```
asort()
sort()
ksort()
natsort()
usort()
uasort()
uksort()
```

With this library, naming reads a little better:

```
Sort::values()
Sort::keys()
Sort::natural()
Sort::user()
```

### PHP doesn't handle keys consistently

[](#php-doesnt-handle-keys-consistently)

When you use `sort()` PHP discards the original keys. Unless you use `asort()`. Or `natsort` and `natcasesort` which always preserve the original keys. You get the idea.

With this library, the returned keys are reset to sequential numbers, regardless of the type of sorting.

```
Sort::values([3 => 'bob', 1 => 'alice']);
// returns [0 => 'alice', 1 => 'bob']
```

If you'd like to keep the original keys, there's a consistent parameter you can always use `Sort::PRESERVE_KEYS`. This selects the correct key-preserving function under the hood, so you don't have to remember it.

```
Sort::values([3 => 'bob', 1 => 'alice'], Sort::PRESERVE_KEYS);
// returns [1 => 'alice', 3 => 'bob']
```

This works for all sort functions:

```
Sort::values(['foo', 'bar', 'baz'], Sort::PRESERVE_KEYS);
Sort::natural(['foo', 'bar', 'baz'], Sort::PRESERVE_KEYS);
Sort::user(
    [3, 2, 5, 6],
    function () { /* custom sorting */ },
    Sort::PRESERVE_KEYS
);
```

Much easier to remember. If the constants are too long-winded or readable, you can also pass `true` to preserve the keys or `false` to discard them.

### PHP doesn't accept iterators or generators

[](#php-doesnt-accept-iterators-or-generators)

Built-in sorting functions work great on arrays but won't accept their Traversable brethren.

With this library, iterators and generators are automatically converted to arrays.

```
$x = new ArrayIterator([3, 1, 2]);
Sort::values($x); // returns [1, 2, 3]
```

Note this library always returns arrays, even when given a custom collection. If you'd like your custom collection to support this library, see the usort documentation below.

### PHP doesn't have a shorthand for sorting by fields

[](#php-doesnt-have-a-shorthand-for-sorting-by-fields)

When you're comparing a list of objects, you usually want to compare the same field on them repeatedly. Usually that means writing a usort function like this:

```
Sort::user($list, function (HighScore $a, HighScore $b) {
    return $a->getPoints()  $b->getPoints();
});
```

And that's with the PHP 7 shorthand operator helping. This library offers a slightly shorter, Scala inspired version where you only specify how to retrieve the sortable data from an element.

```
Sort::by($list, function (HighScore $a) {
    return $a->getPoints();
});
```

This also works in reverse:

```
Sort::byDescending($list, function (HighScore $a) {
    return $a->getPoints();
});
```

### PHP doesn't have chained usort

[](#php-doesnt-have-chained-usort)

There's no elegant syntax for chaining multiple sorts at once. If you wanted to sort a list of high scores, first by points, then name, then date, you'd need to write a function like:

```
usort(
    $unsorted,
    function (HighScore $scoreA, HighScore $scoreB) {
        $a = $scoreA->getPoints();
        $b = $scoreA->getPoints();

        if ($a == $b) {
            $a = $scoreA->getDate();
            $b = $scoreB->getDate();
        }

        if ($a == $b) {
            $a = $scoreA->getName();
            $b = $scoreB->getName();
        }

        return $a  $b;
    }
);
```

With this library, you can chain sorts like so:

```
Sort::chain()
    ->compare(function (HighScore $a, HighScore $b) {
        return $a->getPoints()  $b->getPoints();
    })
    ->compare(function (HighScore $a, HighScore $b) {
        return $a->getDate()  $b->getDate();
    })
    ->compare(function (HighScore $a, HighScore $b) {
        return $a->getName()  $b->getName();
    });
```

In most cases, you'll want to extract the same information from `$a` and `$b` at the same time. You might also want to sort them as ascending or descending on different factors. For both of these use cases, you can use the `asc()` and `desc()` methods.

```
$sortChain = Sort::chain()
    ->desc(function (HighScore $score) {
        return $score->getPoints();
    })
    ->asc(function (HighScore $score) {
        return $score->getDate();
    })
    ->asc(function (HighScore $score) {
        return $score->getName();
    });
```

Once you've created your sorting chain, you can apply it to keys or values. Features like Iterator support, returned values, and PRESERVE\_KEY flag are all supported.

```
$sortChain->values(['foo', 'bar']);
$sortChain->values(['foo', 'bar'], Sort::PRESERVE_KEYS);
$sortChain->keys(['foo' => 'blah', 'bar' => 'blat']);
```

You can also invoke the chain itself as a comparison function:

```
$sortChain('steven', 'connie'); // returns -1, 0 or 1
```

This means you can use it with any custom collection class that supports usort:

```
$yourCustomCollection->usort($sortChain);
```

When building your sort chain, you don't have to compose all the sorting functions at once. You can attach them over time or conditionally:

```
$sortOrder = Sort::chain();

if ($options['sort_by_name']) {
   $sortOrder->asc(...);
}

// etc
```

However, if use the chain before any sorts are added, then the order is essentially random and decided by your PHP runtime (PHP 5.x vs PHP 7 vs HHVM). There's no easy way to normalize this (I've tried) but it varies based on the runtime, the number of elements in the array, the sorting algorithm used, etc. The good news is it doesn't matter if the elements are random because there was nothing worth sorting by anyways! :)

License
-------

[](#license)

[MIT](https://opensource.org/licenses/MIT)

Contributing
------------

[](#contributing)

PRs welcome. :) Please abide by PSR-2, use tests, and respect the [Code Manifesto](http://codemanifesto.com/).

Status
------

[](#status)

Working, tested, still need to add non-functionals like docs and fancy README badges.

###  Health Score

36

—

LowBetter than 82% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity44

Moderate usage in the ecosystem

Community19

Small or concentrated contributor base

Maturity49

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 90.5% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

2912d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/08b3ff6fe26e7316ae1da92af62c040380ae6bb1056794d44c6151ac74240e54?d=identicon)[rosstuck](/maintainers/rosstuck)

---

Top Contributors

[![rosstuck](https://avatars.githubusercontent.com/u/146766?v=4)](https://github.com/rosstuck "rosstuck (38 commits)")[![cebe](https://avatars.githubusercontent.com/u/189796?v=4)](https://github.com/cebe "cebe (1 commits)")[![greydnls](https://avatars.githubusercontent.com/u/1276798?v=4)](https://github.com/greydnls "greydnls (1 commits)")[![jonathantorres](https://avatars.githubusercontent.com/u/195615?v=4)](https://github.com/jonathantorres "jonathantorres (1 commits)")[![WyriHaximus](https://avatars.githubusercontent.com/u/147145?v=4)](https://github.com/WyriHaximus "WyriHaximus (1 commits)")

---

Tags

sortsorting

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/tuck-sort/health.svg)

```
[![Health](https://phpackages.com/badges/tuck-sort/health.svg)](https://phpackages.com/packages/tuck-sort)
```

###  Alternatives

[kyslik/column-sortable

Package for handling column sorting in Laravel 6.x

6485.6M21](/packages/kyslik-column-sortable)[mottie/tablesorter

tablesorter (FORK) is a jQuery plugin for turning a standard HTML table with THEAD and TBODY tags into a sortable table without page refreshes. tablesorter can successfully parse and sort many types of data including linked data in a cell.

2.6k223.5k](/packages/mottie-tablesorter)[icecave/parity

A customizable deep comparison library.

516.8M10](/packages/icecave-parity)[symbiote/silverstripe-gridfieldextensions

A collection of useful grid field components

971.8M235](/packages/symbiote-silverstripe-gridfieldextensions)[undefinedoffset/sortablegridfield

Adds drag and drop functionality to Silverstripe's GridField

941.2M50](/packages/undefinedoffset-sortablegridfield)[topshelfcraft/supersort

...a super-duper sorting function for your Craft templates.

4287.1k1](/packages/topshelfcraft-supersort)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)