array_values - PHP code example

PHP Function Array_Values

PHP arrays are a key component of many web applications. They provide a way to create indexed, associative and multidimensional arrays with key-value pairs. Associative arrays in PHP use strings as their indexes while indexed and multidimensional arrays have numeric indexes.

The php function array_values takes an indexed array and returns a new array that has all of the values from that array but with numeric keys starting at zero, retaining the original non-numeric indexes for each value. This makes it possible to have an indexed array of values that are sorted with their original key-value associations, and also allows for map functions to operate on the data without changing the key order.

Aside from the ability to sort an array based on its keys, the array_values() function also has two other parameters that can be used: a list of values to exclude and whether to perform strict matching. This last is useful if you want the indexed array to only return values that have a particular key in them. For example, if you have an array of user ids and you pass the array_values() function with the parameter set to only return those user ids that have the value 'tennis' then it will only return the user ids in the array that have the value 'tennis'.

As you can see there are quite a few different ways to work with an array in PHP, however most of them require the internal pointer for the array to be shifted. For this reason, working with a small array by using functions like current(), reset() and end() is often more performant than using combinations of array_values(), array_pop() and count().

array_values example

        $replacements[$token] = $value instanceof MarkupInterface ? PlainTextOutput::renderFromHtml($value) : $value;
      }
    }

    // Optionally alter the list of replacement values.     if (!empty($options['callback'])) {
      $function = $options['callback'];
      $function($replacements, $data, $options, $bubbleable_metadata);
    }

    $tokens = array_keys($replacements);
    $values = array_values($replacements);

    // If a local $bubbleable_metadata object was created, apply the metadata     // it collected to the renderer's currently active render context.     if (!$bubbleable_metadata_is_passed_in && $this->renderer->hasRenderContext()) {
      $build = [];
      $bubbleable_metadata->applyTo($build);
      $this->renderer->render($build);
    }

    return str_replace($tokens, $values, $text);
  }

function wp_resolve_numeric_slug_conflicts( $query_vars = array() ) {
    if ( ! isset( $query_vars['year'] ) && ! isset( $query_vars['monthnum'] ) && ! isset( $query_vars['day'] ) ) {
        return $query_vars;
    }

    // Identify the 'postname' position in the permastruct array.     $permastructs   = array_values( array_filter( explode( '/', get_option( 'permalink_structure' ) ) ) );
    $postname_index = array_search( '%postname%', $permastructs, true );

    if ( false === $postname_index ) {
        return $query_vars;
    }

    /* * A numeric slug could be confused with a year, month, or day, depending on position. To account for * the possibility of post pagination (eg 2015/2 for the second page of a post called '2015'), our * `is_*` checks are generous: check for year-slug clashes when `is_year` *or* `is_month`, and check * for month-slug clashes when `is_month` *or* `is_day`. */

public function __construct(private readonly iterable $validators)
    {
    }

    public function validate(ProductExportEntity $productExportEntity, string $productExportContent): array
    {
        $errors = new ErrorCollection();
        foreach ($this->validators as $validator) {
            $validator->validate($productExportEntity, $productExportContent, $errors);
        }

        return array_values($errors->getElements());
    }
}

