Использование:

/* @var $objs Test[] */
foreach ($objs as $obj) {
    // Typehinting will occur after typing $obj->
}

при вводе встроенных переменных и

class A {
    /** @var Test[] */
    private $items;
}

для свойств класса.

Предыдущий ответ от '09, когда в PHPDoc (и в IDE, таких как Zend Studio и Netbeans) не было этой опции:

Лучшее, что ты можешь сделать, это сказать:

foreach ($Objs as $Obj)
{
    /* @var $Obj Test */
    // You should be able to get hinting after the preceding line if you type $Obj->
}

Я часто этим занимаюсь в Zend Studio. Не знаю, как насчет других редакторов, но должно работать.

В IDE PhpStorm от JetBrains вы можете использовать /** @var SomeObj[] */, например:

/**
 * @return SomeObj[]
 */
function getSomeObjects() {...}

В документации по phpdoc рекомендуется этот метод:

указано, что содержит единственный тип, определение типа информирует читателя о типе каждого элемента массива. Тогда ожидается, что в качестве элемента для данного массива будет только один тип.

Пример: @return int[]

Подсказки Netbeans:

Вы получаете завершение кода для $users[0]-> и для $this-> для массива классов User.

/**
 * @var User[]
 */
var $users = array();

Вы также можете увидеть тип массива в списке членов класса, когда завершите $this->...

Чтобы указать переменную, представляет собой массив объектов:

$needles = getAllNeedles();
/* @var $needles Needle[] */
$needles[1]->...                        //codehinting works

Это работает в Netbeans 7.2 (я его использую)

Также работает с:

$needles = getAllNeedles();
/* @var $needles Needle[] */
foreach ($needles as $needle) {
    $needle->...                        //codehinting works
}

Поэтому использование объявления внутри foreach не обязательно.

PSR-5: PHPDoc предлагает форма нотации в стиле Generics.

Синтаксис

Type[]
Type<Type>
Type<Type[, Type]...>
Type<Type[|Type]...>

Значения в Коллекции МОГУТ даже быть другим массивом и даже другой Коллекцией.

Type<Type<Type>>
Type<Type<Type[, Type]...>>
Type<Type<Type[|Type]...>>

Примеры

<?php

$x = [new Name()];
/* @var $x Name[] */

$y = new Collection([new Name()]);
/* @var $y Collection<Name> */

$a = new Collection(); 
$a[] = new Model_User(); 
$a->resetChanges(); 
$a[0]->name = "George"; 
$a->echoChanges();
/* @var $a Collection<Model_User> */

Примечание. Если вы ожидаете, что IDE будет выполнять поддержку кода, то другой вопрос, поддерживает ли IDE нотацию коллекций в стиле PHPDoc Generic.

Из моего ответа на этот вопрос.

Я предпочитаю читать и писать чистый код - как описано в «Чистом коде» Роберта К. Мартина. Следуя его кредо, вы не должны требовать, чтобы разработчик (как пользователь вашего API) знал (внутреннюю) структуру вашего массива.

Пользователь API может спросить: это массив только с одним измерением? Распространены ли объекты по всем уровням многомерного массива? Сколько вложенных циклов (foreach и т. Д.) Мне нужно для доступа ко всем объектам? Какие типы объектов «хранятся» в этом массиве?

Как вы обрисовали в общих чертах, вы хотите использовать этот массив (содержащий объекты) как одномерный массив.

Как указано Ниши, вы можете использовать:

/**
 * @return SomeObj[]
 */

для этого.

Но опять же: имейте в виду - это не стандартная нотация докблока. Это обозначение было введено некоторыми производителями IDE.

Хорошо, хорошо, как разработчик вы знаете, что «[]» привязан к массиву в PHP. Но что означает «что-то []» в обычном контексте PHP? «[]» означает: создать новый элемент внутри «чего-то». Новый элемент может быть чем угодно. Но вы хотите выразить следующее: массив объектов одного и того же типа и его точного типа. Как видите, производитель IDE вводит новый контекст. Новый контекст, который вам нужно было изучить. Новый контекст, который пришлось изучить другим PHP-разработчикам (чтобы понять ваши док-блоки). Плохой стиль (!).

Поскольку ваш массив действительно имеет одно измерение, вы, возможно, захотите назвать этот «массив объектов» «списком». Имейте в виду, что «список» имеет особое значение в других языках программирования. Было бы лучше называть это, например, "сбором".

