Handling array of object and intellisense

Question

I am finding a lot of the time I pass an array of custom objects to a function for processing. In my function I check to make sure it is the right class before accessing internal properties/methods.

Because I am taking an array and as far as I am aware PHP doesn't have any typed generic list I cannot use type hinting so intellisense in my IDE doesn't work and code inspection throws warnings.

I came across an old post that gave the idea of throwing in this line of code in order to get intellisense working while developing:

if (false) $myObj = new MyObject();

So I end up with a function that looks like:

function ProcessObjectArray(array $arrayOfObject)
{
    foreach ($arrayOfObject as $key => $myObj) {
        if (get_class($myObj) == 'MyNamespace\MyObject') {
            if (false) $myObj = new MyObject();
            // I can now access intellisense for MyObject in here

        } else {
            trigger_error('is not right object');
        }
    }
}

It seems like a bit of a weird hack so I am wondering if this is a sign that I am not handling arrays of objects in the best way or if there is a better way to get my intellisense working. I had a look at the arrayobject interface to see if I could create a class implementing arrayobject that would hold a typed list. While it makes it nice to put all validation inside its constructor or append like functions I couldn't get it working with intellisense as the internal container is still just a standard array. Also using get_class doesn't seem good as if a class name or namespace is renamed then the IDE refactoring features do not pick this reference up (well, PHPStorm doesn't at least and it is one I am using).

I of course don't need intellisense but the weirdness of this hack made me wonder if I have the right approach to OOP in PHP and thought I might be missing something. Is this the right way of doing it or have I missed something?

Jonathan · Accepted Answer · 2015-04-21 19:35:20Z

4

with phpstorm when you add your annotations it will correctly do the code completion for you.

/**
 * @param MyNamespace\MyObject[] $arrayOfObject
 */
function ProcessObjectArray(array $arrayOfObject)
{
    foreach ($arrayOfObject as $key => $myObj) {
        if (get_class($myObj) == 'MyNamespace\MyObject') {
            if (false) $myObj = new MyObject();
            // I can now access intellisense for MyObject in here

        } else {
            trigger_error('is not right object');
        }
    }
}

However intellisense won't stop you from passing in incorrect objects, it will only help you while coding to prevent passing in the incorrect objects.

Perhaps you may wish to consider using collections instead of using generic arrays.

There are lots of examples out there, however here is a simple one which you can expand upon

class Collection 
{
    /** @var array */
    private $items = [];

    /**
     * @param MyNamespace\MyObject $obj
     * @return $this
     */
    public function addItem(MyNamespace\MyObject $obj) {
        $this->items[] = $obj;
        return $this;
    }

    /**
     * @param $index
     * @return $this
     */
    public function deleteItem($index) {
        unset($this->items[$index]);
        return $this;
    }

    /**
     * @param $index
     * @return MyNamespace\MyObject|null
     */
    public function getItem($index) {
        return array_key_exists($index, $this->items) ? $this->items[$index] : null;
    }

    /**
     * @return MyNamespace\MyObject[]
     */
    public function getItems() {
        return $this->items;
    }

    /**
     * @return int
     */
    public function count() {
        return sizeOf($this->items);
    }
}

here is an example how it all works:

$collection = new \Collection;

$obj = new MyNamespace\MyObject;

$collection->addItem($obj);

foreach($collection->getItems() as $item) {
    // this will already know that $item is MyNamespace\MyObject because of the annotation on the getItems() method
    $item->doSomething();
}

edited Apr 21, 2015 at 19:35

answered Apr 21, 2015 at 18:24

Jonathan

2,87515 silver badges23 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Guerrilla Over a year ago

How do I annotate this collection so autocompletion works when I am iterating over its members in another function?

Jonathan Over a year ago

the annotation on getItems() should cover that case just fine.

Guerrilla Over a year ago

I combined this with other answer and got perfect outcome. Thanks for the help!

Guerrilla Over a year ago

Hmm, so with your example you initialise an array with getitems() and then iterate over that array or use a for loop and getItem() instead of foreach?

Aleksander Wons · Accepted Answer · 2015-04-22 05:44:47Z

2

class MyCollection implements \Iterator
{
    /**
     * @var CollectionElement[]
     */
    private $elements = [];


    public function addElement(CollectionElement $element)
    {
        $this->elements[] = $element;
    }

    /**
     * @return CollectionElement
     */
    public function current()
    {
        return current($this->elements);
    }

    //... Rest of the Iterator implementation
}

This way you cannot add to the collection anything other than CollectionElement. And after:

foreach($collection as $element){
    /** @var CollectionElement $element */
    $element->//here you will have autocompletion
}

You don't need to check anything since your collection will never contain anything you are not expecting.

edited Apr 22, 2015 at 5:44

answered Apr 21, 2015 at 18:26

Aleksander Wons

3,98721 silver badges30 bronze badges

2 Comments

Guerrilla Over a year ago

I just tried this and auto completion isn't working. Any idea what I missed?

Guerrilla Over a year ago

I got it, hadn't specified return type on current(). Thanks, I feel much better using a pattern like this

user229044 · Accepted Answer · 2015-04-22 01:16:20Z

-5

If you are going this route, I would avoid using the are native arrays. I would make classes that contain arrays of a certain type. That way, you can validate the array contents in the constructor of the class, and then you can use actual type hinting for the objects, which PHP allows.

edited Apr 22, 2015 at 1:16

user229044♦

241k41 gold badges346 silver badges350 bronze badges

answered Apr 21, 2015 at 18:24

Aaron Kent

6281 gold badge5 silver badges11 bronze badges

2 Comments

David Wyly Over a year ago

"In general, PHP is a terrible language for any serious type work." I cringed.

Aaron Kent Over a year ago

"I cringed". Just out of curiosity, why? I wouldn't think it was controversial that PHP is the most weakly/loosely typed prominent in wide use.

Collectives™ on Stack Overflow

Handling array of object and intellisense

3 Answers 3

4 Comments

2 Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

2 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related