iterator_to_array - PHP code example

PHP Function Iterator_To_Arrayy

php function iterator_to_array copies elements of an iterator into an array. Its second argument is a boolean value, indicating whether to use the iterator element keys as index. It is recommended to use this parameter if you want to avoid using the foreach loop for indexing the iterator.

The iterator_to_array function accepts any iterable as its first argument. Its return value is an array of the elements that the iterator has returned.

An iterable is any value that can be looped over with a foreach() loop. This includes arrays, as well as objects implementing the Traversable interface. The iterable pseudo-type was introduced in PHP 7.1.

It is possible to delegate a generator function, Traversable object, or array by using the yield from keyword. This allows you to create an outer generator, Traversable object, or array that yields values from the inner one and then stops execution once the inner generator has stopped generating its values.

The iterator_to_array() function now supports named parameters as well as positional arguments. A new optional argument, $use_keys, allows you to enable or disable the use of the iterator keys as indexes. When not enabled, the default key is a null string; if the iterator keys are used as indexes, they can be used as any standard PHP integer or float type. When enabled, NULL keys will be converted to an empty string, double keys will be truncated to their integer counterparts, resource keys will generate a warning and be converted to their resource ID, and boolean keys will be treated as an integer by the iterator.

iterator_to_array example

->addTag('foo_bar')
        ;
        $container->register(FooBarTaggedClass::class)
            ->addArgument(new TaggedIteratorArgument('foo_bar', 'foo'))
            ->setPublic(true)
        ;

        $container->compile();

        $s = $container->get(FooBarTaggedClass::class);

        $param = iterator_to_array($s->getParam()->getIterator());
        $this->assertSame(['bar' => $container->get(BarTagClass::class), 'foo_tag_class' => $container->get(FooTagClass::class)], $param);
    }

    public function testTaggedServiceWithIndexAttributeAndDefaultMethod()
    {
        $container = new ContainerBuilder();
        $container->register(BarTagClass::class)
            ->setPublic(true)
            ->addTag('foo_bar')
        ;
        $container->register(FooTagClass::class)

'normal'],
            ['verbose'],
            ['very_verbose'],
            ['debug'],
        ];
    }

    public function testIterate()
    {
        $bar = new ProgressBar($output = $this->getOutputStream(), 0, 0);

        $this->assertEquals([1, 2], iterator_to_array($bar->iterate([1, 2])));

        rewind($output->getStream());
        $this->assertEquals(
            ' 0/2 [>---------------------------] 0%'.
            $this->generateOutput(' 1/2 [==============>-------------] 50%').
            $this->generateOutput(' 2/2 [============================] 100%'),
            stream_get_contents($output->getStream())
        );
    }

    public function testIterateUncountable()
    {

private array $storages;

    /** * @internal * * @param AbstractIncrementStorage[] $storages */
    public function __construct(
        iterable $storages,
        private readonly string $configuredStorage
    ) {
        $this->storages = $storages instanceof \Traversable ? iterator_to_array($storages) : $storages;
    }

    public function getStorage(?string $storage = null): AbstractIncrementStorage
    {
        if ($storage === null) {
            $storage = $this->configuredStorage;
        }

        if (!isset($this->storages[$storage])) {
            throw new IncrementStorageNotFoundException($storage, array_keys($this->storages));
        }

    private function getSnippetsFromDir(string $directory): array
    {
        $finder = new Finder();
        $finder->files()
            ->in($directory)
            ->name('*.html.twig')
            ->sortByName()
            ->notName('render.html.twig')
            ->ignoreUnreadableDirs();

        $snippets = array_values(array_map(static fn (\SplFileInfo $file): string => ltrim(mb_substr(str_replace('.html.twig', '', $file->getPathname()), mb_strlen($directory)), '/'), iterator_to_array($finder)));

        return $snippets;
    }
}

    private function writeResource($file, mixed $value, int $indentation, bool $requireBraces = true): void
    {
        if (\is_int($value)) {
            $this->writeInteger($file, $value);

            return;
        }

        if ($value instanceof \Traversable) {
            $value = iterator_to_array($value);
        }

        if (\is_array($value)) {
            $intValues = \count($value) === \count(array_filter($value, 'is_int'));

            // check that the keys are 0-indexed and ascending             $intKeys = array_is_list($value);

            if ($intValues && $intKeys) {
                $this->writeIntVector($file, $value, $indentation);

->andWhere('esd.id IS NULL')
                ->setParameter('articleId', $productId);

            $query = $builder->getQuery();
            $query->setHydrationMode(AbstractQuery::HYDRATE_ARRAY);
            $paginator = $this->getModelManager()->createPaginator($query);

            // returns the total count of the query             $totalResult = $paginator->count();

            // returns the customer data             $result = iterator_to_array($paginator);

            $products = $this->buildListProducts($result);
            $products = $this->getAdditionalTexts($products);
            $result = $this->assignAdditionalText($result, $products);

            $this->View()->assign([
                'data' => $result,
                'total' => $totalResult,
                'success' => true,
            ]);

        $loader = clone $this;
        $loader->currentDirectory = $currentDirectory;

        return $loader;
    }

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

        /** @var \SplFileInfo $file */
        foreach ($files as $file) {
            if ($file->isDir()) {

    public function __construct(
        private readonly TwigBundleIterator $templateIterator,
        private readonly array $kernelBundles
    ) {
    }

    public function getIterator(): \Traversable
    {
        $data = iterator_to_array($this->templateIterator, false);
        $search = [];
        $replace = [];

        foreach ($this->kernelBundles as $bundleName => $bundle) {
            $parents = class_parents($bundle);
            if (!isset($parents[Bundle::class])) {
                continue;
            }

            $search[] = sprintf('@%s/', $bundleName);
            $replace[] = '';
        }

public function testValidateWithoutValue(): void
    {
        try {
            $this->conditionRepository->create([
                [
                    'type' => (new ShippingStreetRule())->getName(),
                    'ruleId' => Uuid::randomHex(),
                ],
            ], $this->context);
            static::fail('Exception was not thrown');
        } catch (WriteException $stackException) {
            $exceptions = iterator_to_array($stackException->getErrors());
            static::assertCount(2, $exceptions);
            static::assertSame('/0/value/streetName', $exceptions[1]['source']['pointer']);
            static::assertSame(NotBlank::IS_BLANK_ERROR, $exceptions[1]['code']);

            static::assertSame('/0/value/operator', $exceptions[0]['source']['pointer']);
            static::assertSame(NotBlank::IS_BLANK_ERROR, $exceptions[0]['code']);
        }
    }

    public function testValidateWithEmptyStreetName(): void
    {

$a += self::extractMetadata($c);

        return $a;
    }

    /** * @return array */
    public static function castCollectionMetadata(CollectionMetadata $c, array $a, Stub $stub, bool $isNested)
    {
        $a += iterator_to_array($c);

        return $a;
    }

    /** * @return array */
    public static function castTopicMetadata(TopicMetadata $c, array $a, Stub $stub, bool $isNested)
    {
        $prefix = Caster::PREFIX_VIRTUAL;

use Symfony\Component\Mime\RawMessage;

class RawMessageTest extends TestCase
{
    /** * @dataProvider provideMessages */
    public function testToString($messageParameter)
    {
        $message = new RawMessage($messageParameter);
        $this->assertEquals('some string', $message->toString());
        $this->assertEquals('some string', implode('', iterator_to_array($message->toIterable())));
        // calling methods more than once work         $this->assertEquals('some string', $message->toString());
        $this->assertEquals('some string', implode('', iterator_to_array($message->toIterable())));
    }

    public static function provideMessages(): array
    {
        return [
            'string' => ['some string'],
            'traversable' => [new \ArrayObject(['some', ' ', 'string'])],
            'array' => [['some', ' ', 'string']],
        ];

/** @var Query<OrderModel|array<string, mixed>> $query */
        $query = $builder->getQuery();

        $query->setHydrationMode($this->getResultMode());

        $paginator = $this->getManager()->createPaginator($query);

        // Returns the total count of the query         $totalResult = $paginator->count();

        // Returns the order data         $orders = iterator_to_array($paginator);

        foreach ($orders as &$order) {
            if (\is_array($order)) {
                $order['paymentStatusId'] = $order['cleared'];
                $order['orderStatusId'] = $order['status'];
                unset($order['cleared'], $order['status']);
            }
        }

        return ['data' => $orders, 'total' => $totalResult];
    }

$this->orderService->createOrder($dataBag, $context);

        $cart->add((new LineItem('b', 'test'))->setStates([State::IS_DOWNLOAD]));

        try {
            $this->orderService->createOrder($dataBag, $context);

            static::fail('Did not throw exception');
        } catch (\Throwable $exception) {
            static::assertInstanceOf(ConstraintViolationException::class, $exception);
            $errors = iterator_to_array($exception->getErrors());
            static::assertCount(1, $errors);
            static::assertEquals('VIOLATION::IS_BLANK_ERROR', $errors[0]['code']);
            static::assertEquals('/revocation', $errors[0]['source']['pointer']);
        }

        $dataBag->set('revocation', true);

        $this->orderService->createOrder($dataBag, $context);
    }
}

    /** * @param array|\Traversable $entity * * @return array|\Traversable */
    public function deserialize(Config $config, EntityDefinition $definition, $entity)
    {
        $deserialized = parent::deserialize($config, $definition, $entity);

        $deserialized = \is_array($deserialized) ? $deserialized : iterator_to_array($deserialized);

        if (!isset($deserialized['id']) && isset($deserialized['salutationKey'])) {
            $id = $this->getSalutationId($deserialized['salutationKey']);

            // if we dont find it by salutationKey, only set the id to the fallback if we dont have any other data             if (!$id && \count($deserialized) === 1) {
                $id = $this->getSalutationId('not_specified');
                unset($deserialized['salutationKey']);
            }

            if ($id) {

public function testValidateWithMissingValues(): void
    {
        try {
            $this->conditionRepository->create([
                [
                    'type' => (new OrderCountRule())->getName(),
                    'ruleId' => Uuid::randomHex(),
                ],
            ], $this->context);
            static::fail('Exception was not thrown');
        } catch (WriteException $stackException) {
            $exceptions = iterator_to_array($stackException->getErrors());
            static::assertCount(2, $exceptions);
            static::assertSame('/0/value/count', $exceptions[0]['source']['pointer']);
            static::assertSame(NotBlank::IS_BLANK_ERROR, $exceptions[0]['code']);

            static::assertSame('/0/value/operator', $exceptions[1]['source']['pointer']);
            static::assertSame(NotBlank::IS_BLANK_ERROR, $exceptions[1]['code']);
        }
    }

    public function testValidateWithEmptyValues(): void
    {