Помните: вы используете язык программирования, который позволяет вам использовать все возможности ООП. Используйте класс вместо массива и сделайте свой класс проходимым, как массив. Например.:

class orderCollection implements ArrayIterator

Или, если вы хотите хранить внутренние объекты на разных уровнях в рамках многомерной структуры массива / объекта:

class orderCollection implements RecursiveArrayIterator

Это решение заменяет ваш массив объектом типа «orderCollection», но пока не включает автозавершение кода в вашей среде IDE. Хорошо. Следующий шаг:

Реализуйте методы, представленные интерфейсом, с помощью docblocks, в частности:

/**
 * [...]
 * @return Order
 */
orderCollection::current()

/**
 * [...]
 * @return integer E.g. database identifier of the order
 */
orderCollection::key()

/**
 * [...]
 * @return Order
 */
orderCollection::offsetGet()

Не забывайте использовать подсказку типов для:

orderCollection::append(Order $order)
orderCollection::offsetSet(Order $order)

Это решение перестает вводить много:

/** @var $key ... */
/** @var $value ... */

во всех ваших файлах кода (например, внутри циклов), как подтвердил Захимака своим ответом. Ваш пользователь API не обязан вводить эти докблоки для завершения кода. Наличие @return только в одном месте максимально снижает избыточность (@var). Если добавить в docBlocks @var, код будет хуже читаться.

Наконец-то все готово. Выглядит сложно? Похоже, чтобы сломать орех кувалдой? Не совсем так, поскольку вы знакомы с этими интерфейсами и с чистым кодом. Помните: ваш исходный код пишется один раз / читается много раз.

Если автозавершение кода вашей IDE не работает с этим подходом, переключитесь на более подходящий вариант (например, IntelliJ IDEA, PhpStorm, Netbeans) или отправьте запрос функции в средство отслеживания проблем вашего производителя IDE.

Спасибо Кристиану Вайсу (из Германии) за то, что он был моим тренером и научил меня такому замечательному материалу. PS: Встретимся с ним на XING.

Используйте array[type] в Zend Studio.

В Zend Studio отлично работают array[MyClass], array[int] или даже array[array[MyClass]].

В NetBeans 7.0 (может быть и ниже) вы можете объявить возвращаемый тип «массив с текстовыми объектами» так же, как @return Text, и подсказка кода будет работать:

Изменить: обновлен пример с предложением @Bob Fanger.

/**
 * get all Tests
 *
 * @return Test|Array $tests
 */
public function getAllTexts(){
    return array(new Test(), new Test());
}

и просто используйте это:

$tests =  $controller->getAllTests();
//$tests->         //codehinting works!
//$tests[0]->      //codehinting works!

foreach($tests as $text){
    //$test->      //codehinting works!
}

Он не идеален, но лучше оставить его просто «смешанным», что не приносит никакой пользы.

МИНУСЫ - вам разрешено использовать массив как текстовый объект, который будет вызывать ошибки.

Как отметила Даниэла Варани в своем ответе, есть способ указать тип $ item при итерации по $ items в $ collectionObject: добавить @return MyEntitiesClassName в current() и остальные методы Iterator и ArrayAccess, которые возвращают значения.

Бум! Нет необходимости в /** @var SomeObj[] $collectionObj */ поверх foreach и работает правильно с объектом коллекции, нет необходимости возвращать коллекцию с помощью специального метода, описанного как @return SomeObj[].

Я подозреваю, что не все IDE поддерживают его, но он отлично работает в PhpStorm, что меня радует.

Пример:

class MyCollection implements Countable, Iterator, ArrayAccess {

    /**
     * @return User
     */
    public function current() {
        return $this->items[$this->cursor];
    }

    //... implement rest of the required `interface` methods and your custom
}

Что полезного я собирался добавить, разместив этот ответ

В моем случае current() и остальные interface-методы реализованы в классе Abstract-collection, и я не знаю, какие объекты в конечном итоге будут храниться в коллекции.

Итак, вот трюк: не указывайте тип возвращаемого значения в абстрактном классе, вместо этого используйте инструкцию PhpDoc @method в описании конкретного класса коллекции.

Пример:

class User {

    function printLogin() {
        echo $this->login;
    }

}

