ksort - PHP code example

PHP Function Ksort

PHP provides a number of built-in functions for sorting array elements in different ways. Some of these are used for sorting array elements alphabetically, while others are used for sorting array elements numerically or in ascending or descending order. The ksort function is used for sorting associative array elements by the key while keeping the original values.

The ksort() function takes in two parameters. The first is mandatory and specifies the array that needs to be sorted by the keys. The second is optional and can be used to modify the behavior of ksort. For example, if the second parameter is SORT_REGULAR then items will be compared normally and won't change their types. However, if the second parameter is SORT_LOCALE_STRING then the items will be compared as strings based on the current locale.

For example, the below program shows how to use ksort to sort an associative array with its keys such as "Lemon, Apple and Grape" and its values such as "34,50 and 25". In this way, the associative array is sorted in ascending order by the key while keeping the values.

The ksort() function also allows you to sort the array in a case-sensitive manner. In this way, capital letters will be placed before the small letters. This is a different behavior from the other array sort functions in PHP which place numeric keys prior to alphabetical keys. This is a bug fix and will be changed in future versions of PHP to make it consistent with the other array sort functions.

ksort example

if (!str_contains($file, 'jquery.ui')) {
            continue;
          }
          $weight = $asset['weight'];
          $this->weightGroupedAssets["$weight"][] = $file;
        }
      }
    }
    $this->weightGroupedAssets = array_map(function D$item) {
      return array_unique($item);
    }, $this->weightGroupedAssets);
    ksort($this->weightGroupedAssets);
  }

  /** * Confirm assets are weighted so they load in the correct order. * * The configured loading order is compared against the necessary loading * order. The necessary loading order was determined by the requirements * specified in each jQuery UI JavaScript file. */
  public function testProperlySetWeights() {
    $assets = [];

    /** * Returns the headers as a string. */
    public function __toString(): string
    {
        if (!$headers = $this->all()) {
            return '';
        }

        ksort($headers);
        $max = max(array_map('strlen', array_keys($headers))) + 1;
        $content = '';
        foreach ($headers as $name => $values) {
            $name = ucwords($name, '-');
            foreach ($values as $value) {
                $content .= sprintf("%-{$max}s %s\r\n", $name.':', $value);
            }
        }

        return $content;
    }

/** * Combines selectors from the rules store when they have the same styles. * * @since 6.1.0 */
    private function combine_rules_selectors() {
        // Build an array of selectors along with the JSON-ified styles to make comparisons easier.         $selectors_json = array();
        foreach ( $this->css_rules as $rule ) {
            $declarations = $rule->get_declarations()->get_declarations();
            ksort( $declarations );
            $selectors_json[ $rule->get_selector() ] = wp_json_encode( $declarations );
        }

        // Combine selectors that have the same styles.         foreach ( $selectors_json as $selector => $json ) {
            // Get selectors that use the same styles.             $duplicates = array_keys( $selectors_json, $json, true );
            // Skip if there are no duplicates.             if ( 1 >= count( $duplicates ) ) {
                continue;
            }

  protected function getRouteCollectionCacheId(Request $request) {
    // Include the current language code in the cache identifier as     // the language information can be elsewhere than in the path, for example     // based on the domain.     $this->addExtraCacheKeyPart('language', $this->getCurrentLanguageCacheIdPart());

    // Sort the cache key parts by their provider in order to have predictable     // cache keys.     ksort($this->extraCacheKeyParts);
    $key_parts = [];
    foreach ($this->extraCacheKeyParts as $provider => $key_part) {
      $key_parts[] = '[' . $provider . ']=' . $key_part;
    }

    return 'route:' . implode(':', $key_parts) . ':' . $request->getPathInfo() . ':' . $request->getQueryString();
  }

  /** * Returns the language identifier for the route collection cache. * * @return string * The language identifier. */

// sorting routes by priority         if ($this->prioritizeDetected && $this->prioritize && $routes !== []) {
            $order = [];

            foreach ($routes as $key => $value) {
                $key                    = $key === '/' ? $key : ltrim($key, '/ ');
                $priority               = $this->getRoutesOptions($key, $verb)['priority'] ?? 0;
                $order[$priority][$key] = $value;
            }

            ksort($order);
            $routes = array_merge(...$order);
        }

        return $routes;
    }

    /** * Returns one or all routes options * * @return array<string, int|string> [key => value] */

// we merge the 2 maps (we never remove old mime types) $map = array_replace_recursive($current, $new);

foreach ($exts as $ext => $types) {
    foreach ($types as $mt) {
        if (!isset($map[$mt])) {
            $map += [$mt => [$ext]];
        }
    }
}
ksort($map);

foreach ($map as $mimeType => $extensions) {
    foreach ($exts as $ext => $types) {
        if (in_array($mimeType, $types, true)) {
            array_unshift($extensions, $ext);
        }
    }
    $data .= sprintf(" '%s' => ['%s'],\n", $mimeType, implode("', '", array_unique($extensions)));
}
$data .= $post;

        }
        return array_flip($newarray);
    }

    /** * @param array $theArray * * @return bool */
    public static function ksort_recursive(&$theArray) {
        ksort($theArray);
        foreach ($theArray as $key => $value) {
            if (is_array($value)) {
                self::ksort_recursive($theArray[$key]);
            }
        }
        return true;
    }

    /** * @param string $filename * @param int $numextensions * * @return string */

