Claudiu Persoiu

Blog-ul lui Claudiu Persoiu


Archive for the ‘iterator’ tag

Generating generators in PHP 5.5

without comments

A new PHP version is about to be released. At the time I’m writing this blog PHP 5.5 is in beta 4.

Eager to see the updates, I’ve compiled the new beta version. The feature list is available at: http://www.php.net/manual/en/migration55.new-features.php

The generators are the most important feature..

Generating generators in PHP 5.5

A generator is basically a function that contains a call to “yield”.

Let’s take the example form php.net:

<?php
function xrange($start, $limit, $step = 1) {
   for ($i = $start; $i <= $limit; $i += $step) {
       yield $i;
   }
}

echo 'Single digit odd numbers: ';

/* Note that an array is never created or returned,
* which saves memory. */
foreach (xrange(1, 9, 2) as $number) {
   echo "$number ";
}
?>

Basically, the generator (xrange in this case), instead of returning an array, will return a value at a time, in order to be processed.

But wait… wasn’t this already possible before this version?

Generators before PHP 5.5

Before PHP 5.5 there were already Iterators:

<?php

class xrange implements Iterator
{
    private $position = 0;
    private $start;
    private $limit;
    private $step;

    public function __construct($start, $limit, $step = 1)
    {
        $this->start = $start;
        $this->limit = $limit;
        $this->step = $step;
        $this->position = 0;
    }

    function rewind()
    {
        $this->position = 0;
    }

    function current()
    {
        return $this->start + ($this->position * $this->step);
    }

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

    function next()
    {
        ++$this->position;
    }

    function valid()
    {
        return $this->current() <= $this->limit;
    }
}

echo 'Single digit odd numbers: ';

/* Note that an array is never created or returned,
 * which saves memory. */
foreach (new xrange(2, 9, 2) as $number) {
    echo "$number ";
}
?>

Beside the fact that the Iterator is an object with multiple properties, basically we can achieve the same result.

But why do we need generators then? Simple! Instead of using ~40 lines of code, we can simply use 5 to achieve the same goal.

Another interesting thing is that:

get_class(printer());

will return Generator.

Basically, a generator returns an object of type Generator, and this object extends Iterator.

The major difference, as it is described on the php.net website, is that the generator can not be reset, basically it goes one way only.

Sending information to the generators

Yes, generators work both ways, but each generator only works in one particular direction. If the syntax above is for “producing” data, then the syntax below is only for “consuming” data.

The syntax for a “consumer” is simple:

<?php
function printer() {
    $counter = 0;
    while(true) {
        $counter++;
        $value = yield;
        echo $value . $counter . PHP_EOL;
    }
    echo ‘Never executed...' . PHP_EOL;
}

$printer = printer();
$printer->send('Hello!');
echo 'Something is happening over here...' . PHP_EOL;
$printer->send('Hello!');
?>

The output will be:

Hello!1
Something is happening over here...
Hello!2

Basically, the value of yield can be used as any other value. What’s interesting is the while. On php.net is the folowing comment:

// Sends the given value to the
// generator as the result of
// the yield expression and
// resumes execution of the
// generator.

The loop is needed because the generator will stop after it processes the value and will only continue when a new value is received. If we remove the while, only the first value will be processed, regardless of how many times we’ll call send().

An interesting thing is that what comes after the loop will not be executed, that is in my case:
echo ‘Never executed…’ . PHP_EOL;

So, if it looks like a good place to release a resource (e.g. DB or file), in fact it isn’t, because that code will never get executed.

It seems useful for logging. Again, nothing that couldn’t have been done before, but now it allows for an easier approach.

I’ve found though something that doesn’t work:

<?php
function printer() {
    while(true) {
        echo yield . PHP_EOL;
    }
}

$printer = printer();
$printer->send('Hello world!');

foreach($printer as $line) {
    echo $line . PHP_EOF;
}

A little chaotic, isn’t it? But I was wondering what would happen:
Fatal error: Uncaught exception ‘Exception’ with message ‘Cannot rewind a generator that was already run’ in…

