<?php
var_dump(spl_classes());

<?php
var_dump(get_declared_interfaces());

<?php
foreach ($foo as $key=>$val)
{
    echo "$key vaut $val";
}

<?php
$fooIt = $foo->getIterator();
$fooIt->rewind();
while ($fooIt->valid()) {
    echo "$fooIt->key() vaut $fooIt->current()";
    $fooIt->next();
}

<?php
class Bar
{
	private $_var = 2 ;
	public $foo = 8;
}

$bar = new Bar;
foreach ($bar as $k=>$v)
{
	echo $k . " a la valeur ". $v; 
}

// affiche foo a la valeur 8

<?php
class MonArray implements Iterator
{
    private $_tab = array();

    private $_pas;

    public function __construct(array $array, $pas = 1)
    {
        $this->_tab = $array;
        $this->_pas = abs((int)$pas);
    }

    public function valid()
    {
        return array_key_exists(key($this->_tab),$this->_tab);
    }

    public function next()
    {
        for ($i=1; $i<=$this->_pas;$i++) {
            next($this->_tab);
        }
        return $this;
    }

    public function rewind()
    {
        reset($this->_tab);
        return $this;
    }

    public function key()
    {
        return key($this->_tab);
    }

    public function current()
    {
        return current($this->_tab);
    }
}

<?php
$tablo = range (0,10);
$mon_array = new MonArray($tablo, 2));

foreach($mon_array as $v)
{
    echo $v;
}

<?php
$pdo  = new PDO('mysql:host=localhost;dbname=test','logintest','passtest');
$stmt = $pdo->query("SELECT * FROM test");
$it   = new IteratorIterator($stmt);

foreach ($it as $val) {
    echo $val;
}

<?php
class MonArray implements Iterator, Countable
{
    // la classe reste la même qu'au dessus, on rajoute cependant :
    public function count()
    {
        return count($this->_tab);
    }
}

<?php
class MonArray implements RecursiveIterator
{
    private $_tab = array();
    private $_pas;

    public function __construct(array $array, $pas = 1)
    {
        $this->_tab = $array;
        $this->_pas = abs((int)$pas);
    }

    public function valid()
    {
        return array_key_exists(key($this->_tab),$this->_tab);
    }

    public function next()
    {
        for ($i=1; $i<=$this->_pas;$i++) {
            next($this->_tab);
        }
        return $this;
    }

    public function rewind()
    {
        reset($this->_tab);
        return $this;
    }

    public function key()
    {
        return key($this->_tab);
    }

    public function current()
    {
        return current($this->_tab);
    }

    public function hasChildren()
    {
        return is_array(current($this->_tab));
    }

    public function getChildren()
    {
        return new self(current($this->_tab));
    }

<?php
$tablo = range (0,10);
$tablo[] = array('u',array('w'));
$tablo[] = array('x',array('z'));
$a = new RecursiveIteratorIterator(new MonArray($tablo,1));

foreach($a as $k=>$v)
{
    echo $v.' ';
}

<?php
$itere = new RecursiveIteratorIterator(new MonArray($tablo,1));

$limiteur = new LimitIterator($itere,5,4);
foreach($limiteur AS $v)
{
    echo $v;
}

<?php
class MonArray implements SeekableIterator
{
    // même code qu'auparavent
    
    public function seek($index)
    {
        if (array_key_exists($index,$this->_tab)) {
            $this->_key = $index;
            return $this->_tab[$index];
        }
    }
}

<?php 
class MonArrayFiltre extends FilterIterator 
{
    public function __construct(MonArray $mon_array)
    {
        parent::__construct(new RecursiveIteratorIterator($mon_array));
    }
	
