Difference between ArrayIterator, ArrayObject and Array in PHP

Question

Can somebody explain clearly the fundamental differences between ArrayIterator, ArrayObject and Array in PHP in terms of functionality and

Answer 1

EDIT:forgot to address the normal array in my answer..

Before you read all this, if your new to php and not trying to do anything tricky just storing values to be used later, then just use the array primitive type.

$data = [1,2,3,4,5];
//or
$data = array(1,2,3,4,5);

Array is the entry point and you should get used to using first them before considering using the others. If you do not understand arrays then you will probably will not understand the benefits of using the others. ( See https://www.w3schools.com/php/php_arrays.asp for a tutorial on arrays. )

Otherwise continue reading...

I have the same question and after coming here decided to just spend some time testing them out and here is my findings and conclusions...

First lets clear up some things that were said by others that I immediately tested.

ArrayObject and ArrayItterator do not protect the data. Both can still be passed by reference in a for-each loop (see down he bottom for example).

Both return true for is_object(), both return false for is_array() and both allow direct access to the values as an array without providing protection for adding values etc. and both can be passed by reference allowing the original data to be manipulated during a foreach loop.

$array = new ArrayIterator();
var_dump(is_array($array)); // false
var_dump(is_object($array)); // true
$array[] = 'value one';
var_dump($array[0]);//string(9) "value one"

$array = new ArrayObject();
var_dump(is_array($array)); // false
var_dump(is_object($array)); // true
$array[] = 'value one';
var_dump($array[0]);//string(9) "value one"

The big difference can be seen in the functions that are available for either of them.

ArrayIteroator has all the functions required to traverse the values such as a foreach loop. ( A foreach loop will call rewind(),valid(),current(),key() methods ) see: https://www.php.net/manual/en/class.iterator.php for an excellent example of the concept (lower level class documentation).

While an ArrayObject can still be iterated over and access values the same way, it does not offer public access to pointer functions.

Object is kind of like adding a wrapper arount the ArrayItterator object and has public getIterator ( void ) : ArrayIterator that will faciliate traversing of the values inside.

You can always get the ArrayItterator From ArrayObject if your really need the added functions.

ArrayItterator is best choice if you have your own pseudo foreach loop for traversing in weird ways and want better control instead of just start to end traversal.

ArrayItterator would also be a good choice for overriding the default array behavior when iterated over by a foreach loop. eg..

//I originally made to this to solve some problem where generic conversion to XML via a foreach loop was used,
//and I had a special case where a particular API wanted each value to have the same name in the XML.
class SameKey extends ArrayIterator{

    public function key()
    {
        return "AlwaysTheSameKey";
    }
}

$extendedArrayIterator =  new SameKey(['value one','value two','value three']);
$extendedArrayIterator[] = 'another item added after construct';
//according to foreach there all the keys are the same
foreach ($extendedArrayIterator as $key => $value){
    echo "$key: ";//key is always the same
    var_dump($value);
}
//can still be access as array with index's if you need to differentiate the values
for ($i = 0; $i < count($extendedArrayIterator); $i++){
    echo "Index [$i]: ";
    var_dump($extendedArrayIterator[$i]);
}

The ArrayObject might be a good choice if you have more high level complexities with itterators going on for example...

//lets pretend I have many custom classes extending ArrayIterator each with a different behavior..
$O = new ArrayObject(['val1','val2','val3']);
//and I want to change the behavior on the fly dynamically by changing the iterator class
if ($some_condition = true) $O->setIteratorClass(SameKey::class);
foreach ($O as $key => $value){
    echo "$key: ";//AlwaysTheSameKey:
    var_dump($value);
}

One example might be changing the output of the same data set such as having a bunch of custom iterators that will return the values in a different format when traversing the same data set. eg...

class AustralianDates extends ArrayIterator{
    public function current()
    {
        return Date('d/m/Y',parent::current());
    }
}
$O = new ArrayObject([time(),time()+37474,time()+37845678]);
//and I want to change the behaviour on the fly dynamically by changing the iterator class
if ($some_condition = true) $O->setIteratorClass(AustralianDates::class);
foreach ($O as $key => $value){
    echo "$key: ";//AlwaysTheSameKey:
    var_dump($value);
}

Obviously there are probably better ways to do this kind of thing.

In short these are the major major advantages differences I can see.

ArrayItorator - lower level ability to control or extend & override traversal behaviors.

VS

ArrayObject - one Container for data but able to change ArrayIterator class.

There are also other differences you might care to inspect but I'd imagine you wont fully grasp them all until you use them extensively.

It appears both objects can be used by reference in a foreach but NOT when using a custom itterator class via an ArrayObject..

//reference test
$I = new ArrayIterator(['mouse','tree','bike']);
foreach ($I as $key => &$value){
    $value = 'dog';
}
var_dump($I);//all values in the original are now 'dog'

$O = new ArrayObject(['mouse','tree','bike']);
foreach ($O as $key => &$value){
    $value = 'dog';
}
var_dump($O);//all values in the original are now 'dog'

$O->setIteratorClass(SameKey::class);
foreach ($O as $key => &$value){//PHP Fatal error:  An iterator cannot be used with foreach by reference
    $value = 'dog';
}
var_dump($O);

Recommendation/Conclusion

Use arrays.

If you want to do something tricky then, I'd recommend always using ArrayIterator to start off with and only move on to ArrayObject if you want to something specific that only ArrayObject can do.

Considering the ArrayObject can make use of any custom ArrayIterators you have created along the way, id say this is the logical path to take.

Hope this helps you as much as it helped me looking into it.