u/outer_gamer

Hey r/php,

I’ve spent a lot of time mentoring developers who are incredibly comfortable inside modern frameworks (like Laravel or Symfony), but they frequently hit a wall when they need to drop down to raw, native PHP mechanics to handle variable multi-layer logic.

A classic example is dynamic, multi-column dashboard sorting where the priority order, target keys, and sorting directions are determined at runtime by an incoming API payload. Framework collection helpers abstract this away, but handling it purely with native usort() using a fallback closure cascade is a great mental exercise in core data manipulation.

I'm working on a set of progressive logic problems called Linear Code Mastery, and I wanted to share Task #54 to see how you all would approach or optimize this specific engineering pattern.

---

The Problem: The Dynamic Multi-Column Sorter

The Scenario: An order management dashboard allows operators to sort an order queue by multiple columns simultaneously — for example: sort by status ascending, then by total_amount descending, then by created_at ascending as a tiebreaker. The number of sort columns and their directions are submitted as a runtime configuration array, not hardcoded.

The Requirements & Constraints:

• Accepts a flat tabular dataset array and an ordered $sortSpec array detailing columns and string directions ('asc' or 'desc').
• Must use native usort() with a dynamically constructed closure comparator — no helper collections, no array_multisort().
• The comparator must evaluate each column in priority order via a "waterfall" loop, returning immediately if a non-zero tiebreaker is found, and continuing if there is a tie.
• String columns use strcmp(). Numeric columns use the spaceship operator <=>.
• Missing keys in records should gracefully default to an empty string fallback without triggering undefined array index errors.
• Direction inversion (desc) must be handled clean and line-linearly without messy branching logic.

---

The Structural Architecture

1. Isolation: Operate on a shallow copy of the dataset array within the wrapper method to respect execution safety and prevent mutating the caller's reference pointer.
2. The Priority Cascade: The closure built inside buildComparator() iterates directly through the runtime specifications. If a comparison yields a non-zero integer, that direction-adjusted value is popped back to usort() immediately.
3. Type Uniformity: String vs numeric checking uses is_numeric(), casting numeric targets to unified floats to keep string-integers and string-floats evaluating perfectly on the spaceship axis.

---

The Code Implementation

<?php declare(strict_types=1);

/**
 * DynamicMultiColumnSorter
 *
 * Sorts tabular datasets by a runtime-configured multi-column sort specification.
 * Builds a single usort() comparator that evaluates columns in priority order,
 * falling through to the next column on ties.
 */
final class DynamicMultiColumnSorter
{
    /**
     * Sorts a dataset by a multi-column sort specification.
     * Operates on a copy of $dataset — returns a re-indexed array.
     */
    public function sort(array $dataset, array $sortSpec): array
    {
        if ($dataset === [] || $sortSpec === []) {
            return array_values($dataset);
        }

        $data = $dataset;
        $comparator = $this->buildComparator($sortSpec);
        usort($data, $comparator);

        return $data;
    }

    /**
     * Builds a multi-column comparator closure from the sort specification.
     */
    private function buildComparator(array $sortSpec): \Closure
    {
        return function (array $a, array $b) use ($sortSpec): int {

            foreach ($sortSpec as $spec) {
                $column    = $spec['column'];
                $direction = strtolower($spec['direction']) === 'desc' ? 'desc' : 'asc';

                // Null-coalescing to empty string for missing columns
                $valA = $a[$column] ?? '';
                $valB = $b[$column] ?? '';

                // Auto-detect comparison method: numeric vs string
                if (is_numeric($valA) && is_numeric($valB)) {
                    $result = (float) $valA <=> (float) $valB;
                } else {
                    $result = strcmp((string) $valA, (string) $valB);
                    $result = $result === 0 ? 0 : ($result < 0 ? -1 : 1);
                }

                if ($result !== 0) {
                    return $direction === 'desc' ? -$result : $result;
                }
            }

            return 0;
        };
    }
}

Let's Discuss

How do you tackle clean dynamic user-sorting inside native PHP core environments when you can't touch heavy external collections libraries? Would you handle the closure compilation or the type evaluation differently here?

I'd love to see alternative micro-optimizations or different approaches to handling the tiebreaker loop in the comments!

---

Note: If you enjoy working through these types of raw array manipulations and language mechanics, I put together the full set of 100 progressive logic challenges in my workbook project workspace, Linear Code Mastery.