    public function accept()
    {
        $it = $this->getInnerIterator();
        return strlen($it->current()) == 1 ? true: false;
    }
}

$a = new MonArrayFiltre(new MonArray(array('erf',array('r'),'x','y','zz')));

foreach($a AS $v) {
    echo $v;
}

<?php
class DefinedFunction extends RegexIterator 
{
    public function __construct($regex, $mode = 0, $flags = 0, $preg_flags = 0)
    {
        $phpFunctions = get_defined_functions();
        parent::__construct(new ArrayIterator(array_shift($phpFunctions)), $regex, $mode, $flags, $preg_flags);
    }
}

foreach (new DefinedFunction('/str/') as $key=>$val) {
    echo $val;
}

<?php
$directory ="path/to/dir"; 
$iter = new RecursiveIteratorIterator(
	 new RecursiveDirectoryIterator($directory,RecursiveDirectoryIterator::KEY_AS_FILENAME)
	 ,RecursiveIteratorIterator::SELF_FIRST);

foreach ($iter as $entry) {
    if ($entry->isDir()) {
        $token = "<b>%s</b>";
    }else{
        $token = "%s";
    }
    echo str_repeat("&nbsp;", 3*$iter->getDepth());
    printf($token."<br>",$entry);
}

<?php
$arr1  = new ArrayIterator(array(1,2,3));
$arr2  = new ArrayIterator(array(4,5,6));

$ai = new AppendIterator();
$ai->append($arr1);
$ai->append($arr2);

foreach ($ai as $value) {
    echo $value; // 123456
}

<?php
$arr = array(
         10,
         array(1, 2, 3),
         11,
         array(4, 5, 6),
         12 );
$pi = new ParentIterator(new RecursiveArrayIterator($arr));

foreach ($pi as $key=>$val) {
    printf("%s - %s",$key,print_r($val,true));
}
/*
1 - Array
(
    [0] => 1
    [1] => 2
    [2] => 3
)
3 - Array
(
    [0] => 4
    [1] => 5
    [2] => 6
)
*/

<?php
$pdo = new PDO('mysql:host=localhost;dbname=test','logintest','passtest');
$stmt = new CachingIterator(new IteratorIterator($pdo->query("SELECT * FROM test")));
$stmt->rewind();
$stmt->next();
$stmt->next();

if ($stmt->hasNext()) {
    echo "il reste des résultats";
}

<?php
$xml =<<<EOF
<doc>
<a>hello</a>
<a>
	<b>world</b>
	<c />
	<d>
	  <e>coucou</e>
	</d>
</a>
<c>developpez</c>
</doc>
EOF;

$sxml = new RecursiveIteratorIterator(new SimpleXMLIterator($xml));
foreach ($sxml as $val) {
	printf("%s - ",$val); // hello world coucou developpez
}

<?php

class FunctionProxy implements ArrayAccess
{
    const SEPARATOR = '_';    
    private $_func;
    
    public function offsetGet($offset)
    {
        $this->_func = $offset;
        return $this;
    }
    
    public function offsetSet($offset,$value)
    {
        throw new Exception('Affectation interdite');
    }
    
    public function offsetExists($offset)
    {
        return ($this->_func == $offset);
    }
    
    public function offsetUnset($offset)
    {
        throw new Exception('Déréférencement interdit');
    }
    
    public function __call($func,$args)
    {
        $func = $this->_func.self::SEPARATOR.$func;
        if (!function_exists($func)) {
            throw new Exception("PHP function $func doesn't exist");
        }        
        return @call_user_func_array($func,$args);
    }
}
$p = new functionProxy();
$p['array']->combine($array1, $array2); // proxy vers la fonction PHP array_combine()
$p['str']->replace(/* ... */); // proxy vers la fonction PHP str_replace()

<?php
$ar = new ArrayObject(array('a','b','c'));
$ar['key'] = 'd';

echo $ar->count(); // 4
$oldArray = $ar->exchangeArray(array(1,2,3));
foreach($ar as $value) {
echo $value;
}
// affiche alors 123

<?php
$ar = new ArrayObject(array('a','b','c'), ArrayObject::ARRAY_AS_PROPS);
$ar->key = 'd';

echo $ar->count(); // 4

<?php
$ar = new ArrayObject(array('a','b','c',array('d')));
$ar['key'] = array('some value','another value');

$ar->setIteratorClass('RecursiveArrayIterator');
$itere = new RecursiveIteratorIterator($ar);
foreach($itere as $value) {
echo $value;
}
// affiche : abcdsome valueanother value 

<?php
class Panier extends SplObjectStorage
{
    private $_items;
    
    public function attach($i)
    {
        if (!$i instanceof Item) {
            throw new Exception('Item requis');
        }
        return parent::attach($i);
    }
    
    public function detach($i)
    {
        if (!$i instanceof Item) {
            throw new Exception('Item requis');
        }
        return parent::detach($i);
    }
    
    public function calculTotal()
    {
        foreach ($this as $item) {
            $somme[] = $item->price;
        }
        return array_sum($somme);
    }
}

$it = new ArrayIterator(array('foo'=>'bar', 'baz'=>'developpez', 'julien'=>'pauli');
var_dump(iterator_to_array($it));