Let's take a look at that documentation.

The iterator interface requires five methods.

Current, key, next, rewind, and valid.

The countable interface requires a single count method.

Just like with our own interfaces, PHP will also throw exceptions

if we try to implement a built in interface without the required methods.

Since we are instantiating our collection class,

let's try previewing our site again.

We see the error telling us which methods need to be implemented.

So let's get to work.

For each public method we'll be creating,

we'll use a built-in function on our collection array.

For the iterator method, each function will be working with the array pointer.

The pointer saves the position on an array.

For public function current(),

we're going to return current

($this->collection);.

This will return the current pointer of the collection array.

We can duplicate this method for other five methods.

For key, the function is called key().

This gives you the key of the item the pointer is on.

For the method next, The function call is next.

For the method rewind((), The function call is actually reset.

This resets the pointer of the array to the first item.

For the method valid(), We're going to check the key

And see if it's not equal to null.

This will let us know if the current key is valid.

For count(), we'll us our common count function,

Which returns the number of items in the array.

Before we give our new collection a try,

lets add a vardump that will help us see what's going on.

In each of the iterator methods, we're going to add var_dump(_ _ and

then the magic constant METHOD.

Rewind, next key and

current.

We're ready to give our new collection a try.

So let's open index.php.

For our collection, we need to prse in the $repo.

By default, this will pull all the posts.

Let's loop through each post and return the title.

Foreach ($content as $item).

Echo $item-> title.

And let's check this out in the browser.

Let's view the source.

Let's increase this font size.

For the first pass, we can see that it rewinds the pointer.

Then it checks that the current item is valid.

If so, it returns the current item.

And this is where we get our title.

The following loops move the pointer to the next item

before checking that the item is valid and then returning current.

After the last item, the call to valid will return false and the loop will end.

Great, now that we've seen what happens, let's go back and

comment out those method dumps.