abstract class MyCollection implements Countable, Iterator, ArrayAccess {

    protected $items = [];

    public function current() {
        return $this->items[$this->cursor];
    }

    //... implement rest of the required `interface` methods and your custom
    //... abstract methods which will be shared among child-classes
}

/**
 * @method User current()
 * ...rest of methods (for ArrayAccess) if needed
 */
class UserCollection extends MyCollection {

    function add(User $user) {
        $this->items[] = $user;
    }

    // User collection specific methods...

}

Теперь об использовании классов:

$collection = new UserCollection();
$collection->add(new User(1));
$collection->add(new User(2));
$collection->add(new User(3));

foreach ($collection as $user) {
    // IDE should `recognize` method `printLogin()` here!
    $user->printLogin();
}

Еще раз: я подозреваю, что не все IDE поддерживают его, но PhpStorm поддерживает. Попробуйте свой, оставьте в комментариях результаты!

Я знаю, что опаздываю на вечеринку, но недавно работал над этой проблемой. Я надеюсь, что кто-то это увидит, потому что принятый ответ, хотя и правильный, не является лучшим способом сделать это. По крайней мере, не в PHPStorm, но я не тестировал NetBeans.

Лучший способ - это расширение класса ArrayIterator, а не использование собственных типов массивов. Это позволяет вам вводить подсказку на уровне класса, а не на уровне экземпляра, что означает, что вам нужно использовать PHPDoc только один раз, а не во всем коде (что не только беспорядочно и нарушает DRY, но также может быть проблематичным, когда дело доходит до рефакторинг - PHPStorm имеет обыкновение пропускать PHPDoc при рефакторинге)

См. Код ниже:

class MyObj
{
    private $val;
    public function __construct($val) { $this->val = $val; }
    public function getter() { return $this->val; }
}

/**
 * @method MyObj current()
 */
class MyObjCollection extends ArrayIterator
{
    public function __construct(Array $array = [])
    {
        foreach($array as $object)
        {
            if(!is_a($object, MyObj::class))
            {
                throw new Exception('Invalid object passed to ' . __METHOD__ . ', expected type ' . MyObj::class);
            }
        }
        parent::__construct($array);
    }

    public function echoContents()
    {
        foreach($this as $key => $myObj)
        {
            echo $key . ': ' . $myObj->getter() . '<br>';
        }
    }
}

$myObjCollection = new MyObjCollection([
    new MyObj(1),
    new MyObj('foo'),
    new MyObj('blah'),
    new MyObj(23),
    new MyObj(array())
]);

$myObjCollection->echoContents();

Ключевым моментом здесь является PHPDoc @method MyObj current(), переопределяющий тип возвращаемого значения, унаследованный от ArrayIterator (это mixed). Включение этого PHPDoc означает, что когда мы перебираем свойства класса с помощью foreach($this as $myObj), мы получаем завершение кода при обращении к переменной $myObj->...

Для меня это лучший способ добиться этого (по крайней мере, до тех пор, пока PHP не представит типизированные массивы, если они когда-либо будут), поскольку мы объявляем тип итератора в повторяемом классе, а не в экземплярах класса, разбросанных по всему коду.

Я не показал здесь полное решение для расширения ArrayIterator, поэтому, если вы воспользуетесь этим методом, вы также можете:

• При необходимости включите другой PHPDoc уровня класса для таких методов, как offsetGet($index) и next()
• Переместите проверку работоспособности is_a($object, MyObj::class) из конструктора в частный метод
• Вызовите эту (теперь частную) проверку работоспособности из переопределений методов, таких как offsetSet($index, $newval) и append($value)

Проблема в том, что @var может обозначать только один тип - не содержать сложной формулы. Если у вас есть синтаксис для «array of Foo», зачем останавливаться на этом и не добавлять синтаксис для «массива массива, содержащего 2 Foo и три Bar»? Я понимаю, что список элементов, возможно, более общий, чем этот, но это скользкая дорожка.

Лично я несколько раз использовал @var Foo[] для обозначения «массива Foo», но это не поддерживается IDE.

Я нашел кое-что, что работает, это может спасти жизни!

private $userList = array();
$userList = User::fetchAll(); // now $userList is an array of User objects
foreach ($userList as $user) {
   $user instanceof User;
   echo $user->getName();
}