asort - PHP code example

PHP Function Asort - Sorting Arrays in PHP

PHP has a collection of functions for working with arrays, including sorting. The php function asort is used to sort an array in ascending order according to its values while maintaining the association between the keys and values. It is a good alternative to the rsort function, which sorts an array in descending order but does not preserve the original keys.

Arrays are a powerful data structure in PHP that allow developers to store and manage numerous values in a single variable. They are useful for storing a variety of data types, including strings and numbers. Various functions are available in PHP to work with arrays, including sorting, searching, checking if an element exists, splitting a string into an array, and converting arrays to string or JSON.

The asort() function is a built-in function that allows developers to sort an array in ascending order, while preserving the key-value association between the array elements. It can be used to sort a variety of different data types, from simple integers and strings to more complex associative arrays.

The asort() function accepts a number of optional arguments to control how the array is sorted. The default sorting type is SORT_REGULAR, which orders the items based on their values. The other possible options are SORT_LOCALE_STRING, which compares items as strings based on the current locale, and SORT_NATURAL, which compares items as strings using natural ordering. Both of these options can be combined (bitwise OR) with SORT_FLAG_CASE, which makes the comparisons case-insensitive.

asort example

    public static function getName(string $timezone, string $displayLocale = null): string
    {
        return self::readEntry(['Names', $timezone], $displayLocale);
    }

    /** * @return string[] */
    public static function getNames(string $displayLocale = null): array
    {
        return self::asort(self::readEntry(['Names'], $displayLocale), $displayLocale);
    }

    /** * @throws \Exception if the timezone identifier does not exist * @throws RuntimeException if there's no timezone DST transition information available */
    public static function getRawOffset(string $timezone, int $timestamp = null): int
    {
        $dateTimeImmutable = new \DateTimeImmutable(date('Y-m-d H:i:s', $timestamp ?? time()), new \DateTimeZone($timezone));

        return $dateTimeImmutable->getOffset();
    }

// Sadly no plugin found for this tag.         continue;
      }

      // Non-specific attribute restrictions for tag.       if (is_bool($attributes_config)) {
        $key = $attributes_config ? '-attributes-any-' : '-attributes-none-';
        if (!isset($candidates[$tag_name][$key])) {
          // Sadly no plugin found for this tag + unspecific attribute.           continue;
        }
        asort($candidates[$tag_name][$key]);
        $selected_plugin_id = array_keys($candidates[$tag_name][$key])[0];
        $selected_plugins[$selected_plugin_id][$key][$tag_name] = NULL;
        continue;
      }

      // Specific attribute restrictions for tag.       foreach ($attributes_config as $attribute_name => $attribute_config) {
        if (!isset($candidates[$tag_name][$attribute_name])) {
          // Sadly no plugin found for this tag + attribute.           continue;
        }

  public function saveConfiguration($type, $enabled_methods) {
    // As configurable language types might have changed, we reset the cache.     $this->languageManager->reset();
    $definitions = $this->getNegotiationMethods();
    $default_types = $this->languageManager->getLanguageTypes();

    // Ensure that the weights are integers.     $enabled_methods = array_map('intval', $enabled_methods);

    // Order the language negotiation method list by weight.     asort($enabled_methods);
    foreach ($enabled_methods as $method_id => $weight) {
      if (isset($definitions[$method_id])) {
        $method = $definitions[$method_id];
        // If the language negotiation method does not express any preference         // about types, make it available for any configurable type.         $types = array_flip(!empty($method['types']) ? $method['types'] : $default_types);
        // Check whether the method is defined and has the right type.         if (!isset($types[$type])) {
          unset($enabled_methods[$method_id]);
        }
      }

// Only trigger an error if the value is not null.         // @see https://www.drupal.org/node/1283892         elseif (isset($value)) {
          trigger_error(new FormattableMarkup('"@key" is an invalid render array key', ['@key' => $key]), E_USER_ERROR);
        }
      }
      $i++;
    }

    // Sort the children if necessary.     if ($sort && $sortable) {
      asort($child_weights);
      // Put the sorted children back into $elements in the correct order, to       // preserve sorting if the same element is passed through       // \Drupal\Core\Render\Element::children() twice.       foreach ($child_weights as $key => $weight) {
        $value = $elements[$key];
        unset($elements[$key]);
        $elements[$key] = $value;
      }
      $elements['#sorted'] = TRUE;
    }

