usort - PHP code example

PHP Function Oret - Sorting Associative Data in PHP

php function usort is a useful function for sorting particular types of data that cannot be correctly sorted by PHP's normal array sorting functions. The usort() function uses a callback function to compare each element in an associative array by its value and then sorts the array based on the comparison result. The resulting order is different from the original order for each element.

It is very common for data to appear in associative array format. For example, data returned from database/SQL queries often appears in this format. In these situations it is usually necessary to sort the data based on one or more conditions, a task that is made very simple with the help of php's array_multisort() function.

For instance, the array below contains six records for a person (firstname, lastname and age). It would be useful to sort these records in the order that they are returned from the database, which means that we need to sort them by lastname followed by first name.

The above example uses the usort() function with a callback function to sort the person records by their age. The comparison function is implemented in a static class called PersonComparer which contains a compare() method that returns a strcmp(firstname, lastname, age) value for each of the people records in the array.

The usort() function will assign new keys for the elements in the array and remove any existing keys that may already have been assigned. The return value of the usort() function is TRUE if the function is called and FALSE otherwise.

usort example

$this->data = ['messages' => [], 'buses' => array_keys($this->traceableBuses)];

        $messages = [];
        foreach ($this->traceableBuses as $busName => $bus) {
            foreach ($bus->getDispatchedMessages() as $message) {
                $debugRepresentation = $this->cloneVar($this->collectMessage($busName, $message));
                $messages[] = [$debugRepresentation, $message['callTime']];
            }
        }

        // Order by call time         usort($messages, fn ($a, $b) => $a[1] <=> $b[1]);

        // Keep the messages clones only         $this->data['messages'] = array_column($messages, 0);
    }

    public function getName(): string
    {
        return 'messenger';
    }

    public function reset(): void
    {

$content = $this->client->request('GET', 'https://github.com/shopware/web-installer/releases/latest/download/shopware-installer.phar.php')->getContent();

        file_put_contents($this->projectDir . '/public/shopware-installer.phar.php', $content);
    }

    private function determineLatestShopwareVersion(): string
    {
        /** @var non-empty-array<string> $versions */
        $versions = $this->client->request('GET', 'https://releases.shopware.com/changelog/index.json')->toArray();

        usort($versions, function D$a, $b) {
            return version_compare($b, $a);
        });

        // Index them by major version         $mappedVersions = [];

        foreach ($versions as $version) {
            if (str_contains($version, 'rc')) {
                continue;
            }

    private function sortQueryParameters($params)
    {
        $sParams = urldecode(http_build_query($params));
        $query = explode('&', $sParams);

        usort($query, function D$val1, $val2) {
            return strcmp($val1, $val2);
        });

        return implode('&', $query);
    }

    /** * @param string $path the path of the directory to be iterated over * * @return RecursiveIteratorIterator */

