My previous example in part 2 was just “hello world”, so I’m going to try for something more like the real world. You may find this example unusual, but it does work. I took the PageRange class I used in my July 2007 php|architect article and converted it to the JavaScript style. The class is a variation on Martin Fowler’s Range pattern, and is the hub of a re-implementation of the main functionality of PEAR Pager, using a more object-oriented style.

A Range object is defined by just two values (three in my variation), so it might seem like too much to have an object just to keep these values, but as you can see from the example, a Range class can have behaviors to change and compare ranges.

As before, I’m defining most of the methods inside the constructor.

<?php
class PageRange {
    public $start;
    public $end;
    public $length;

    private $moveToStartAt;
    private $moveToEndAt;
    private $changeLengthToEndAt;
    private $includes;
    private $isInside;
    private $extendsBeyondStartOf;
    private $extendsBeyondEndOf;
    private $truncateToFitInside;
    private $moveToFitInside;
    private $asArray;

    public function __construct($start,$end,$length) {
        $self = $this;
        $this->start = $start;
        $this->end = $end;
        $this->length = $length;

        $this->moveToStartAt = function($start) use ($self) {
            return PageRange::withStartAndLength(
                $start,$self->length);
        };

        $this->moveToEndAt = function($end) use ($self) {
            return PageRange::withEndAndLength($end,$self->length);
        };

        $this->changeLengthToEndAt = function($end) use ($self) {
            return PageRange::withStartAndEnd($self->start,$end);
        };

        // Comparisons

        $this->includes = function($page) use ($self) {
            return $page >= $self->start
                && $page <= $self->end;
        };

        $this->isInside = function($range) use ($self) {
            return $range->includes($self->getStart())
                && $range->includes($self->getEnd());
        };

        $this->extendsBeyondStartOf = function(PageRange $range) use ($self) {
            return ($self->getStart() < $range->getStart());
        };

        $this->extendsBeyondEndOf = function(PageRange $range) use ($self) {
            return ($self->getEnd() > $range->getEnd());
        };

        // Changes

        $this->truncateToFitInside = function(PageRange $larger) use ($self) {
            if ($self->isInside($larger)) return clone $self;
            return $self->changeLengthToEndAt(
                $larger->getEnd());
        };

        $this->moveToFitInside = function(PageRange $larger) use ($self) {
            if ($self->isInside($larger)) return clone $self;
            if ($self->extendsBeyondEndOf($larger))
                return $self->moveToEndAt($larger->getEnd());
            if ($self->extendsBeyondStartOf($larger))
                return $self->moveToStartAt(
                    $larger->getStart());
        };

        // Convert to array

        $this->asArray = function() use ($self) {
            return range($self->start,$self->end);
        };

    }

I’ve defined the static methods in the usual way, non-JavaScript style. And there is, of course, the mandatory __call() method.

class PageRange...

    public function __call($method,$args) {
        return call_user_func_array($this->$method,$args);
    }

    public function getStart() { return $this->start; }

    public function getEnd() { return $this->end; }

    public function getLength() { return $this->length; }

    private static function calculateEnd($start,$length) {
        return $start + $length - 1;
    }

    private static function calculateStart($end,$length) {
        return $end - $length + 1;
    }

    private static function calculateLength($start,$end) {
        return $end - $start + 1;
    }

    public static function withStartAndLength(
        $start,$length)
    {
        return new self(
            $start,
            self::calculateEnd($start,$length),
            $length
        );
    }

    public static function withEndAndLength($end,$length) {
        return new self(
            self::calculateStart($end,$length),
            $end,
            $length
        );
    }

    public static function withStartAndEnd($start,$end) {
        return new self(
            $start,
            $end,
            self::calculateLength($start,$end)
        );
    }

}

An interesting aspect of this class is the fact that the constructor is private, so you have to use one of the creation methods. That’s part of my variation on the range pattern.

After the previous post in this series, additional independent implementations of the idea of JavaScript-style classes have turned up. So I’m going to list them and comment briefly on the differences. I hope this will be helpful to anyone who actually wants to use this in practice and needs to decide on the details of the implementation. Here are the links in chronological order:

• Ionut G. Stan:Javascript style PHP with PHP 5.3.0 (forum posting).
• Fredrik Holmström: Javascript-OO & Python-DuckTyping in PHP5.3.
• John Mertic: What’s new in PHP V5.3, Part 2: Closures and lambda functions.
• My own previous article.
• Andrea Giammarchi: A JavaScript Object Like PHP Class.

One difference is how JavaScript-like the implementations are. Some of them implement a syntax that is deliberately made to resemble JavaScript. Andrea Giammarchi’s version even uses ArrayAccess to make it possible to access object properties using both object and array syntax, as in JavaScript. At the other extreme is my implementation. I’ve tried to make it as similar to a regular PHP class as possible. You can instantiate an object in the same way as with an ordinary PHP class. This comes from defining the methods inside the class constructor.

After seeing all of these, I prefer my own way of doing it, except that it lacks what I mentioned in the previous article: an exception when you try to call an unrecognized method. But I’m obviously not objective, and I may have have missed something.

After I did my own research, I discovered that someone had beat me to it. As early as September last year Fredrik Holmström wrote about Javascript-OO & Python-DuckTyping in PHP5.3.

I’ve done the same thing independently and somewhat differently, so it’s interesting to compare. Unlike Holmström, I’m defining the closures inside the constructor for the class that’s using them. That makes the code that uses the class a little more similar to what we’re used to.

Let’s start with a “Hello world” example.

class HelloWorldWithClosures {
    private $hello;
    private $goodbye;

    public function __construct() {
        // If we try using $this inside the closure, we get a syntax error.
        // So we need another variable name, which is basically arbitrary.
        $self = $this;

        // $self is not actually used inside this method/closure, but we want to be consistent.
        $this->hello = function() use ($self) {
            echo "hello world...\n";
        };

        $this->goodbye = function() use ($self) {
            $self->hello();
            echo "...and goodbye for now\n";
        };
    }

    public function __call($method,$args) {
        return call_user_func_array($this->$method,$args);
    }
}

The closures are instance variables in the class, and the __call() method is set up to call the correct closure when calling the method in the usual way in PHP.

Now we can call a plain method that uses nothing else from the class:

$obj = new HelloWorldWithClosures;
$obj->hello(); // prints "hello world..."

And we can call the goodbye() method that starts by calling hello():

$obj = new HelloWorldWithClosures;
$obj->goodbye();
// prints "hello world...
//...and goodbye for now"

We can also add new methods to object that’s already instantiated without changing the class:

$obj->helloAgain = function() use($obj) {
    $obj->goodbye();
    echo "...and hello again\n";
};

This last example exploits the somewhat vulgar fact that you can still add public instance variables on the fly to an object, as in PHP 4.

A different approach that avoids this, but is a bit more verbose, would be to use an array to store the closures in the object:

class HelloWorldWithClosures2 {
    public $methods = array();

    public function __construct() {
        $self = $this;

        $this->methods['hello'] = function() use ($self) {
            echo "hello world...\n";
        };

        $this->methods['goodbye'] = function() use ($self) {
            $self->hello();
            echo "...and goodbye for now\n";
        };
    }

    public function __call($method,$args) {
        return call_user_func_array($this->methods[$method],$args);
    }
}

In addition, we would normally need to throw an execption when a method does not exist. The blog post I linked to at the beginning has this feature.

Those are the basics of how to write JavaScript-classes in PHP 5.3. Whether you actually want do it this way depends on your needs. There’s no point unless you actually want to use the flexibility this style of programmer affords.