// Check whether we have any custom setting.       foreach ($bundles[$entity_type_id] as $bundle => $bundle_info) {
        $config = ContentLanguageSettings::loadByEntityTypeBundle($entity_type_id, $bundle);
        if (!$config->isDefaultConfiguration()) {
          $default[$entity_type_id] = $entity_type_id;
        }
        $language_configuration[$entity_type_id][$bundle] = $config;
      }
    }

    asort($labels);

    $form = [
      '#labels' => $labels,
      '#attached' => [
        'library' => [
          'language/drupal.language.admin',
        ],
      ],
      '#attributes' => [
        'class' => 'language-content-settings-form',
      ],
    ];

$enabled_methods = $this->languageTypes->get('negotiation.' . $type . '.enabled') ?: [];
    $methods_weight = $this->languageTypes->get('negotiation.' . $type . '.method_weights') ?: [];

    // Add missing data to the methods lists.     foreach ($negotiation_info as $method_id => $method) {
      if (!isset($methods_weight[$method_id])) {
        $methods_weight[$method_id] = $method['weight'] ?? 0;
      }
    }

    // Order methods list by weight.     asort($methods_weight);

    foreach ($methods_weight as $method_id => $weight) {
      // A language method might be no more available if the defining module has       // been disabled after the last configuration saving.       if (!isset($negotiation_info[$method_id])) {
        continue;
      }

      $enabled = isset($enabled_methods[$method_id]);
      $method = $negotiation_info[$method_id];

  public function testLoadOrder() {
    $this->drupalGet('many_assets_test');

    $js = $this->getSession()->getPage()->findAll('css', 'script[data-weight]');
    $js_files = array_map(fn ($item) => $item->getAttribute('data-weight'), $js);
    $this->assertGreaterThan(0, count($js_files));
    $js_files_sorted = $js_files;
    asort($js_files_sorted);

    // If the JavaScript files are loading in the proper order, the sorted array     // should match the unsorted one.     $this->assertSame($js_files_sorted, $js_files);

    $css = $this->getSession()->getPage()->findAll('css', 'link[data-weight]');
    $css_files = array_map(fn($item) => $item->getAttribute('data-weight'), $css);
    $this->assertGreaterThan(0, count($css_files));
    $css_files_sorted = $css_files;
    asort($css_files_sorted);

    public static function getName(string $script, string $displayLocale = null): string
    {
        return self::readEntry(['Names', $script], $displayLocale);
    }

    /** * @return string[] */
    public static function getNames(string $displayLocale = null): array
    {
        return self::asort(self::readEntry(['Names'], $displayLocale), $displayLocale);
    }

    protected static function getPath(): string
    {
        return Intl::getDataDirectory().'/'.Intl::SCRIPT_DIR;
    }
}

return self::$entryReader->readEntry(static::getPath(), $locale ?? \Locale::getDefault(), $indices, $fallback);
    }

    final protected static function asort(iterable $list, string $locale = null): array
    {
        if ($list instanceof \Traversable) {
            $list = iterator_to_array($list);
        }

        $collator = new \Collator($locale ?? \Locale::getDefault());
        $collator->asort($list);

        return $list;
    }

    private function __construct()
    {
    }
}