WriteParameterBag $parameters
    ): \Generator {
        if (!$field instanceof ListField) {
            throw DataAbstractionLayerException::invalidSerializerField(ListField::class, $field);
        }

        $this->validateIfNeeded($field, $existence, $data, $parameters);

        $value = $data->getValue();

        if ($value !== null) {
            $value = array_values($value);

            $this->validateTypes($field, $value, $parameters);

            $value = Json::encode($value);
        }

        yield $field->getStorageName() => $value;
    }

    public function decode(Field $field, mixed $value): ?array
    {

$criteria->addAssociation('dependentThemes');
        $criteria->addFilter(new EqualsFilter('technicalName', $technicalName));

        /** @var ThemeEntity|null $theme */
        $theme = $this->themeRepository->search($criteria, $context)->first();

        if ($theme === null) {
            return;
        }

        $dependentThemes = $theme->getDependentThemes() ?? new ThemeCollection();
        $ids = [...array_values($dependentThemes->getIds()), ...[$theme->getId()]];

        $this->removeOldMedia($technicalName, $context);
        $this->themeRepository->delete(array_map(fn (string $id) => ['id' => $id], $ids), $context);
    }

    private function getThemeByTechnicalName(string $technicalName, Context $context): ?ThemeEntity
    {
        $criteria = new Criteria();
        $criteria->addFilter(new EqualsFilter('technicalName', $technicalName));
        $criteria->addAssociation('previewMedia');

    public function getSkip(): array
    {
        return $this->skip;
    }

    /** * @param array<string> $skip */
    public function setSkip(array $skip): void
    {
        $this->skip = \array_unique(\array_values($skip));
    }

    public function addSkip(string ...$skip): void
    {
        $this->skip = \array_unique(\array_merge($this->skip, \array_values($skip)));
    }

    public function allow(string $name): bool
    {
        return !\in_array($name, $this->getSkip(), true);
    }
}

    public function isAvailable(array $optionIds): bool
    {
        return $this->combinationDetails[$this->calculateHash($optionIds)]['available'] ?? false;
    }

    /** * @param array<string> $optionIds */
    private function calculateHash(array $optionIds): string
    {
        $optionIds = array_values($optionIds);
        sort($optionIds);

        return md5((string) json_encode($optionIds, \JSON_THROW_ON_ERROR));
    }
}

'#source#' => $source,
            '#alias#' => EntityDefinitionQueryHelper::escape($mappingAlias),
            '#reference_column#' => EntityDefinitionQueryHelper::escape($field->getMappingLocalColumn()),
        ];

        $context->getQuery()->leftJoin(
            EntityDefinitionQueryHelper::escape($context->getAlias()),
            EntityDefinitionQueryHelper::escape($field->getMappingDefinition()->getEntityName()),
            EntityDefinitionQueryHelper::escape($mappingAlias),
            str_replace(
                array_keys($parameters),
                array_values($parameters),
                '#source# = #alias#.#reference_column# '
                . $this->buildMappingVersionWhere($field, $context->getDefinition())
            )
        );

        $parameters = [
            '#mapping#' => EntityDefinitionQueryHelper::escape($mappingAlias),
            '#source_column#' => EntityDefinitionQueryHelper::escape($field->getMappingReferenceColumn()),
            '#alias#' => EntityDefinitionQueryHelper::escape($alias),
            '#reference_column#' => $this->getReferenceColumn($context, $field),
        ];

    $this->assertTrue($result, 'A new item has been correctly synchronized.');

    // Remove an item from the source items and check that its removed from all     // the translations.     $sync_langcode = $this->langcodes[1];
    $unchanged_items = $this->unchangedFieldValues[$sync_langcode];
    $field_values = $this->unchangedFieldValues;
    $sync_delta = mt_rand(0, count($field_values[$sync_langcode]) - 1);
    unset($field_values[$sync_langcode][$sync_delta]);
    // Renumber deltas to start from 0.     $field_values[$sync_langcode] = array_values($field_values[$sync_langcode]);
    $this->synchronizer->synchronizeItems($field_values, $unchanged_items, $sync_langcode, $this->langcodes, $this->synchronized);
    $result = TRUE;
    foreach ($this->unchangedFieldValues as $langcode => $items) {
      $new_delta = 0;
      // Check that the old values are still in place.       for ($delta = 0; $delta < $this->cardinality; $delta++) {
        // Skip the removed item.         if ($delta != $sync_delta) {
          foreach ($this->columns as $column) {
            $result = $result && ($this->unchangedFieldValues[$langcode][$delta][$column] == $field_values[$langcode][$new_delta][$column]);
          }

    /** * @return array<string> */
    public function getProductNumbers()
    {
        if (\count($this->storage) === 0) {
            return [];
        }

        $productNumbers = array_merge(...array_values($this->storage));

        return array_keys($productNumbers);
    }
}

