DEV Community: Sebastian Rapetti

Refactor of a function

Sebastian Rapetti — Sat, 09 Dec 2017 11:43:28 +0000

Before starting, the reader considers this my personal opinion, how I see the things and not the only way resolve the problem.

I am working on a validator library and one of the various implemented filters do HTML escaping (replacing special characters with the correct HTML entities). For escape special char I need to know name or number of the html entity. Not all entities have a name then use the number is oblugatory.

For get the number of char, PHP offer a function called ord(). Unfortunately ord() does not work with UTF-8 multibyte characters and if multi-byte functions are not availables need to find another solution.

To be honest I don't like use multi-byte function on a filter because I cannot presume that all strings or character passed to the filter are multi-byte. In this case, defensive programming help us and we consider that all passed can be dangerous.

In comments of ord() function documentations I found a little snippet of code that seem the solution for my problem. It return the char number for all multi-byte chars.

Original code

This is the original version of the function (it's five years old code), prensent in PHP docs comments:

<?php

function ordutf8($string, &$offset)
{
    $code = ord(substr($string, $offset, 1));

    if ($code >= 128) {//otherwise 0xxxxxxx

        if ($code < 224)
            $bytesnumber = 2;//110xxxxx
        else if ($code < 240)
            $bytesnumber = 3;//1110xxxx
        else if ($code < 248)
            $bytesnumber = 4;//11110xxx

        $codetemp = $code - 192 - ($bytesnumber > 2 ? 32 : 0) - ($bytesnumber > 3 ? 16 : 0);

        for ($i = 2; $i <= $bytesnumber; $i++) {
            $offset ++;
            $code2 = ord(substr($string, $offset, 1)) - 128;//10xxxxxx
            $codetemp = $codetemp * 64 + $code2;
        }

        $code = $codetemp;
    }

    $offset += 1;

    if ($offset >= strlen($string))
        $offset = -1;

    return $code;
}

Code is thinked to manage a phrase, not only one character at time. Inside this function, there are two IF, five IF-ELSE and one FOR statements. Too complicated.

Step 1

We are in 2018 and PHP7 (7.2 current major version) provide a lot of new features, the one I love most is type checking!
Next, I need to manage one char at time, offset argument is no longer required.

<?php

function ordutf8(string $char) : int
{
    $code = ord(substr($char, 0, 1));

    if ($code >= 128) {

        if ($code < 224)
            $bytesnumber = 2;
        else if ($code < 240)
            $bytesnumber = 3;
        else if ($code < 248)
            $bytesnumber = 4;

        $codetemp = $code - 192 - ($bytesnumber > 2 ? 32 : 0) - ($bytesnumber > 3 ? 16 : 0);

        $offset = 0;

        for ($i = 2; $i <= $bytesnumber; $i++) {
            $offset ++;
            $code2 = ord(substr($char, $offset, 1)) - 128;
            $codetemp = $codetemp * 64 + $code2;
        }

        $code = $codetemp;
    }

    return $code;
}

One of two IF statement was removed.

Step 2

This code piece contains two IF-ELSE written using ternary operators:

<?php

$codetemp = $code - 192 - ($bytesnumber > 2 ? 32 : 0) - ($bytesnumber > 3 ? 16 : 0);

We replace it with static values, provide directly the correct number without check it every time.

<?php

function ordutf8(string $char) : int
{
    $code = ord(substr($char, 0, 1));

    if ($code >= 128) {
        $count = 0;

        if ($code < 224) {
            $bytesnumber = 2;
        } else if ($code < 240) {
            $bytesnumber = 3;
            $count = 32;
        } else if ($code < 248) {
            $bytesnumber = 4;
            $count = 48;
        }

        $codetemp = $code - 192 - $count;

        $offset = 0;

        for ($i = 2; $i <= $bytesnumber; $i++) {
            $offset ++;
            $code2 = ord(substr($char, $offset, 1)) - 128;
            $codetemp = $codetemp * 64 + $code2;
        }

        $code = $codetemp;
    }

    return $code;
}

Two of five IF-ELSE statements was removed.

Step 3

We can refactor FOR statements for remove variables and reduce lines of code.

<?php

function ordutf8(string $char) : int
{
    $code = ord(substr($char, 0, 1));

    if ($code >= 128) {
        $count = 0;

        if ($code < 224) {
            $bytes = 2;
        } else if ($code < 240) {
            $bytes = 3;
            $count = 32;
        } else if ($code < 248) {
            $bytes = 4;
            $count = 48;
        }

        $temp = $code - 192 - $count;

        for ($i = 1; $i < $bytes; $i++) {
            $code = $temp = $temp * 64 + ord(substr($char, $i, 1)) - 128;
        }
    }

    return $code;
}

In details from this:

<?php

$codetemp = $code - 192 - $count;

$offset = 0;

for ($i = 2; $i <= $bytesnumber; $i++) {
    $offset ++;
    $code2 = ord(substr($char, $offset, 1)) - 128;
    $codetemp = $codetemp * 64 + $code2;
}

$code = $codetemp;

To this:

<?php

$temp = $code - 192 - $count;

for ($i = 1; $i < $bytes; $i++) {
    $code = $temp = $temp * 64 + ord(substr($char, $i, 1)) - 128;
}

Step 4

Now we need to try to remove a little bit of IF-ELSE statements. This step seem more complicated than previous, but let us reflect on the conditions used in the IF statements.

we now have four conditions:

>=128 2 bytes
<224 2 bytes
<240 3 bytes
<248 4 bytes

we can rewrite them using only three:

>127 2 bytes
>223 3 bytes
>239 4 bytes

without using IF-ELSE statements and overwriting the variables when to the next condition is true.

<?php

function ordutf8(string $char) : int
{
    $code = ord(substr($char, 0, 1));

    if ($code > 127) {

        $bytes = 2; 
        $count = 0;

        if ($code > 223){
            $bytes = 3; 
            $count = 32;
        }

        if ($code > 239){
            $bytes = 4; 
            $count = 48;
        }

        $temp = $code - 192 - $count;

        for ($i = 1; $i < $bytes; $i++) {
            $code = $temp = $temp * 64 + ord(substr($char, $i, 1)) - 128;
        }
    }

    return $code;
}

Five of five IF-ELSE statements was removed. Remain 3 IF and one FOR statements.

Step 5

We now try to remove FOR statement and rewrite all as mathematics formula.

<?php

function ordutf8(string $char) : int
{
    $code = ord(substr($char, 0, 1));

    if ($code > 239){
        return ((/*($code - 240) * 64 + */ord(substr($char, 1, 1)) - 128) * 
                64 + ord(substr($char, 2, 1)) - 128) * 
                64 + ord(substr($char, 3, 1)) - 128;
    }

    if ($code > 223){
        return (($code - 224) * 64 + ord(substr($char, 1, 1)) - 128)
                * 64 + ord(substr($char, 2, 1)) - 128;
    }

    if ($code > 127) {
        return ($code - 192) * 64 + ord(substr($char, 1, 1)) - 128;
    }

    return $code;
}

Now only three IF statement remain.
UPDATE: Commented code in first IF statement return always zero. Useless code.

Conclusion

I hope this article can help you understand that you do not have to stop at the moment the code works. The code can always be improved, simplified and made more efficient.

Code improvement can be appreciated running little test on https://3v4l.org/TWFLX.

Code is also available on my Gist

MVC pattern from scratch

Sebastian Rapetti — Mon, 06 Nov 2017 17:35:30 +0000

Before starting, the reader considers this my personal opinion, how I see the things and not the only way for implement or for use the MVC Pattern.

On internet, it's possible find a lot of implementations and MVC frameworks ready to use, I decided to start from scratch because this is the best method for know deeply a thing.

After hours of theorical and pratical study, for understand what a Model, a View, a Controller and what they do, questions multiply.

Often, I saw that the Pattern components' workload is unbalanced, Controller do the most of the job: receive and filter user input data, manipulate the Model, call the View etc.

Why if the Pattern has three components, the Controller should do the most of the job? Controller means that this component control others or the Pattern lifecycle? It not was better call it Controller Pattern?

After others studies, a theoretical MVC Pattern where components have responsibility equally divided, begins to take shape in my mind.

I have the components:

Model -> Business Logic;
View -> Show Informations;
Controller -> Take User Input;

How to create a relation between thems without overload the Controller?

Considering that the Model should receive input data from Controller, process it, do all action needed; The View should be informed by the Model if data was updated for generate new well formatted output; The Controller should filter input data and activate the Model;

A possible solution could be...

Model and View can speak through the Observer Pattern;
Controller can pass data to the Model, invoking directly the proper Model' method;
Controller and Model could also linked through the Observer Pattern, but this way is a bit more complicated because Model should be Subject and Observer at the same time.

And the View compared to Controller?

Interaction between View and Controller could be unnecessary!

It's time, with previous "axioms" in mind, to write a lot of PHP code. :)

The Code

Is organized in three parents classes: Model, View, Controller that define the role and the relation of every component. After three classes for the concrete example: CalulatorModel, CalculatorView, CalculatorController. They inherit from parents classes. Finally the MVC pattern running.

Parents classes

Could be also abstract classes but not today.

Model

Contains methods for the Subject role (remind Observer Pattern), notify state change to the Observer.

<?php

/**
 * Parent class for custom model classes.
 *
 * This class was implemented like part of Observer pattern
 * https://en.wikipedia.org/wiki/Observer_pattern
 * http://php.net/manual/en/class.splsubject.php
 */
class Model implements SplSubject {

    /**
     * @var object List of attached observerer
     */
    private $observers;

    /**
     * @var array Data for notify to observerer
     */
    private $updates = [];

    /**
     * Class Constructor.
     */
    public function __construct() {
        $this->observers = new SplObjectStorage();
    }

    /**
     * Attach an Observer class to this Subject for updates
     * when occour a subject state change.
     *
     * @param SplObserver $observer
     */
    public function attach(SplObserver $observer) {
        if ($observer instanceof View) {
            $this->observers->attach($observer);
        }
    }

    /**
     * Detach an Observer class from this Subject.
     *
     * @param SplObserver $observer
     */
    public function detach(SplObserver $observer) {
        if ($observer instanceof View) {
            $this->observers->detach($observer);
        }
    }

    /**
     * Notify a state change of Subject to all registered Observeres.
     */
    public function notify() {
        foreach ($this->observers as $value) {
            $value->update($this);
        }
    }

    /**
     * Set the data to notify to all registered Observeres.
     *
     * @param array $data
     */
    public function set(array $data) {
        $this->updates = array_merge_recursive($this->updates, $data);
    }

    /**
     * Get the data to notify to all registered Observeres.
     *
     * @return array
     */
    public function get(): array {
        return $this->updates;
    }

}

View

Contains methods for the Observer role (remind Observer Pattern), retrive changes from the Subject.

<?php

/**
 * Parent class for custom view classes.
 *
 * This class was implemented like part of Observer pattern
 * https://en.wikipedia.org/wiki/Observer_pattern
 * http://php.net/manual/en/class.splobserver.php
 */
class View implements SplObserver {

    /**
     * @var array Data for the dynamic view
     */
    protected $data = [];

    /**
     * @var string Output data
     */
    protected $output = '';

    /**
     * @var Model Model for access data
     */
    protected $model;

    /**
     * Class Constructor.
     *
     * @param Model $model
     */
    public function __construct(Model $model) {
        $this->model = $model;
    }

    /**
     * Render a template.
     */
    public function render(): string {
        return $this->output;
    }

    /**
     * Update Observer data.
     *
     * @param SplSubject $subject
     */
    public function update(SplSubject $subject) {
        if ($subject instanceof Model) {
            $this->data = array_merge($this->data, $subject->get());
        }
    }

}

Controller

On Controller there isn't a lot of say.

<?php

/**
 * Parent class for custom controller classes.
 */
class Controller {

    /**
     * @var object The model object for current controller
     */
    protected $model = null;

    /**
     * Class Constructor.
     *
     * @param object $model
     */
    public function __construct(Model $model) {
        $this->model = $model;
    }

}

Concrete example classes, a basic calculator

I chose as example a basic calculator, it provide the possibility to add, subtract, multiply and divide, one or more number. I have prefered write a method for every math operation because is simpler follow the code.

Comparing this concrete example with the reasoning at the start of the article, I can say:

Model: Perform mathematical operation and notify result to the View;
View: Show operation and result as well formatted output;
Controller: Filter user provided numbers and invoke the Model;

Calculator Model

<?php

/**
 * Our Custom Model
 */
class CalculatorModel extends Model {

    /**
     * Class Constructor.
     */
    public function __construct() {
        parent::__construct();
    }

    /**
     * Mutiply business logic.
     * 
     * @param array $numbers
     */
    public function multiply(array $numbers) {
        $this->set([
            'result' => $this->operation('*', $numbers),
            'operands' => $numbers,
        ]);
    }

    /**
     * Divide business logic.
     * 
     * @param array $numbers
     */
    public function divide(array $numbers) {
        $this->set([
            'result' => $this->operation('/', $numbers),
            'operands' => $numbers
        ]);
    }

    /**
     * Subtraction business logic.
     * 
     * @param array $numbers
     */
    public function sub(array $numbers) {
        $this->set([
            'result' => $this->operation('-', $numbers),
            'operands' => $numbers
        ]);
    }

    /**
     * Addition business logic.
     * 
     * @param array $numbers
     */
    public function add(array $numbers) {
        $this->set([
            'result' => $this->operation('+', $numbers),
            'operands' => $numbers
        ]);
    }

    /**
     * Do math operation.
     * This is an example, division by 0 and other problematic things not checked.
     * Danger - Very Horrible Code - need refactor.
     *
     * @param string $operator
     * @param array $numbers
     * @return int|float
     */
    private function operation(string $operator, array $numbers) {
        $temp = null;
        foreach ($numbers as $n) {
            if ($temp === null) {
                $temp = $n;
                continue;
            }

            //example, division by 0 and other not checked
            switch ($operator) {
                case '*':
                    $temp = $temp * $n;
                    break;
                case '/':
                    $temp = $temp / $n;
                    break;
                case '-':
                    $temp = $temp - $n;
                    break;
                case '+':
                    $temp = $temp + $n;
                    break;
            }
        }

        return $temp;
    }

}

Calculator View

<?php

/**
 * Our Custom Model
 */
class CalculatorView extends View {

    /**
     * Class Constructor.
     * 
     * @param CalculatorModel $model
     */
    public function __construct(CalculatorModel $model) {
        parent::__construct($model);
    }

    /**
     * Build output for multiply.
     */
    public function multiply() {

        $this->output = $this->generateOutput(
                'Multiplication', 
                $this->data['operands'], 
                $this->data['result']
        );
    }

    /**
     * Build output for divide.
     */
    public function divide() {
        $this->output = $this->generateOutput(
                'Division', 
                $this->data['operands'], 
                $this->data['result']
        );
    }

    /**
     * Build output for add.
     */
    public function add() {
        $this->output = $this->generateOutput(
                'Addiction', 
                $this->data['operands'], 
                $this->data['result']
        );
    }

    /**
     * Build output for sub.
     */
    public function sub() {
        $this->output = $this->generateOutput(
                'Subtraction', 
                $this->data['operands'], 
                $this->data['result']
        );
    }

    /**
     * Generate the output.
     * Danger - Very Horrible Code - need refactor.
     *
     * @param string $operation
     * @param array $operand
     * @param type $result
     * 
     * @return string
     */
    private function generateOutput(string $operation, array $operands, $result): string {
        $string = $operation . ': ';

        foreach ($operands as $value) {
            $string .= $value . ' * ';
        }

        $string = substr($string, 0, strlen($string) - 2);
        $string .= '= ' . $result;

        return $string;
    }

}

Calculator Controller

<?php

/**
 * Our Custom Controller
 */
class CalculatorController extends Controller {

    /**
     * Class Constructor.
     * 
     * @param CalculatorModel $model
     */
    public function __construct(CalculatorModel $model) {
        parent::__construct($model);
    }

    /**
     * Multiply input point.
     * 
     * @param mixed $numbers
     */
    public function multiply(... $numbers) {

        //check user input
        $this->checkOperands($numbers);
        $this->filter($numbers);

        //manipulate the model
        $this->model->multiply($numbers);
    }

    /**
     * Divide input point.
     * 
     * @param mixed $numbers
     */
    public function divide(... $numbers) {

        //check user input
        $this->checkOperands($numbers);
        $this->filter($numbers);

        //manipulate the model
        $this->model->divide($numbers);
    }

    /**
     * Sub input point.
     * 
     * @param mixed $numbers
     */
    public function sub(... $numbers) {

        //check user input
        $this->checkOperands($numbers);
        $this->filter($numbers);

        //manipulate the model
        $this->model->sub($numbers);
    }

    /**
     * Add input point.
     *
     * @param mixed $numbers
     */
    public function add(... $numbers) {

        //check user input
        $this->checkOperands($numbers);
        $this->filter($numbers);

        //manipulate the model
        $this->model->add($numbers);
    }

    /**
     * Filter user supplied numbers.
     * 
     * @param mixed $numbers
     * @throws InvalidArgumentException
     */
    private function filter(&$numbers) {
        foreach ($numbers as $key => $number) {
            switch (gettype($number)) {
                case 'string':
                    $number[$key] = strtonum($number);
                    break;
                case 'integer':
                    break;
                case 'double':
                    break;
                default:
                    throw new InvalidArgumentException('Not a number');
            }
        }
    }

    /**
     * Convert a number given as string in the proper type (int or float).
     * https://secure.php.net/manual/en/language.types.type-juggling.php
     *
     * @param string $string Number as string ex '1.0', '0.9' etc
     * @return int|float
     */
    private function strtonum(string $string) {
        if (fmod((float) $string, 1.0) === 0.0) {
            return (int) $string;
        }

        return (float) $string;
    }

    /**
     * Check minimum numbers required for operations.
     *
     * @param array $numbers
     * @throws ArgumentCountError
     */
    private function checkOperands(array &$numbers) {
        if (count($numbers) < 2) {
            throw new ArgumentCountError('At least two numbers needed for operation');
        }
    }

}

Running

I wish multiply two numbers (2 and 3) with the basic calculator.

<?php

//create components
$model = new CalculatorModel();
$view = new CalculatorView($model);
$controller = new CalculatorController($model);

//attach the observer to the subject
$model->attach($view);

//call controller
$controller->multiply(2, 3);

//notify changes to observer
$model->notify();

//call view
$view->multiply();

//get the output
echo $view->render();

This code show as output:

Multiplication: 2 * 3 = 6

Finally

It was not easy, the Pattern seem very complicate and there isn't only one way for implement it, but after a bit of practice everything becomes simple, it is very flexible, is a great aids for the organization of code. It's Worth!

A final consideration about the runnig, at first look, code should not work because the View, after notify, is called outside the Model.

How the View (outside the Model) receive notifies if the scope of the object is different?

Model notify in local scope inside the instance, View calls method ($view->multiply()) in global scope. I think the solution could be found in "how php pass the objects to a function", according to the official documentation objects are passed by references by default but I'm not still sure it works for this.

If you wish try the code 3v4l.org can help you, code is on my Gist Account and require PHP7 for run.

Refactor, a solution with class abstraction

Sebastian Rapetti — Wed, 23 Aug 2017 23:24:47 +0000

Working on my little PHP framework I encountered a situation when the code suffered of duplication. Situation apparently, cannot be resolved because code concern two different part of the framework.

The Mess

I have two classes, one for get a connection to persistent storage and the other for get a connection to cache. Classes return different objects, but do action at the same way.

Code is not optimized but that's another story. I wish focus on duplication and refactor.

Storage Factory:

<?php

/**
 * Storage Factory.
 */
class StorageFactory
{
    private $driver;

    private $supportedDriver = [
        'pdo'     => PdoStorage::class,
        'mysqli'  => MysqliStorage::class,
        'mongodb' => MongoDbStorage::class,
    ];

    private $options;

    public function __construct(string $driver, array $options)
    {
        $this->driver = $driver;
        $this->options = $options;
    }

    public function getConnection() : StorageInterface
    {
        $driver = $this->driver;
        $options = $this->options;

        if (isset($this->supportedDriver[$driver])) {
            $storageClass = $this->supportedDriver[$driver];

            return new $storageClass($options);
        }

        throw new InvalidArgumentException("[$driver] not supported.");
    }
}

And Cache Factory:

<?php

/**
 * Cache Factory.
 */
class CacheFactory
{
    private $driver;

    private $supportedDriver = [
        'disk'       => DiskCache::class,
        'memcached'  => MemcachedCache::class,
    ];

    private $options;

    public function __construct(string $driver, array $options)
    {
        $this->driver = $driver;
        $this->options = $options;
    }

    public function get() : CacheInterface
    {
        $driver = $this->driver;
        $options = $this->options;

        if (isset($this->supportedDriver[$driver])) {
            $cache = $this->supportedDriver[$driver];

            return new $cache($options);
        }

        throw new InvalidArgumentException("[$driver] not supported.");
    }
}

Previous code is an obvious example of duplication :(

Questions begin

How resolve this problem?

Cache is a type of storage, a very fast storage. I can merge all inside one factory class but *Storage classes and *Cache classes in my framework implement different interfaces.

Furthermore, I wish use PHP return types declaration I cannot have a method that returns two different types of objects.

I analize code...

Where are the differences in the classes?

I have to isolate the differences in the code:

<?php

// Storage class
private $supportedDriver = [
    'pdo'     => PdoStorage::class,
    'mysqli'  => MysqliStorage::class,
    'mongodb' => MongoDbStorage::class,
];

// Cache class
private $supportedDriver = [
    'disk'       => DiskCache::class,
    'memcached'  => MemcachedCache::class,
];

// Storage class
public function getConnection() : StorageInterface
{
    //code
}

// Cache class
public function get() : CacheInterface
{
    //code
}

And now?

Now I know the differences, must to split them in two concrete implementation and move duplicate code into an abstract class.

Abstract class:

<?php

/**
 * Abstract Storage Factory.
 */
abstract class AbstractStorageFactory
{
    protected $driver;

    protected $supportedDriver = [];

    protected $options;

    public function __construct(string $driver, array $options)
    {
        $this->driver = $driver;
        $this->options = $options;
    }

    protected function returnStorageObject()
    {
        $driver = $this->driver;
        $options = $this->options;

        if (isset($this->supportedDriver[$driver])) {
            $class = $this->supportedDriver[$driver];

            return new $class($options);
        }

        throw new InvalidArgumentException("[$driver] not supported.");
    }

    /**
     * Get storage object.
     *
     * @return object
     */
    abstract public function get();
}

Concrete factories:

<?php

/**
 * Storage Factory.
 */
class StorageFactory extends AbstractStorageFactory
{
    protected $supportedDriver = [
        'pdo'     => PdoStorage::class,
        'mysqli'  => MysqliStorage::class,
        'mongodb' => MongoDbStorage::class,
    ];

    public function get() : StorageInterface
    {
        return $this->returnStorageObject();
    }
}


/**
 * Cache Factory.
 */
class CacheFactory extends AbstractStorageFactory
{
    protected $supportedDriver = [
        'disk'       => DiskCache::class,
        'memcached'  => MemcachedCache::class,
    ];

    public function get() : CacheInterface
    {
        return $this->returnStorageObject();
    }
}

Finally

Code duplication is disappeared and I used the PHP return types.

I wrote this little article not for the code, but for share the reasoning did for reach final result.

Hello I am Sebastian

Sebastian Rapetti — Wed, 09 Aug 2017 20:35:28 +0000

Sorry, this is my second article, must be the first but I published another before this.

I live in Olbia, Sardinia.

You can find me on Twitter as @sebastianr1982 or via e-mail at sebastian.rapetti@alice.it and I am currently working on github at https://github.com/linna

I am coding since 2002. I mostly speak PHP, but if needed C, C++ and every C like language, I will wish learn Python and Go.

I'm learning everything I can :), programming for me is an hobby, however calling it hobby is reductive, I see programming like an art, the code like a sculpture. A raw piece of stone after hard work becomes art, a raw piece of code, a function or a class after optimizing become art.

I am developing not for job, only for passion.

Nice to meet all.

PHP code, about readability and performance

Sebastian Rapetti — Thu, 27 Jul 2017 14:41:36 +0000

Lot of my coding time is spent to improve performance and find bugs, PHP give much freedom for coding and this often evolve in bad habits, therefore need pay attention for write fast and efficient code.

Write fast code for me means that some times I must do a choice between readability, short code, simplicity and performance.

As example I can report my experience with the recursion. Recursion, informally when a function calls itself, can be used for solve problems and create algorithms with a few lines of code.

This is good, but with PHP could be a bad thing because call a user-defined function is expensive in term of time.

The problem

Write a dependency injection resolver. I need a method that create a map of the dependencies and store it inside an array.

First I used the recursive approach as fastest to implement. When I did profiling, i saw that most of the execution time was used to resolve the class dependencies. The recursion is too expensive and need to rewrite the code.

Solution

After a fast search on internet, I decided to use iterative approach that compared to recursive need more code but is faster.

As recursive:

<?php

/**
 * Create a dependencies map for a class.
 *
 * @param int $level Depth of dependency
 * @param string $class Class to build dependencies
 */
private function buildTree(int $level, string $class)
{
    //initialize array
    $this->tree[$level][$class] = [];

    //get parameter from constructor
    $param = (new \ReflectionClass($class))->getConstructor()->getParameters();

    //loop parameter
    foreach ($param as $key => $value) {

        //if there is parameter with callable type
        if ($value->hasType() === true && class_exists((string) $value->getType())) {

            //store dependency
            $this->tree[$level][$class][] = $value->getClass()->name;

            //call recursive
            $this->buildTree($level + 1, $value->getClass()->name);
        }
    }
}

And as iterative:

<?php

/**
 * Create a dependencies map for a class.
 *
 * @param string $class Class to build dependencies
 */
private function buildTree(string $class)
{
    //set start level
    $level = 0;

    //create stack
    $stack = new \SplStack();

    //iterate
    while (true) {

        //initialize array if not already initialized
        if (!isset($this->tree[$level][$class])) {
            $this->tree[$level][$class] = [];
        }

        //get parameter from constructor
        $parameters = (new \ReflectionClass($class))->getConstructor()->getParameters();

        //loop parameter
        foreach ($parameters as $param) {

            //check if argument is already stored
            $notAlreadyStored = !in_array($param, $this->tree[$level][$class]);

            //if there is parameter with callable type
            if (class_exists((string) $param->getType()) && $notAlreadyStored) {

                //push values in stack for simulate later recursive function
                $stack->push([$level, $class]);

                //store dependency
                $this->tree[$level][$class][] = $param;

                //update values for simulate recursive function
                $level++;
                $class = (is_object($param->getClass())) ?
                    $param->getClass()->name : null;

                //return to main while
                continue 2;
            }

            if ($notAlreadyStored) {
                //store dependency
                $this->tree[$level][$class][] = $param;
            }
        }

        //if stack is empty break while end exit from function
        if ($stack->count() === 0) {
            break;
        }

        //get last value pushed into stack;
        list($level, $class) = $stack->pop();
    }
}

As you can see, at first look, iterative code is longer and more complicated than recursive. In details, main differences are only a while loop and a LIFO data structure for simulate the call stack.

Benchmark

Returning to profiling of the code and to performance, differences in execution time between previous pieces of code are very significative. The speed gap, grows with the number of function calls.

I do a little benchmark using php microtime() and this is the result:

Calls	Execution Time Iteractive	Execution Time Recursive	Fastest
1	100%	30% - 50%	Recursive
10	100%	180% - 210%	Iteractive
100	100%	300% - 450%	Iteractive
1000	100%	700% - 1100%	Iteractive
10000	100%	600% - 700%	Iteractive

In benchmark I have simulated a class that depend by other classes. Example Class A depend from B, B from C, C from D, D from E etc. Total nine nested classes.

Benchmark was executed with Virtual Box, Ubuntu Server 16.04.2, Apache/2.4.18, php 7.1.7 with mod-fpm. Virtual machine: Intel(R) Core(TM)2 Extreme CPU X9100, 2 Cpu max 40% and 512Mb of Ram, SSD. Benchmark ran 10 times and recursion values are averaged.

Conclusion

In conclusion, when need to do a choice between "how the code is written" and performance, for me it's best have more execution speed and less code simplicity /readability. Can help in this case, leave more detailled comments (what and because, not only because) for not forget what the code do.

Of course, the previous consideration does not mean that you do not have to follow the good code practices.

Your preferred Ide/Text editor?

Sebastian Rapetti — Mon, 17 Jul 2017 20:00:46 +0000

Today after some years of Netbeans utilize I decided to try Atom and it gave me a good feeling.

What ide/text editor do you use for code development?