PHPackages                             gielfeldt/iterators - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. gielfeldt/iterators

ActiveLibrary[Utility & Helpers](/categories/utility)

gielfeldt/iterators
===================

Various iterators.

0.2.0(7y ago)18.2kMITPHPPHP >=7.0.0

Since Apr 14Pushed 7y ago2 watchersCompare

[ Source](https://github.com/gielfeldt/iterators)[ Packagist](https://packagist.org/packages/gielfeldt/iterators)[ Docs](https://github.com/gielfeldt/iterators)[ RSS](/packages/gielfeldt-iterators/feed)WikiDiscussions master Synced 3w ago

READMEChangelogDependencies (2)Versions (4)Used By (0)

Iterators
=========

[](#iterators)

[![Build Status](https://camo.githubusercontent.com/1c8dba69e2347d90d1c5e2aa7980f8f491dd3b8c21af0a19f30878724de4e169/68747470733a2f2f7472617669732d63692e6f72672f6769656c66656c64742f6974657261746f72732e7376673f6272616e63683d6d6173746572)](https://travis-ci.org/gielfeldt/iterators)[![Test Coverage](https://camo.githubusercontent.com/5444e9ab3ebc80ef4fbf0c7704e92dfc777520250a01bac46dddd16a4e423ded/68747470733a2f2f636f6465636c696d6174652e636f6d2f6769746875622f6769656c66656c64742f6974657261746f72732f6261646765732f636f7665726167652e737667)](https://codeclimate.com/github/gielfeldt/iterators/coverage)[![Code Climate](https://camo.githubusercontent.com/c11c16d7c8a5541fcd8aefdb4977beb3ff4181424c24daaa54ef99250c4401f7/68747470733a2f2f636f6465636c696d6174652e636f6d2f6769746875622f6769656c66656c64742f6974657261746f72732f6261646765732f6770612e737667)](https://codeclimate.com/github/gielfeldt/iterators)[![Scrutinizer Code Quality](https://camo.githubusercontent.com/da74236feaf75c070d7e5ae61394857b1604a7c8731b0c7c65f0fa1c5a8a87cc/68747470733a2f2f7363727574696e697a65722d63692e636f6d2f672f6769656c66656c64742f6974657261746f72732f6261646765732f7175616c6974792d73636f72652e706e673f623d6d6173746572)](https://scrutinizer-ci.com/g/gielfeldt/iterators/?branch=master)

[![Latest Stable Version](https://camo.githubusercontent.com/ee89055ebad43487970c967a53a4990dd204e412db959680c88332a5e4f8f60a/68747470733a2f2f706f7365722e707567782e6f72672f6769656c66656c64742f6974657261746f72732f762f737461626c652e737667)](https://packagist.org/packages/gielfeldt/iterators)[![Latest Unstable Version](https://camo.githubusercontent.com/5bc69a3d4055f32f9b8f8a45fb3f256aff3d42381ae4516cecea8f30ac99e6ad/68747470733a2f2f706f7365722e707567782e6f72672f6769656c66656c64742f6974657261746f72732f762f756e737461626c652e737667)](https://packagist.org/packages/gielfeldt/iterators)[![Dependency Status](https://camo.githubusercontent.com/716cb079b14d62f1493f892f74335fcfd3a8c95109ce0114fb2ba7d5bd52866e/68747470733a2f2f7777772e76657273696f6e6579652e636f6d2f757365722f70726f6a656374732f3538656433396135323661356262303033386534323266372f62616467652e7376673f7374796c653d666c6174)](https://www.versioneye.com/user/projects/58ed39a526a5bb0038e422f7)[![License](https://camo.githubusercontent.com/d7060f2c1fe07ea0b1a06a7e8889c7d2efc147ddd930523d535073a3cb9a16f5/68747470733a2f2f706f7365722e707567782e6f72672f6769656c66656c64742f6974657261746f72732f6c6963656e73652e737667)](https://github.com/gielfeldt/iterators/blob/master/LICENSE.md)[![Total Downloads](https://camo.githubusercontent.com/7afcd6e92cb8e1d3c695aab233f67576c3c91c92723cf74d51970725a90ba20a/68747470733a2f2f706f7365722e707567782e6f72672f6769656c66656c64742f6974657261746f72732f646f776e6c6f6164732e737667)](https://packagist.org/packages/gielfeldt/iterators)

[![Documentation Status](https://camo.githubusercontent.com/7d1b712f92cc5f13d4bcfbb6e105669f900bd44c7cc7497ce90a130af693773b/68747470733a2f2f72656164746865646f63732e6f72672f70726f6a656374732f6974657261746f72732f62616467652f3f76657273696f6e3d737461626c65)](https://readthedocs.org/projects/iterators/?badge=latest)[![Documentation Status](https://camo.githubusercontent.com/3476de9b089f8026985f6c56cad247cd6e74242495a7d938f48a5a341925a1b6/68747470733a2f2f72656164746865646f63732e6f72672f70726f6a656374732f6974657261746f72732f62616467652f3f76657273696f6e3d6c6174657374)](https://readthedocs.org/projects/iterators/?badge=latest)

Installation
------------

[](#installation)

```
composer require gielfeldt/iterators

```

### Iterators

[](#iterators-1)

This library contains a bunch of various iterators that I made primarily for getting more acquainted with iterators in PHP. Some may be useful. Some may be silly.

Enjoy!

[CachingIterator](#cachingiterator)

[ChecksumIterator](#checksumiterator)

[ChunkIterator](#chunkiterator)

[CloningIterator](#cloningiterator)

[CombineIterator](#combineiterator)

[CountableIterator](#countableiterator)

[DiffIterator](#diffiterator)

[FiniteIterator](#finiteiterator)

[FlipIterator](#flipiterator)

[GlobIterator](#globiterator)

[IndexIterator](#indexiterator)

[InfiniteIterator](#infiniteiterator)

[InterleaveIterator](#interleaveiterator)

[IntersectIterator](#intersectiterator)

[TraversableIterator](#traversableiterator)

[KeysIterator](#keysiterator)

[MapIterator](#mapiterator)

[RandomIterator](#randomiterator)

[RepeatIterator](#repeatiterator)

[ReplaceableIterator](#replaceableiterator)

[ReservoirSamplingIterator](#reservoirsamplingiterator)

[ShuffleIterator](#shuffleiterator)

[SortIterator](#sortiterator)

[StepIterator](#stepiterator)

[UniqueIterator](#uniqueiterator)

[ValuesIterator](#valuesiterator)

#### CachingIterator

[](#cachingiterator)

Cache an iterator for multiple iterations.

```
use Gielfeldt\Iterators\CachingIterator;

$input = new \ArrayIterator(range(1, 4));
$input = new \NoRewindIterator($input);
$cached = new CachingIterator($input);

print_r(iterator_to_array($cached));
print_r(iterator_to_array($cached));
```

Output:

```
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
)
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
)

```

#### ChecksumIterator

[](#checksumiterator)

Generate a checksum for an iterator, either per iteration or the entire dataset.

```
use Gielfeldt\Iterators\ChecksumIterator;

$input = new \ArrayIterator([
    ['key1' => 'value1'],
    ['key2' => 'value2'],
    ['key3' => 'value3'],
]);

$iterator = new ChecksumIterator($input, 'md5');
foreach ($iterator as $key => $value) {
    print "$key => $value\n";
}

var_dump($iterator->getChecksum());

var_dump((string) $iterator);
```

Output:

```
0 => e2e517365ffe6fedd279364e3fa74786
1 => f0a0db0fc9abe193b21fd657fe678884
2 => c04f606bb5bba82282dfa93edb59c6ee

string(32) "4fd19adc845da6fdd9c7c394f4626bac"

string(32) "4fd19adc845da6fdd9c7c394f4626bac"

```

#### ChunkIterator

[](#chunkiterator)

Split an iterator into chunks of iterators.

```
use Gielfeldt\Iterators\ChunkIterator;
use Gielfeldt\Iterators\AtomicTempFileObject;

// Split a file into multiple files of a 100 lines each.
$file = new \SplFileObject('inputfile');
foreach (new ChunkIterator($file, 100) as $i => $lines) {
    AtomicTempFileObject::file_put_contents("outputfile.part.$i", implode("", iterator_to_array($lines)));
}
```

#### CloningIterator

[](#cloningiterator)

Clone each value in iteration.

```
use Gielfeldt\Iterators\CloningIterator;

$object1 = (object) ['value' => 'test1'];
$object2 = (object) ['value' => 'test2'];
$object3 = (object) ['value' => 'test3'];

$input = new \ArrayIterator([$object1, $object2, $object3]);

$iterator = new CloningIterator($input);
$cloned = iterator_to_array($iterator);
$object1->value = 'MODIFIED';
var_dump(iterator_to_array($input));
var_dump($cloned);
```

Output:

```
array(3) {
  [0] =>
  class stdClass#2 (1) {
    public $value =>
    string(8) "MODIFIED"
  }
  [1] =>
  class stdClass#3 (1) {
    public $value =>
    string(5) "test2"
  }
  [2] =>
  class stdClass#4 (1) {
    public $value =>
    string(5) "test3"
  }
}

array(3) {
  [0] =>
  class stdClass#9 (1) {
    public $value =>
    string(5) "test1"
  }
  [1] =>
  class stdClass#10 (1) {
    public $value =>
    string(5) "test2"
  }
  [2] =>
  class stdClass#11 (1) {
    public $value =>
    string(5) "test3"
  }
}

```

#### CombineIterator

[](#combineiterator)

Similar to array\_combine(). However, iterators can have non-unique keys. Be aware of this when using iterator\_to\_array();

```
use Gielfeldt\Iterators\CombineIterator;

$keys = new \ArrayIterator(['key1', 'key2', 'key3', 'key1', 'key2', 'key3']);
$values = new \ArrayIterator(['value1', 'value2', 'value3', 'value4', 'value5', 'value6']);

$iterator = new CombineIterator($keys, $values);
foreach ($iterator as $key => $value) {
    print "$key => $value\n";
}

print_r(iterator_to_array($iterator));
```

Output:

```
key1 => value1
key2 => value2
key3 => value3
key1 => value4
key2 => value5
key3 => value6
Array
(
    [key1] => value4
    [key2] => value5
    [key3] => value6
)

```

#### CountableIterator

[](#countableiterator)

Takes any iterator and makes it countable, simply by iterating through it and counting.

```
use Gielfeldt\Iterators\CountableIterator;

$some_noncountable_iterator = new \IteratorIterator(new \ArrayIterator([1, 2, 3]));
$iterator = new CountableIterator($some_noncountable_iterator);
var_dump(count($iterator));
```

Output:

```
int(3)

```

#### DiffIterator

[](#diffiterator)

Compares two iterators. Similar to array\_diff(). Possible to set a custom compare function.

```
use Gielfeldt\Iterators\DiffIterator;

$input1 = new \ArrayIterator(['key1'  => 'value1', 'key2'  => 'value2', 'key3'  => 'value3']);
$input2 = new \ArrayIterator(['key11' => 'value1', 'key22' => 'value1', 'key2'  => 'value3']);
$input3 = new \ArrayIterator(['key1'  => 'value2', 'key2'  => 'value2', 'key33' => 'value3']);

$iterator = new DiffIterator($input1, $input2, $input3);
$iterator->setDiff(function ($iterator, $key, $value) {
    return $iterator->key() == $key && $iterator->current() == $value;
});
print_r(iterator_to_array($iterator));
```

Output:

```
Array
(
    [key1] => value1
    [key3] => value3
)

```

#### FiniteIterator

[](#finiteiterator)

Provide an end condition through an anonymous function for an iterator.

```
use Gielfeldt\Iterators\FiniteIterator;

$input = new \ArrayIterator(range(1, 8));
$some = new FiniteIterator($input, function ($iterator) {
    return $iterator->current() > 5;
});

print_r(iterator_to_array($some));
```

Output:

```
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)

```

#### FlipIterator

[](#flipiterator)

Similar to array\_flip(). However, iterators can have non-unique keys. Be aware of this when using iterator\_to\_array();

```
use Gielfeldt\Iterators\FlipIterator;

$input = new \ArrayIterator([
    'key1'  => 'value1',
    'key2'  => 'value2',
    'key3'  => 'value3',
    'key4'  => 'value1',
    'key5'  => 'value2',
    'key6'  => 'value3',
]);

$iterator = new FlipIterator($input);
foreach ($iterator as $key => $value) {
    print "$key => $value\n";
}

print_r(iterator_to_array($iterator));
```

Output:

```
value1 => key1
value2 => key2
value3 => key3
value1 => key4
value2 => key5
value3 => key6
Array
(
    [value1] => key4
    [value2] => key5
    [value3] => key6
)

```

#### GlobIterator

[](#globiterator)

Similar to \\GlobIterator, but supports \*\*

```
use Gielfeldt\Iterators\GlobIterator;

$iterator = new GlobIterator('/tmp/**.log');
var_dump(iterator_to_array($iterator));
```

Output:

```
array(2) {
  '/tmp/one.log' =>
  class Gielfeldt\Iterators\GlobIteratorFileInfo#17 (2) {
    private $pathName =>
    string(20) "/tmp/one.log"
    private $fileName =>
    string(10) "one.log"
  }
  '/tmp/somedir/two.log' =>
  class Gielfeldt\Iterators\GlobIteratorFileInfo#16 (2) {
    private $pathName =>
    string(20) "/tmp/somedir/two.log"
    private $fileName =>
    string(15) "two.log"
  }
}

```

#### IndexIterator

[](#indexiterator)

Iterate only through certain rows of an iterator.

```
use Gielfeldt\Iterators\IndexIterator;

$input = new \ArrayIterator([
    'test1' => 'val6',
    'test2' => 'val5',
    'test3' => 'val4',
    'test4' => 'val3',
    'test5' => 'val2',
    'test6' => 'val1',
]);
$some = new IndexIterator($input, [2, 3, 5]);

print_r(iterator_to_array($some));
```

Output:

```
Array
(
    [test3] => val4
    [test4] => val3
    [test6] => val1
)

```

#### InfiniteIterator

[](#infiniteiterator)

Like SPL's InfiniteIterator but provides an additional method, getCurrentIteration().

```
use Gielfeldt\Iterators\InfiniteIterator;
use Gielfeldt\Iterators\FiniteIterator;

$input = new \ArrayIterator(range(1, 4));
$infinite = new InfiniteIterator($input);
$some = new FiniteIterator($infinite, function ($iterator) {
    return $iterator->getCurrentIteration() >= 2 && $iterator->current() > 2;
});

foreach ($some as $k => $v) {
    print $some->getCurrentIteration() . ": $k => $v\n";
}
```

Output:

```
0: 0 => 1
0: 1 => 2
0: 2 => 3
0: 3 => 4
1: 0 => 1
1: 1 => 2
1: 2 => 3
1: 3 => 4
2: 0 => 1
2: 1 => 2

```

#### InterleaveIterator

[](#interleaveiterator)

Interleave multiple iterators.

```
use Gielfeldt\Iterators\InterleaveIterator;

$input1 = new \ArrayIterator([
    'key1' => 'value11',
    'key2' => 'value12',
    'key3' => 'value13',
]);

$input2 = new \ArrayIterator([
    'key21' => 'value21',
    'key22' => 'value22',
    'key23' => 'value23',
]);

$input3 = new \ArrayIterator([
    'key1' => 'value31',
    'key2' => 'value32',
    'key3' => 'value33',
]);

$iterator = new InterleaveIterator($input1, $input2, $input3);
foreach ($iterator as $key => $value) {
    print "$key => $value\n";
}

print_r(iterator_to_array($iterator));
```

Output:

```
key1 => value11
key21 => value21
key1 => value31
key2 => value12
key22 => value22
key2 => value32
key3 => value13
key23 => value23
key3 => value33
Array
(
    [key1] => value31
    [key21] => value21
    [key2] => value32
    [key22] => value22
    [key3] => value33
    [key23] => value23
)

```

#### IntersectIterator

[](#intersectiterator)

Similar to array\_intersect(). Possible to set a custom compare function.

```
use Gielfeldt\Iterators\IntersectIterator;

$input1 = new \ArrayIterator(['key1'  => 'value1', 'key2' => 'value2', 'key3' => 'value3']);
$input2 = new \ArrayIterator(['key11' => 'value1', 'key1' => 'value1', 'key2' => 'value3']);
$input3 = new \ArrayIterator(['key1'  => 'value2', 'key2' => 'value2', 'key1' => 'value1']);

$iterator = new IntersectIterator($input1, $input2, $input3);
$iterator->setDiff(function ($iterator, $key, $value) {
    return $iterator->key() == $key && $iterator->current() == $value;
});
print_r(iterator_to_array($iterator));
```

Output:

```
Array
(
    [key1] => value1
)

```

#### TraversableIterator

[](#traversableiterator)

Like SPL's IteratorIterator, but with a more meaningful name :-) and provides a getIndex() method.

```
use Gielfeldt\Iterators\TraversableIterator;

$keys = range(1, 10);
shuffle($keys);
$values = range(1, 10);
shuffle($values);

$input = new \ArrayIterator(array_combine($keys, $values));
$iterator = new TraversableIterator($input);

foreach ($iterator as $k => $v) {
    print $iterator->getIndex() . ": $k => $v\n";
}
```

Output:

```
0: 1 => 3
1: 4 => 2
2: 9 => 10
3: 3 => 8
4: 2 => 6
5: 5 => 5
6: 8 => 1
7: 10 => 9
8: 6 => 7
9: 7 => 4

```

#### KeysIterator

[](#keysiterator)

Similar to array\_keys().

```
use Gielfeldt\Iterators\KeysIterator;

$input = new \ArrayIterator([
    'key1' => 'value1',
    'key2' => 'value2',
    'key3' => 'value3',
]);

$iterator = new KeysIterator($input);

print_r(iterator_to_array($iterator));
```

Output:

```
Array
(
    [0] => key1
    [1] => key2
    [2] => key3
)

```

#### MapIterator

[](#mapiterator)

Similar to array\_map().

```
use Gielfeldt\Iterators\MapIterator;

$input = new \ArrayIterator([
    'key1'  => 'value1',
    'key2'  => 'value2',
    'key3'  => 'value3',
    'key4'  => 'value1',
    'key5'  => 'value2',
    'key6'  => 'value3',
]);

// Flip keys and values.
$iterator = new MapIterator($input, function ($iterator) {
    return [$iterator->current(), $iterator->key()];
});

foreach ($iterator as $key => $value) {
    print "$key => $value\n";
}

print_r(iterator_to_array($iterator));
```

Output:

```
value1 => key1
value2 => key2
value3 => key3
value1 => key4
value2 => key5
value3 => key6
Array
(
    [value1] => key4
    [value2] => key5
    [value3] => key6
)

```

#### RandomIterator

[](#randomiterator)

Selects a set of random elements from a traversable. Does not work with iterators that can only be traversed once. For that, see the ReservoirSamplingIterator.

```
use Gielfeldt\Iterators\RandomIterator;

$input = new \ArrayIterator(range(1, 10));
$random = new RandomIterator($input, 4);

var_dump(count($random));

print_r(iterator_to_array($random));
```

Output:

```
int(4)
Array
(
    [1] => 2
    [6] => 7
    [7] => 8
    [8] => 9
)

```

#### RepeatIterator

[](#repeatiterator)

Repeat and iterator n times.

```
use Gielfeldt\Iterators\RepeatIterator;

$input = new \ArrayIterator([
    'key1'  => 'value1',
    'key2'  => 'value2',
    'key3'  => 'value3',
]);

$iterator = new RepeatIterator($input, 3);

foreach ($iterator as $key => $value) {
    print "$key => $value\n";
}

print_r(iterator_to_array($iterator));
```

Output:

```
key1 => value1
key2 => value2
key3 => value3
key1 => value1
key2 => value2
key3 => value3
key1 => value1
key2 => value2
key3 => value3
Array
(
    [key1] => value1
    [key2] => value2
    [key3] => value3
)

```

#### ReplaceableIterator

[](#replaceableiterator)

Just like TraversableIterator but with a setInnerIterator() method.

```
use Gielfeldt\Iterators\ReplaceableIterator;

$iterator = new ReplaceableIterator(new \ArrayIterator(range(1, 4)));
print_r(iterator_to_array($iterator));

$iterator->setInnerIterator(new \ArrayIterator(range(5, 8)));
print_r(iterator_to_array($iterator));
```

Output:

```
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
)
Array
(
    [0] => 5
    [1] => 6
    [2] => 7
    [3] => 8
)

```

#### ReservoirSamplingIterator

[](#reservoirsamplingiterator)

Like RandomIterator but works more effeciently on iterators of unknown size or which can be traversed only once.

```
use Gielfeldt\Iterators\ReservoirSamplingIterator;

$input = new \ArrayIterator(range(1, 10));
$input = new \NoRewindIterator($input);
$random = new ReservoirSamplingIterator($input, 4);

print_r(iterator_to_array($random));
```

Output:

```
int(4)
Array
(
    [1] => 2
    [6] => 7
    [7] => 8
    [8] => 9
)

```

#### ShuffleIterator

[](#shuffleiterator)

Iterate randomly over a traversable.

```
use Gielfeldt\Iterators\ShuffleIterator;

$input = new \ArrayIterator(range(1, 10));
$shuffled = new ShuffleIterator($input);

print_r(iterator_to_array($shuffled));
print_r(iterator_to_array($shuffled));
```

Output:

```
Array
(
    [1] => 2
    [4] => 5
    [0] => 1
    [9] => 10
    [7] => 8
    [5] => 6
    [2] => 3
    [8] => 9
    [3] => 4
    [6] => 7
)
Array
(
    [1] => 2
    [9] => 10
    [4] => 5
    [2] => 3
    [5] => 6
    [0] => 1
    [8] => 9
    [3] => 4
    [7] => 8
    [6] => 7
)

```

#### SortIterator

[](#sortiterator)

```
use Gielfeldt\Iterators\SortIterator;

$input = new \ArrayIterator([6, 3, 2, 7, 1, 9]);
$iterator = new SortIterator($input);
print_r(iterator_to_array($iterator));

$input = new \ArrayIterator([6, 3, 2, 7, 1, 9]);
$iterator = new SortIterator($input, SortIterator::SORT_DESC);
print_r(iterator_to_array($iterator));

$input = new \ArrayIterator([6, 3, 2, 7, 1, 9]);
$iterator = new SortIterator($input, SortIterator::SORT_ASC, SortIterator::SORT_REINDEX);
print_r(iterator_to_array($iterator));

$input = new \ArrayIterator([6, 3, 2, 7, 1, 9]);
$iterator = new SortIterator($input, SortIterator::SORT_ASC, SortIterator::SORT_REINDEX, function ($a, $b) {
    return -$a->current  -$b->current;
});
print_r(iterator_to_array($iterator));
```

Output:

```
Array
(
    [4] => 1
    [2] => 2
    [1] => 3
    [0] => 6
    [3] => 7
    [5] => 9
)
Array
(
    [5] => 9
    [3] => 7
    [0] => 6
    [1] => 3
    [2] => 2
    [4] => 1
)
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 6
    [4] => 7
    [5] => 9
)
Array
(
    [0] => 9
    [1] => 7
    [2] => 6
    [3] => 3
    [4] => 2
    [5] => 1
)

```

#### StepIterator

[](#stepiterator)

Iterate over a traversable in steps.

```
use Gielfeldt\Iterators\StepIterator;

$input = new \ArrayIterator(range(1, 10));
$stepped = new StepIterator($input, 2);

print_r(iterator_to_array($stepped));
```

Output:

```
Array
(
    [0] => 1
    [2] => 3
    [4] => 5
    [6] => 7
    [8] => 9
)

```

#### UniqueIterator

[](#uniqueiterator)

Similar to array\_unique(). Also supports a custom callback function.

```
use Gielfeldt\Iterators\UniqueIterator;

$input = new \ArrayIterator([-4, -3, -2, -1, 0, 1, 2, 3, 5]);

// Unique elements by their square.
$iterator = new UniqueIterator($input, UniqueIterator::REINDEX, function ($iterator) {
    return $iterator->current() * $iterator->current();
});

print_r(iterator_to_array($iterator));
```

Output:

```
Array
(
    [0] => -4
    [1] => -3
    [2] => -2
    [3] => -1
    [4] => 0
    [8] => 5
)

```

#### ValuesIterator

[](#valuesiterator)

Similar to array\_vales().

```
use Gielfeldt\Iterators\ValuesIterator;

$input = new \ArrayIterator([
    'key1' => 'value1',
    'key2' => 'value2',
    'key3' => 'value3',
]);

$iterator = new ValuesIterator($input);

print_r(iterator_to_array($iterator));
```

Output:

```
Array
(
    [0] => value1
    [1] => value2
    [2] => value3
)

```

### Not iterators as such ...

[](#not-iterators-as-such-)

These are more an extension of the SPL file handling.

[CsvFileObject](#csvfileobject)

[AtomicTempFileObject](#atomictempfileobject)

[AtomicTempFileObjects](#atomictempfileobjects)

#### CsvFileObject

[](#csvfileobject)

An extension of SplFileObject in csv mode, but with csv header support.

```
use Gielfeldt\Iterators\CsvFileObject;

// Load csv file and dump it.
$file = new CsvFileObject('somefile.csv');
print_r(iterator_to_array($file));

// Same but csv comes via a string variable.
$csvdata = "Columm1,Column2\nValue1,Value2\nValue3,Value4";
$file = new CsvFileObject('data://application/octet,' . $csvdata);
print_r(iterator_to_array($file));
```

Output:

```
Array
(
    [0] => Array
        (
            [Columm1] => Value1
            [Column2] => Value2
        )

    [1] => Array
        (
            [Columm1] => Value3
            [Column2] => Value4
        )

)
Array
(
    [0] => Array
        (
            [Columm1] => Value1
            [Column2] => Value2
        )

    [1] => Array
        (
            [Columm1] => Value3
            [Column2] => Value4
        )

)

```

#### AtomicTempFileObject

[](#atomictempfileobject)

#### AtomicTempFileObjects

[](#atomictempfileobjects)

### Helpers

[](#helpers)

Contains various helper methods.

#### Iterator

[](#iterator)

```
use Gielfeldt\Iterators\Iterator;

$input = new \ArrayIterator([1,2,3,4,5,6]);
var_dump(Iterator::sum($input));
var_dump(Iterator::product($input));
var_dump(Iterator::average($input));
var_dump(Iterator::min($input));
var_dump(Iterator::max($input));
```

Output:

```
int(21)

int(720)

double(3.5)

int(1)

int(6)

```

### Caveats

[](#caveats)

1. Lots probably.

###  Health Score

28

—

LowBetter than 52% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity22

Limited adoption so far

Community10

Small or concentrated contributor base

Maturity50

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 98.6% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~568 days

Total

2

Last Release

2789d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/e93f60ea3dd735998209863ed3e064b4aa440db3c23b08f44bf0655c28b0bd3c?d=identicon)[gielfeldt](/maintainers/gielfeldt)

---

Top Contributors

[![gielfeldt](https://avatars.githubusercontent.com/u/4096963?v=4)](https://github.com/gielfeldt "gielfeldt (143 commits)")[![scrutinizer-auto-fixer](https://avatars.githubusercontent.com/u/6253494?v=4)](https://github.com/scrutinizer-auto-fixer "scrutinizer-auto-fixer (2 commits)")

---

Tags

iteratorglobrecursive

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/gielfeldt-iterators/health.svg)

```
[![Health](https://phpackages.com/badges/gielfeldt-iterators/health.svg)](https://phpackages.com/packages/gielfeldt-iterators)
```

###  Alternatives

[nikic/iter

Iteration primitives using generators

1.1k6.2M51](/packages/nikic-iter)[loophp/collection

A (memory) friendly, easy, lazy and modular collection class.

743730.3k15](/packages/loophp-collection)[athari/yalinqo

YaLinqo, a LINQ-to-objects library for PHP

4531.2M5](/packages/athari-yalinqo)[ihor/nspl

Non-standard PHP library (NSPL) - functional primitives toolbox and more

375369.1k](/packages/ihor-nspl)[ginq/ginq

LINQ to Object inspired DSL for PHP

192258.2k3](/packages/ginq-ginq)[chdemko/sorted-collections

Sorted Collections for PHP >= 8.4

222.6M3](/packages/chdemko-sorted-collections)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)