uksort - PHP code example

PHP Function uksort

Article about php function uksort

The uksort() function sorts an array by using a user defined comparison (callback) function. The comparison function determines what is less than, equal to and greater than so that the keys/values association from the original array remains intact. This is useful if you need to sort an array by some non-trivial criteria.

It is used mainly when sorting associative arrays, where the original key-to-value correlations may need to be preserved. In other words, uksort is a way to order alphanumeric strings in the same way that a human would, maintaining the relationship between keys and values, rather than ordering them according to their numerical or alphabetical value.

The function takes the array to be sorted and the comparison function as arguments and returns a boolean value: True on success or False on failure.

To avoid recursion in the comparison function, the function uses two special truthiness operators which look like functions but aren't: empty() and isset(). Using these helps avoid generating PHP warnings for undeclared variables, which is useful if you are working with large and/or complex data structures.

a is the array to be sorted. b is the user-defined comparison function which will compare elements in the array and determine how they should be ordered. c is the original order of the elements in the array and d is the new order that will be used by uksort to sort the array. The uksort function will then take the new index for each element and use it to sort the array. This will preserve the original relationship between key and index, so that if two elements are considered equal by the comparison function, their order in the resulting sorted array will remain the same as it was before.

uksort example

        return 'PRICE_DESC';
    }

    /** * @param array<string, LineItemQuantity[]> $map * * @return array<string, LineItemQuantity[]> */
    protected function sortPriceMap(array $map): array
    {
        \uksort($map, static function Dstring $a, string $b) {
            // the prices are stored as strings, so we need to cast them to float             // we need to store the prices as string, because you can not use floats as array keys             return (float) $b <=> (float) $a;
        });

        return $map;
    }
}

continue;
            }
            $return = $method->getReturnType() instanceof \ReflectionNamedType && 'void' === (string) $method->getReturnType() ? '' : 'return ';
            $methods[] = "\n ".ProxyHelper::exportSignature($method, false, $args)."\n".<<<EOPHP { {$return}(\$this->lazyObjectState->realInstance ??= (\$this->lazyObjectState->initializer)())->{$method->name}({$args}); } EOPHP;
        }

        uksort($methods, 'strnatcmp');
        $proxy .= implode('', $methods)."}\n";

        $this->assertStringEqualsFile(\dirname(__DIR__, 2)."/Traits/{$class}5Proxy.php", $proxy);
    }

    /** * @requires extension relay * @requires PHP 8.2 */
    public function testRelayProxy()
    {

$paths = [];
                foreach ($this->expandGlob($this->pattern) as $p) {
                    if (false !== $i = strpos($p, '/**/')) {
                        $p = substr_replace($p, '/*', $i);
                    }
                    $paths += array_fill_keys(glob($this->prefix.$p, \GLOB_NOSORT), false !== $i ? $regex : null);
                }
            }
        }

        if (null !== $paths) {
            uksort($paths, 'strnatcmp');
            foreach ($paths as $path => $regex) {
                if ($this->excludedPrefixes) {
                    $normalizedPath = str_replace('\\', '/', $path);
                    do {
                        if (isset($this->excludedPrefixes[$dirPath = $normalizedPath])) {
                            continue 2;
                        }
                    } while ($prefix !== $dirPath && $dirPath !== $normalizedPath = \dirname($dirPath));
                }

                if ((null === $regex || preg_match($regex, substr(str_replace('\\', '/', $path), $prefixLen))) && is_file($path)) {

/** * Returns all routes in this collection. * * @return array<string, Route> */
    public function all(): array
    {
        if ($this->priorities) {
            $priorities = $this->priorities;
            $keysOrder = array_flip(array_keys($this->routes));
            uksort($this->routes, static fn ($n1, $n2) => (($priorities[$n2] ?? 0) <=> ($priorities[$n1] ?? 0)) ?: ($keysOrder[$n1] <=> $keysOrder[$n2]));
        }

        return $this->routes;
    }

    /** * Gets a route by name. */
    public function get(string $name): ?Route
    {
        $visited = [];

if (null === $glue) {
            return (!$noBuiltin && $type->allowsNull() && 'mixed' !== $name ? '?' : '').$types[0];
        }
        sort($types);

        return implode($glue, $types);
    }

    private static function exportPropertyScopes(string $parent): string
    {
        $propertyScopes = Hydrator::$propertyScopes[$parent] ??= Hydrator::getPropertyScopes($parent);
        uksort($propertyScopes, 'strnatcmp');
        $propertyScopes = VarExporter::export($propertyScopes);
        $propertyScopes = str_replace(VarExporter::export($parent), 'parent::class', $propertyScopes);
        $propertyScopes = preg_replace("/(?|(,)\n( ) |\n |,\n (\]))/", '$1$2', $propertyScopes);
        $propertyScopes = str_replace("\n", "\n ", $propertyScopes);

        return $propertyScopes;
    }

    private static function exportDefault(\ReflectionParameter $param): string
    {
        $default = rtrim(substr(explode('$'.$param->name.' = ', (string) $param, 2)[1] ?? '', 0, -2));

__( 'A plugin disallowed this event.' )
            );
        }

        return false;
    }

    $crons[ $event->timestamp ][ $event->hook ][ $key ] = array(
        'schedule' => $event->schedule,
        'args'     => $event->args,
    );
    uksort( $crons, 'strnatcasecmp' );

    return _set_cron_array( $crons, $wp_error );
}