So, once send() is used on an iterator, you can’t use it as an iterator again. Of course, another one can be generated with:
printer();

What is more confusing is that Generator is a final class, so it can’t be extended, and if you try to instantiate it directly (although even if it worked it would be useless):
Catchable fatal error: The “Generator” class is reserved for internal use and cannot be manually instantiated in…

Conclusion

It is an interesting feature because it simplifies things a lot when you try to create an iterator.

Also the use of send() seems very interesting, not because it is doing something new, but because it is doing it easier.

On the other hand, I don’t like that there is the same syntax for both generator versions and even more that what is after the while is not getting executed. I think the syntax is a little confusing because there isn’t a clear difference between the two. On the other hand, this already exists in Python, so for inspirator the examples from this language can be used.

Written by Claudiu Persoiu

10 May 2013 at 9:11 AM

Posted in PHP

Tagged with , , ,

Iterating objects using PHP and SPL

without comments

Iterator patter is probably the most popular pattern from SPL. Is a very simple way to demonstrate the advantages of an interface and SPL.

Motivation:
The possibility of iterating object type structures, using functions like foreach(), var_dump(), print_r() etc.

Diagram:

iterator diagram

Iterator structure:

In SPL there are a lot of interfaces and classes for iteration.

Iterator interface base structure:

/**
 * Iterator interface from SPL
 */
Iterator extends Traversable {
      /**
       * Returns the current element
       */
      abstract public mixed current ( void )

      /**
       * Returns the key of the current element
       */
      abstract public scalar key ( void )

      /**
       * Moves to the next element in the array
       */
      abstract public void next ( void )

      /**
       * Reset the iteration to the initial position
       */
      abstract public void rewind ( void )

      /**
       * Check to see if the current position is valid
       */
      abstract public boolean valid ( void )
}

Example 1:

A simple iterator object.

/**
 * The class for the iterator object
 */
class Iterabil implements Iterator {

	/**
	 * The index for the iterated element
	 */
	private $_current = 0;

	/**
	 * Array with elements to iterate
	 */
	private $_elements = array();

	/**
	 * Constructor
	 *
	 * @param array $elements Elements to iterate
	 */
	public function __construct($elements) {
		$this->_elements = $elements;
	}

	/**
	 * Current element
	 *
	 * @return mixed Current element
	 */
	public function current() {
		return $this->_elements[$this->_current];
	}

	/**
	 * Current index
	 *
	 * @return integer Current index
	 */
	public function key() {
		return $this->_current;
	}

	/**
	 * Move to the next index
	 */
	public function next() {
		$this->_current++;
	}

	/**
	 * Reset index
	 */
	public function rewind() {
		$this->_current = 0;
	}

	/**
	 * Check if the current element is set
	 *
	 * @return boolean If the current element is set
	 */
	public function valid() {
          return isset($this->_elements[$this->_current]);
     }
}

// class instance
$obj = new Iterabil(array(1, 2, 3, 4, 5));

// iterate object
foreach ($obj as $value) {
     echo $value.PHP_EOL;
}

// output:
// 1
// 2
// 3
// 4
// 5

Example 2:

Another example a little more complex, a class that allows to iterate through the public properties of a class which extends it. Iterator and Reflection are used.

/**
 * Class which iterates through the public properties of a class which extends it
 */
class Iterabil implements Iterator {

     /**
       * The index for the iterated element
       */
     private $_current = 0;

     /**
      * Array with elements to iterate
      */
     private $_elements = array();

     /**
      * Current element
      *
      * @return mixed Current element
      */
     public function current() {
          return $this->_elements[$this->_current]->name;
     }

     /**
      * Current index
      *
      * @return integer Current index
      */
     public function key() {
          return $this->_current;
     }

     /**
      * Move to next index
      */
     public function next() {
          $this->_current++;
     }

     /**
      * Reset index and get the properties
      */
     public function rewind() {
          // rewind is the first to be called
          // here the properties list should be obtained
          // ReflectionClass is initialized
          // with the current class name as a parameter
          $reflection = new ReflectionClass(get_class($this));

          // we get the public properties
          $this->_elements = $reflection->getProperties(ReflectionMethod::IS_PUBLIC);

          // set the current index
          $this->_current = 0;
     }