if (!isset($customFields[$customFieldName]) || empty($customFieldValue)) {
                    return null;
                }

                $customFields[$customFieldName] = (array) ($customFields[$customFieldName] ?? []);
                $removeData = array_intersect($customFields[$customFieldName], (array) $customFieldValue);

                if (empty($removeData)) {
                    return null;
                }

                $customFields[$customFieldName] = array_values(array_diff($customFields[$customFieldName], $removeData));

                break;
            default:
                return null;
        }

        return $customFields;
    }

    private function getCustomFieldNameFromId(string $customFieldId, string $entity): ?string
    {

$view = Views::getView('comments_recent');
    $view->setDisplay('block_1');
    $this->executeView($view);

    $map = [
      'subject' => 'subject',
      'cid' => 'cid',
      'comment_field_data_created' => 'created',
    ];
    $expected_result = [];
    foreach (array_values($this->commentsCreated) as $key => $comment) {
      $expected_result[$key]['subject'] = $comment->getSubject();
      $expected_result[$key]['cid'] = $comment->id();
      $expected_result[$key]['created'] = $comment->getCreatedTime();
    }
    $this->assertIdenticalResultset($view, $expected_result, $map);

    // Check the number of results given by the display is the expected.     $this->assertCount($this->blockDisplayResults, $view->result,
      new FormattableMarkup('There are exactly @results comments. Expected @expected',
        ['@results' => count($view->result), '@expected' => $this->blockDisplayResults]
      )
    );

  }

  /** * Tests the block content body field migration. */
  public function testBlockContentBodyFieldMigration() {
    /** @var \Drupal\field\FieldStorageConfigInterface $storage */
    $storage = FieldStorageConfig::load('block_content.body');
    $this->assertInstanceOf(FieldStorageConfigInterface::class, $storage);
    $this->assertSame('block_content', $storage->getTargetEntityTypeId());
    $this->assertSame(['basic'], array_values($storage->getBundles()));
    $this->assertSame('body', $storage->getName());

    /** @var \Drupal\field\FieldConfigInterface $field */
    $field = FieldConfig::load('block_content.basic.body');
    $this->assertInstanceOf(FieldConfigInterface::class, $field);
    $this->assertSame('block_content', $field->getTargetEntityTypeId());
    $this->assertSame('basic', $field->getTargetBundle());
    $this->assertSame('body', $field->getName());
    $this->assertSame('Body', $field->getLabel());
  }

}

return $this->getAndSortElementsByIds($ids, $sortings);
    }

    /** * {@inheritdoc} */
    public function getSortingsOfCategories(array $categoryIds, ShopContextInterface $context)
    {
        $mapping = $this->getCategoryMapping($categoryIds);

        $ids = array_merge(...array_values($mapping));

        $sortings = $this->getList(
            $ids,
            $context
        );

        $categorySortings = [];

        foreach ($mapping as $categoryId => $sortingIds) {
            $categorySortings[$categoryId] = $this->getAndSortElementsByIds(
                $sortingIds,

      // a UUID key.       if ($entity_type_id) {
        $id = substr($config_name, strlen($definitions[$entity_type_id]->getConfigPrefix()) + 1);
        $entities[$entity_type_id][] = $id;
      }
    }
    $entities_to_return = [];
    foreach ($entities as $entity_type_id => $entities_to_load) {
      $storage = $this->entityTypeManager->getStorage($entity_type_id);
      // Remove the keys since there are potential ID clashes from different       // configuration entity types.       $entities_to_return[] = array_values($storage->loadMultiple($entities_to_load));
    }
    return array_merge(...$entities_to_return);
  }

  /** * {@inheritdoc} */
  public function getConfigEntitiesToChangeOnDependencyRemoval($type, array $names, $dry_run = TRUE) {
    $dependency_manager = $this->getConfigDependencyManager();

    // Store the list of dependents in three separate variables. This allows us