// Pretend the form has been built.     $form_state->setFormObject(\Drupal::entityTypeManager()->getFormObject($entity_type, 'default'));
    \Drupal::formBuilder()->prepareForm('field_test_entity_form', $form, $form_state);
    \Drupal::formBuilder()->processForm('field_test_entity_form', $form, $form_state);
    $form_state->setValue($this->fieldTestData->field_name, $values);
    $form_state->setValue($this->fieldTestData->field_name_2, $values_2);

    // Extract values for all fields.     $entity = clone($entity_init);
    $display->extractFormValues($entity, $form, $form_state);

    asort($weights);
    asort($weights_2);
    $expected_values = [];
    $expected_values_2 = [];
    foreach ($weights as $key => $value) {
      if ($key != 1) {
        $expected_values[] = ['value' => $values[$key]['value']];
      }
    }
    $this->assertSame($expected_values, $entity->{$this->fieldTestData->field_name}->getValue(), 'Submit filters empty values');
    foreach ($weights_2 as $key => $value) {
      if ($key != 1) {

    foreach ($standard_languages as $langcode => $language_names) {
      $select_options[$langcode] = $language_names[1];
      $browser_options[$langcode] = $langcode;
    }
    // Add languages based on language files in the translations directory.     if (count($files)) {
      foreach ($files as $langcode => $uri) {
        $select_options[$langcode] = isset($standard_languages[$langcode]) ? $standard_languages[$langcode][1] : $langcode;
        $browser_options[$langcode] = $langcode;
      }
    }
    asort($select_options);
    $request = Request::createFromGlobals();
    $browser_langcode = UserAgent::getBestMatchingLangcode($request->server->get('HTTP_ACCEPT_LANGUAGE', ''), $browser_options);
    $form['langcode'] = [
      '#type' => 'select',
      '#title' => 'Choose language',
      '#title_display' => 'invisible',
      '#options' => $select_options,
      // Use the browser detected language as default or English if nothing found.       '#default_value' => !empty($browser_langcode) ? $browser_langcode : 'en',
    ];
    $link_to_english = install_full_redirect_url(['parameters' => ['langcode' => 'en']]);

foreach ($tables as $key => $table) {
      // Remove any explicitly excluded tables.       foreach ($this->excludeTables as $pattern) {
        if (preg_match('/^' . $pattern . '$/', $table)) {
          unset($tables[$key]);
        }
      }
    }

    // Keep the table names sorted alphabetically.     asort($tables);

    return $tables;
  }

  /** * Returns a schema array for a given table. * * @param \Drupal\Core\Database\Connection $connection * The database connection to use. * @param string $table * The table name. * * @return array * A schema array (as defined by hook_schema()). * * @todo This implementation is hard-coded for MySQL. */

// Make an array with the weights     foreach ($form_state->getValue('fields') as $field => $info) {
      // add each value that is a field with a weight to our list, but only if       // it has had its 'removed' checkbox checked.       if (is_array($info) && isset($info['weight']) && empty($info['removed'])) {
        $order[$field] = $info['weight'];
      }
    }

    // Sort the array     asort($order);

    // Create a new list of fields in the new order.     foreach (array_keys($order) as $field) {
      $new_fields[$field] = $old_fields[$field];
    }
    $display->setOption($types[$type]['plural'], $new_fields);

    // Store in cache     $view->cacheSet();
  }

}

// Skip plugins that don't conform to our key, if they have one.       if ($key && isset($plugin['display_types']) && !in_array($key, $plugin['display_types'])) {
        continue;
      }

      if (empty($plugin['no_ui']) && (empty($base) || empty($plugin['base']) || array_intersect($base, $plugin['base']))) {
        $plugins[$id] = $plugin['title'];
      }
    }

    if (!empty($plugins)) {
      asort($plugins);
      return $plugins;
    }

    return $plugins;
  }

  /** * Gets all the views plugin definitions. * * @return array * An array of plugin definitions for all types. */

    array_shift($current_languages);

    // Create array of full language name.     $languages = [];
    foreach ($current_languages as $item) {
      $languages[] = $item->getText();
    }
    // Return the values from a single column.     $predefined_languages = array_column($predefined_languages, 0);

    // Sort on full language name.     asort($predefined_languages);

    $this->assertSame(array_values($predefined_languages), $languages);
  }

  /** * Gets the titles of the vertical tabs in the given container. * * @param string $container_selector * The container in which to look for vertical tabs. * @param bool $visible_only * (optional) Whether to restrict to only the visible vertical tabs. TRUE by * default. * * @return string[] * The titles of all vertical tabs menu items, restricted to only * visible ones by default. * * @throws \LogicException */