/** * Schedules a recurring event. * * Schedules a hook which will be triggered by WordPress at the specified interval. * The action will trigger when someone visits your WordPress site if the scheduled * time has passed. * * Valid values for the recurrence are 'hourly', 'daily', and 'twicedaily'. These can * be extended using the {@see 'cron_schedules'} filter in wp_get_schedules(). * * Use wp_next_scheduled() to prevent duplicate events. * * Use wp_schedule_single_event() to schedule a non-recurring event. * * @since 2.1.0 * @since 5.1.0 Return value modified to boolean indicating success or failure, * {@see 'pre_schedule_event'} filter added to short-circuit the function. * @since 5.7.0 The `$wp_error` parameter was added. * * @link https://developer.wordpress.org/reference/functions/wp_schedule_event/ * * @param int $timestamp Unix timestamp (UTC) for when to next run the event. * @param string $recurrence How often the event should subsequently recur. * See wp_get_schedules() for accepted values. * @param string $hook Action hook to execute when the event is run. * @param array $args Optional. Array containing arguments to pass to the * hook's callback function. Each value in the array * is passed to the callback as an individual parameter. * The array keys are ignored. Default empty array. * @param bool $wp_error Optional. Whether to return a WP_Error on failure. Default false. * @return bool|WP_Error True if event successfully scheduled. False or WP_Error on failure. */

// figure out which keys need to be added             $missingKeys = array_diff_key($keyIndex, $tmpRow);

            // Remove all keys which don't exist in $keyIndex             $tmpRow = array_filter($tmpRow, static fn ($k) => array_key_exists($k, $keyIndex), ARRAY_FILTER_USE_KEY);

            // add missing keys to row, but use $this->emptyCells             $tmpRow = array_merge($tmpRow, array_map(fn ($v) => ['data' => $this->emptyCells], $missingKeys));

            // order keys by $keyIndex values             uksort($tmpRow, static fn ($k1, $k2) => $keyIndex[$k1] <=> $keyIndex[$k2]);
        }
        $this->rows[] = $tmpRow;

        return $this;
    }

    /** * Set to true if each row column should be synced by keys defined in heading. * * If a row has a key which does not exist in heading, it will be filtered out * If a row does not have a key which exists in heading, the field will stay empty * * @return $this */

        }

        // anonymous services "in the wild"         if (false !== $nodes = $xpath->query('.//container:services/container:service[not(@id)]', $root)) {
            foreach ($nodes as $node) {
                throw new InvalidArgumentException(sprintf('Top-level services must have "id" attribute, none found in "%s" at line %d.', $file, $node->getLineNo()));
            }
        }

        // resolve definitions         uksort($definitions, 'strnatcmp');
        foreach (array_reverse($definitions) as $id => [$domElement, $file]) {
            if (null !== $definition = $this->parseDefinition($domElement, $file, new Definition())) {
                $this->setDefinition($id, $definition);
            }
        }
    }

    private function getArgumentsAsPhp(\DOMElement $node, string $name, string $file, bool $isChildDefinition = false): array
    {
        $arguments = [];
        foreach ($this->getChildren($node, $name) as $arg) {

        return 'PRICE_ASC';
    }

    /** * @param array<string, LineItemQuantity[]> $map * * @return array<string, LineItemQuantity[]> */
    protected function sortPriceMap(array $map): array
    {
        \uksort($map, static function Dstring $a, string $b) {
            // the prices are stored as strings, so we need to cast them to float             // we need to store the prices as string, because you can not use floats as array keys             return (float) $a <=> (float) $b;
        });

        return $map;
    }
}

public function seal(string $name, string $value): void
    {
        $this->lastMessage = null;
        $this->validateName($name);
        $this->loadKeys();
        $filename = $this->getFilename($name);
        $this->export($filename, sodium_crypto_box_seal($value, $this->encryptionKey ?? sodium_crypto_box_publickey($this->decryptionKey)));

        $list = $this->list();
        $list[$name] = null;
        uksort($list, 'strnatcmp');
        file_put_contents($this->pathPrefix.'list.php', sprintf("<?php\n\nreturn %s;\n", VarExporter::export($list)), \LOCK_EX);

        $this->lastMessage = sprintf('Secret "%s" encrypted in "%s"; you can commit it.', $name, $this->getPrettyPath(\dirname($this->pathPrefix).\DIRECTORY_SEPARATOR));
    }

    public function reveal(string $name): ?string
    {
        $this->lastMessage = null;
        $this->validateName($name);

        $filename = $this->getFilename($name);

$reflector = new \ReflectionClass($method['class']);
          if ($reflector->implementsInterface($interface)) {
            $this->processors[$scope][$method_id] = $this->negotiator->getNegotiationMethodInstance($method_id);
            $weights[$method_id] = $method['weight'];
          }
        }
      }
    }

    // Sort the processors list, so that their functions are called in the     // order specified by the weight of the methods.     uksort($this->processors[$scope], function D$method_id_a, $method_id_b) use ($weights) {
      return $weights[$method_id_a] <=> $weights[$method_id_b];
    });
  }

  /** * Initializes the injected event subscriber with the language path processor. * * The language path processor service is registered only on multilingual * site configuration, thus we inject it in the event subscriber only when * it is initialized. */

// Do not apply markup/translate as it will be cached.         $plugin_data = get_plugin_data( WP_CONTENT_DIR . "/$plugin_file", false, false );

        if ( empty( $plugin_data['Name'] ) ) {
            $plugin_data['Name'] = $plugin_file;
        }

        $dropins[ $plugin_file ] = $plugin_data;
    }

    uksort( $dropins, 'strnatcasecmp' );

    return $dropins;
}

/** * Returns drop-ins that WordPress uses. * * Includes Multisite drop-ins only when is_multisite() * * @since 3.0.0 * @return array[] Key is file name. The value is an array, with the first value the * purpose of the drop-in and the second value the name of the constant that must be * true for the drop-in to be used, or true if no constant is required. */