     /**
      * Check if the current element is set
      *
      * @return boolean If the current element is set
      */
     public function valid() {
         return isset($this->_elements[$this->_current]);
    }
}

/**
 * A new class with public properties
 *
 */
class Testing extends Iterabil {
     public $proprietate1;
     public $proprietate2;
}

// class instance
$obj = new Testing();

// iterate object
foreach ($obj as $value) {
     echo $value.PHP_EOL;
}

// output:
// proprietate1
// proprietate2

And if you what the above example to be accessible as an array you just have to implement ArrayAccess from SPL.

ArrayAccess structure:

ArrayAccess   {
    /**
     * Check if the offset exists
     */
    abstract public boolean offsetExists ( string $offset );

    /**
     * Returns the element of an offset or NULL if it does not exist
     */
    abstract public mixed offsetGet ( string $offset );

    /**
     * Set a value for an offset
     */
    abstract public void offsetSet ( string $offset , string $value );

    /**
     * Unset a value for an offset
     */
    abstract public void offsetUnset ( string $offset )
}

Example 3:

An even more complicated example which shows the power of interfaces from SPL. Iterator object accessible like an array.

To simplify the array access logic I’ve used the php native functions for iterating an array (next(), reset()).

/**
 * The class for the iterator object
 */
class Iterabil implements Iterator, ArrayAccess, Countable {

     /**
      * Array with elements to iterate
      */
     private $_elements = array();

     /**
      * Constructor
      *
      * @param array $elements Elementele de iterat
      */
     public function __construct($elements) {
          $this->_elements = $elements;
     }

     /**
      * Current element
      *
      * @return mixed Current element
      */
     public function current() {
          return current($this->_elements);
     }

     /**
      * Current index
      *
      * @return integer Current index
      */
     public function key() {
          return key($this->_elements);
     }

     /**
      * Move to the next index
      */
     public function next() {
          next($this->_elements);
     }

     /**
      * Reset index
      */
     public function rewind() {
          reset($this->_elements);
     }

     /**
      * Check if the current element is set
      *
      * @return boolean If the current element is set
      */
     public function valid() {
          return current($this->_elements)?true:false;
    }
    /**
     * Check if the offset exists
     *
     * @param string $offset Element key
     * @return boolean If the element is set
     */
    public function offsetExists($offset) {
         return isset($this->_elements[$offset]);
    }

    /**
     * Returns the element of an offset or NULL if it does not exist
     *
     * @param string $offset Array offset
     * @return mixed Element or NULL
     */
    public function offsetGet($offset) {
         return $this->_elements[$offset];
    }

    /**
     * Set a value for an offset
     *
     * @param string $offset Element offset
     * @param mixed $value Value of the element in the array
     */
    public function offsetSet($offset, $value) {
         $this->_elements[$offset] = $value;
    }

    /**
     * Unset a value for an offset
     *
     * @param string $offset Element offset
     */
    public function offsetUnset($offset) {
         unset($this->_elements[$offset]);
    }

    /**
     * Number of elements in the array
     *
     * @return integer Number of elements in array
     */
    public function count() {
         return count($this->_elements);
    }
}

// Class instance
$obj = new Iterabil(array(1, 2, 3, 4, 5));

echo 'Iteration using "for":'.PHP_EOL;

// iterate the object like a simple array
for($i = 0; $i < count($obj); $i++) {
     echo $obj[$i].PHP_EOL;
}

echo 'Element to delete: '.$obj[1].PHP_EOL;

unset($obj[1]);

echo 'Iteration using "foreach":'.PHP_EOL;

// iterate the object using foreach
foreach ($obj as $element) {
     echo $element.PHP_EOL;
}

// Output:
//Iteration using "for":
//1
//2
//3
//4
//5
//Element to delete: 2
//Iteration using "foreach":
//1
//3
//4
//5

Written by Claudiu Persoiu

8 October 2009 at 8:38 AM