foreach ($allAssets as $asset) {
            // $asset->getPublicPath() will start with a "/"             $targetPath = $publicDir.$asset->publicPath;

            if (!is_dir($dir = \dirname($targetPath))) {
                $this->filesystem->mkdir($dir);
            }

            $this->filesystem->dumpFile($targetPath, $asset->content);
            $manifest[$asset->logicalPath] = $asset->publicPath;
        }
        ksort($manifest);
        $io->comment(sprintf('Compiled <info>%d</info> assets', \count($manifest)));

        return $manifest;
    }
}

$sentMessage = new SentMessage($message, (string) $this);
        if (isset($content[$phone]['id_sms'])) {
            $sentMessage->setMessageId($content[$phone]['id_sms']);
        }

        return $sentMessage;
    }

    private function generateSignature(array $data): string
    {
        ksort($data);

        return md5(implode('', array_values($data)).$this->password);
    }

    private function escapePhoneNumber(string $phoneNumber): string
    {
        return str_replace('+', '00', $phoneNumber);
    }
}

private function generateAlpha3Codes(array $languageCodes, ArrayAccessibleResourceBundle $metadataBundle): array
    {
        $alpha3Codes = array_flip(array_filter($languageCodes, static fn (string $language): bool => 3 === \strlen($language)));

        foreach ($metadataBundle['alias']['language'] as $alias => $data) {
            if (3 === \strlen($alias) && 'overlong' === $data['reason']) {
                $alpha3Codes[$alias] = true;
            }
        }

        ksort($alpha3Codes);

        return array_keys($alpha3Codes);
    }

    private function generateAlpha2ToAlpha3Mapping(ArrayAccessibleResourceBundle $metadataBundle): array
    {
        $aliases = iterator_to_array($metadataBundle['alias']['language']);
        $alpha2ToAlpha3 = [];

        foreach ($aliases as $alias => $data) {
            $language = $data['replacement'];

            }

            foreach ($names as $key => $name) {
                if (\array_key_exists($name, $arguments) && (0 === $key || \array_key_exists($key - 1, $arguments))) {
                    $arguments[$key] = $arguments[$name];
                    unset($arguments[$name]);
                }
            }

            if ($arguments !== $call[1]) {
                ksort($arguments, \SORT_NATURAL);
                $calls[$i][1] = $arguments;
            }
        }

        if ($constructor) {
            [, $arguments] = array_pop($calls);

            if ($arguments !== $value->getArguments()) {
                $value->setArguments($arguments);
            }
        }

// Only try to update editors using CKEditor 5.     if ($editor->getEditor() !== 'ckeditor5') {
      return FALSE;
    }

    $settings = $editor->getSettings();

    // Nothing to do if there are fewer than two plugins with settings.     if (count($settings['plugins']) < 2) {
      return FALSE;
    }
    ksort($settings['plugins']);
    $editor->setSettings($settings);

    return TRUE;
  });
}

/** * Updates Text Editors using CKEditor 5 Code Block. */
function ckeditor5_post_update_code_block(&$sandbox = []) {
  $config_entity_updater = \Drupal::classResolver(ConfigEntityUpdater::class);

            return true;
        }

        /** * @param resource $fh * @return true */
        public function export_to_file_handle( $fh ) {
            $entries = array_filter( $this->entries, array( $this, 'is_entry_good_for_export' ) );
            ksort( $entries );
            $magic                     = 0x950412de;
            $revision                  = 0;
            $total                     = count( $entries ) + 1; // All the headers are one entry.             $originals_lengths_addr    = 28;
            $translations_lengths_addr = $originals_lengths_addr + 8 * $total;
            $size_of_hash              = 0;
            $hash_addr                 = $translations_lengths_addr + 8 * $total;
            $current_addr              = $hash_addr;
            fwrite(
                $fh,
                pack(

$sortedCommands = [];
        foreach ($commands as $name => $command) {
            $key = $this->application->extractNamespace($name, 1);
            if (\in_array($key, ['', self::GLOBAL_NAMESPACE], true)) {
                $globalCommands[$name] = $command;
            } else {
                $namespacedCommands[$key][$name] = $command;
            }
        }

        if ($globalCommands) {
            ksort($globalCommands);
            $sortedCommands[self::GLOBAL_NAMESPACE] = $globalCommands;
        }

        if ($namespacedCommands) {
            ksort($namespacedCommands, \SORT_STRING);
            foreach ($namespacedCommands as $key => $commandsSet) {
                ksort($commandsSet);
                $sortedCommands[$key] = $commandsSet;
            }
        }

'data-dialog-type' => 'modal',
          ],
          '#submit' => [
            'callback' => [$this, 'reuseCallback'],
          ],
        ],
      ];
      $rows[] = $row;
    }

    // Sort rows by field name.     ksort($rows);
    $form['add']['table'] = [
      '#type' => 'table',
      '#header' => [
        $this->t('Field'),
        $this->t('Field Type'),
        $this->t('Summary'),
        $this->t('Operations'),
      ],
      '#attributes' => [
        'class' => ['js-reuse-table'],
      ],
    ];