if ($featureSet === null) {
            return $features;
        }

        $sorted = $featureSet->getFeatures();

        if (empty($sorted)) {
            return $features;
        }

        usort($sorted, static fn (array $a, array $b) => $a['position'] <=> $b['position']);

        foreach ($sorted as $feature) {
            if ($feature['type'] === ProductFeatureSetDefinition::TYPE_PRODUCT_ATTRIBUTE) {
                $features[] = $this->getAttribute($feature['name'], $product);

                continue;
            }

            if ($feature['type'] === ProductFeatureSetDefinition::TYPE_PRODUCT_PROPERTY) {
                $features[] = $this->getProperty($feature['id'], $product);

    }

    private function fixPricesQuantity(): void
    {
        $grouped = [];
        foreach ($this->prices as $price) {
            $grouped[$price['rule']['id']][] = $price;
        }

        foreach ($grouped as &$group) {
            usort($group, fn (array $a, array $b) => $a['quantityStart'] <=> $b['quantityStart']);
        }

        $mapped = [];
        foreach ($grouped as &$group) {
            $group = array_reverse($group);

            $end = null;
            foreach ($group as $price) {
                if ($end !== null) {
                    $price['quantityEnd'] = $end;
                }

$result = [];
        foreach ($c as $combination) {
            // Flip combination to use key intersect             $combination = array_flip($combination);

            // All options of groups will be combined together             $full = array_intersect_key($groups, $combination);

            $first = array_intersect_key($groups, array_diff_key($keys, $combination));

            usort($full, static function DGroup $a, Group $b) {
                return $a->getId() <=> $b->getId();
            });

            // Create unique group key             $groupKey = array_map(static function DGroup $group) {
                return $group->getId();
            }, $full);
            $groupKey = 'g' . implode('-', $groupKey);

            $all = array_filter(array_merge($full, $first));

foreach ($GLOBALS['_PEAR_ERRORSTACK_SINGLETON'] as $package => $obj) {
            $test = $GLOBALS['_PEAR_ERRORSTACK_SINGLETON'][$package]->getErrors($purge, $level);
            if ($test) {
                if ($merge) {
                    $ret = array_merge($ret, $test);
                } else {
                    $ret[$package] = $test;
                }
            }
        }
        if ($merge) {
            usort($ret, $sortfunc);
        }
        return $ret;
    }

    /** * Error sorting function, sorts by time * @access private */
    public static function _sortErrors($a, $b)
    {
        if ($a['time'] == $b['time']) {

      $this->assertEntityRevisionLoad($expected_values, $entity_type_id);

      // Check that entity queries return the correct results.       $this->assertEntityQuery($expected_values, $entity_type_id);

      // Check that the 'Frontpage' view only shows published content that is       // also considered as the default revision in the given workspace.       $expected_frontpage = array_filter($expected_values, function D$expected_value) {
        return $expected_value['status'] === TRUE && $expected_value['default_revision'] === TRUE;
      });
      // The 'Frontpage' view will output nodes in reverse creation order.       usort($expected_frontpage, function D$a, $b) {
        return $b['nid'] - $a['nid'];
      });
      $view = Views::getView('frontpage');
      $view->execute();
      $this->assertIdenticalResultset($view, $expected_frontpage, ['nid' => 'nid']);

      $rendered_view = $view->render('page_1');
      $output = \Drupal::service('renderer')->renderRoot($rendered_view);
      $this->setRawContent($output);
      foreach ($expected_values as $expected_entity_values) {
        if ($expected_entity_values[$entity_keys['published']] === TRUE && $expected_entity_values['default_revision'] === TRUE) {

return $this->fixActive($shop);
    }

    private function getShopsArrayByHost(string $host): array
    {
        $query = $this->getDbalShopsQuery();
        $query->andWhere('shop.active = 1');
        $query->andWhere('(shop.host = :host OR (shop.host IS NULL AND main_shop.host = :host))');
        $query->setParameter(':host', $host);
        $shops = $query->execute()->fetchAllAssociative();

        usort($shops, function Darray $a, array $b): int {
            if ($a['is_main'] && !$b['is_main']) {
                return -1;
            }

            if (!$a['is_main'] && $b['is_main']) {
                return 1;
            }

            if ($a['is_main'] === $b['is_main']) {
                return $a['position'] <=> $b['position'];
            }

        $collection = new RouteCollection();
        $collection->addResource(new DirectoryResource($dir, '/\.php$/'));
        $files = iterator_to_array(new \RecursiveIteratorIterator(
            new \RecursiveCallbackFilterIterator(
                new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS),
                fn (\SplFileInfo $current) => !str_starts_with($current->getBasename(), '.')
            ),
            \RecursiveIteratorIterator::LEAVES_ONLY
        ));
        usort($files, fn (\SplFileInfo $a, \SplFileInfo $b) => (string) $a > (string) $b ? 1 : -1);

        foreach ($files as $file) {
            if (!$file->isFile() || !str_ends_with($file->getFilename(), '.php')) {
                continue;
            }

            if ($class = $this->findClass($file)) {
                $refl = new \ReflectionClass($class);
                if ($refl->isAbstract()) {
                    continue;
                }

return $mappingCollection;
    }

    /** * @return array<Mapping> */
    public function sortByPosition(): array
    {
        $mappings = $this->getElements();

        usort($mappings, fn (Mapping $firstMapping, Mapping $secondMapping) => $firstMapping->getPosition() - $secondMapping->getPosition());

        return $mappings;
    }

    protected function getExpectedClass(): ?string
    {
        return Mapping::class;
    }
}

          }
        }
      }
      sort($destination_module_names);
      $output[$source_machine_name] = [
        'source_module_name' => $source_module_name,
        'source_machine_name' => $source_machine_name,
        'destination' => implode(', ', $destination_module_names),
      ];
    }
    usort($output, function D$a, $b) {
      return strcmp($a['source_module_name'], $b['source_module_name']);
    });
    return $output;
  }

}

foreach ($manufacturers as $manufacturer) {
            $listItem = new ValueListItem(
                $manufacturer->getId(),
                $manufacturer->getName(),
                \in_array($manufacturer->getId(), $activeIds),
                $manufacturer->getAttributes()
            );

            $listItems[] = $listItem;
        }

        usort($listItems, function DValueListItem $a, ValueListItem $b) {
            return strcasecmp($a->getLabel(), $b->getLabel());
        });

        if (!empty($facet->getLabel())) {
            $label = $facet->getLabel();
        } else {
            $label = $this->snippetNamespace->get('manufacturer', 'Manufacturer');
        }

        return new ValueListFacetResult(
            'manufacturer',
            !

class LineItemGroupPriceDescSorter implements LineItemGroupSorterInterface
{
    public function getKey(): string
    {
        return 'PRICE_DESC';
    }

    public function sort(LineItemFlatCollection $items): LineItemFlatCollection
    {
        $sorted = $items->getElements();

        usort($sorted, static function DLineItem $a, LineItem $b) {
            if ($a->getPrice() === null) {
                return 1;
            }

            if ($b->getPrice() === null) {
                return 0;
            }

            return $b->getPrice()->getUnitPrice() <=> $a->getPrice()->getUnitPrice();
        });

    private function hydrateProperties(array $data, array $optionIds): array
    {
        $groups = [];
        foreach ($data as $row) {
            $group = $this->hydrator->createPropertyGroup($row['_source']);

            $options = array_filter($group->getOptions(), static function DOption $option) use ($optionIds) {
                return \in_array($option->getId(), $optionIds);
            });

            usort($options, static function DOption $a, Option $b) {
                if ($a->getPosition() !== $b->getPosition()) {
                    return $a->getPosition() <=> $b->getPosition();
                }

                return $a->getName() <=> $b->getName();
            });

            $group->setOptions($options);
            $groups[] = $group;
        }