Portanto, no PHPDoc, pode-se especificar @varacima da declaração da variável membro para sugerir seu tipo. Então um IDE, por exemplo. O PHPEd saberá com que tipo de objeto está trabalhando e poderá fornecer uma visão do código para essa variável.

<?php
  class Test
  {
    /** @var SomeObj */
    private $someObjInstance;
  }
?>

Isso funciona muito bem até que eu precise fazer o mesmo com uma matriz de objetos para poder obter uma dica adequada quando eu percorrer esses objetos posteriormente.

Então, existe uma maneira de declarar uma tag PHPDoc para especificar que a variável membro é uma matriz de SomeObjs? @vararray não é suficiente e @var array(SomeObj)não parece ser válido, por exemplo.

Usar:

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

ao digitar variáveis ​​em linha e

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

para propriedades de classe.

Resposta anterior de '09 quando PHPDoc (e IDEs como Zend Studio e Netbeans) não tinham essa opção:

O melhor que você pode fazer é dizer:

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

Eu faço muito isso no Zend Studio. Não conheço outros editores, mas deve funcionar.

No PhpStorm IDE do JetBrains, você pode usar /** @var SomeObj[] */, por exemplo:

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

A documentação do phpdoc recomenda este método:

especificada contendo um único tipo, a definição de Tipo informa o leitor sobre o tipo de cada elemento da matriz. Somente um tipo é esperado como elemento para uma determinada matriz.

Exemplo: @return int[]

Dicas do Netbeans:

Você obtém a conclusão do código para $users[0]->e $this->para uma matriz de classes de usuário.

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

Você também pode ver o tipo da matriz em uma lista de membros da classe ao concluir a $this->...

Para especificar uma variável é uma matriz de objetos:

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

Isso funciona no Netbeans 7.2 (estou usando)

Trabalha também com:

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

Portanto, o uso da declaração dentro do foreachnão é necessário.

PSR-5: O PHPDoc propõe uma forma de notação no estilo genérico.

Sintaxe

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

Valores em uma coleção podem até ser outra matriz e até outra coleção.

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

Exemplos

<?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> */

Nota: Se você espera que um IDE faça assistência ao código, é outra pergunta sobre se o IDE suporta a notação de coleções no estilo genérico PHPDoc.

Da minha resposta a esta pergunta .

Prefiro ler e escrever código limpo - conforme descrito em "Código Limpo", de Robert C. Martin. Ao seguir o seu credo, você não deve exigir que o desenvolvedor (como usuário da sua API) conheça a estrutura (interna) da sua matriz.

O usuário da API pode perguntar: Isso é uma matriz com apenas uma dimensão? Os objetos estão espalhados em todos os níveis de uma matriz multidimensional? Quantos loops aninhados (foreach, etc.) eu preciso acessar todos os objetos? Que tipo de objetos são "armazenados" nessa matriz?

Como você descreveu, deseja usar essa matriz (que contém objetos) como uma matriz unidimensional.

Conforme descrito por Nishi, você pode usar:

/**
 * @return SomeObj[]
 */

por isso.

Mais uma vez: esteja ciente - essa não é uma notação padrão de bloqueio de documentos. Essa notação foi introduzida por alguns produtores de IDE.

Ok, ok, como desenvolvedor, você sabe que "[]" está vinculado a uma matriz em PHP. Mas o que um "algo []" significa no contexto normal do PHP? "[]" significa: crie um novo elemento dentro de "algo". O novo elemento pode ser tudo. Mas o que você deseja expressar é: matriz de objetos do mesmo tipo e do tipo exato. Como você pode ver, o produtor do IDE introduz um novo contexto. Um novo contexto que você teve que aprender. Um novo contexto que outros desenvolvedores de PHP tiveram que aprender (para entender seus docblocks). Estilo ruim (!).

Como sua matriz possui uma dimensão, talvez você queira chamar essa "matriz de objetos" de "lista". Esteja ciente de que "lista" tem um significado muito especial em outras linguagens de programação. Seria melhor chamar isso de "coleção", por exemplo.

Lembre-se: você usa uma linguagem de programação que permite todas as opções de OOP. Use uma classe em vez de uma matriz e torne sua classe percorrível como uma matriz. Por exemplo:

class orderCollection implements ArrayIterator

Ou se você deseja armazenar os objetos internos em diferentes níveis em uma estrutura de matriz / objeto multidimensional:

class orderCollection implements RecursiveArrayIterator

Esta solução substitui sua matriz por um objeto do tipo "orderCollection", mas não habilita a conclusão de código no seu IDE até o momento. OK. Próxima Etapa:

Implemente os métodos introduzidos pela interface com docblocks - em particular:

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

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

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

Não se esqueça de usar dicas de tipo para:

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

Esta solução para de introduzir muitos:

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

em todos os seus arquivos de código (por exemplo, dentro de loops), como Zahymaka confirmou com sua resposta. O usuário da API não é obrigado a introduzir os docblocks, a ter o código completo. Ter @return em apenas um local reduz a redundância (@var) o mais mutch possível. Polvilhe "docBlocks com @var" para tornar seu código mais legível.

Finalmente você está pronto. Parece difícil de conseguir? Parece tomar uma marreta para quebrar uma noz? Não muito, desde que você esteja familiarizado com essas interfaces e com o código limpo. Lembre-se: seu código-fonte é escrito uma vez / é lido muitos.

Se a conclusão do código do seu IDE não funcionar com essa abordagem, mude para uma melhor (por exemplo, IntelliJ IDEA, PhpStorm, Netbeans) ou envie uma solicitação de recurso no rastreador de problemas do seu produtor de IDE.

Agradeço a Christian Weiss (da Alemanha) por ser meu treinador e por me ensinar coisas excelentes. PS: Encontre eu e ele no XING.

Use array[type]no Zend Studio.

Em Zend Studio, array[MyClass]ou array[int]ou mesmo array[array[MyClass]]um grande trabalho.

No NetBeans 7.0 (também pode ser menor), você pode declarar o tipo de retorno "matriz com objetos de texto", assim como @return Texta dica de código funcionará:

Edit: atualizou o exemplo com a sugestão do @Bob Fanger

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

e apenas use-o:

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

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

Não é perfeito, mas é melhor apenas deixá-lo "misturado", o que não traz valor.

CONS é que você pode pisar a matriz como objeto de texto, o que gerará erros.

Como DanielaWaranie mencionou em sua resposta - existe uma maneira de especificar o tipo de $ item ao iterar mais de $ itens em $ collectionObject: adicionar e @return MyEntitiesClassNameao current()restante de IteratoreArrayAccess -Métodos que valores de retorno.

Estrondo! Não há necessidade de /** @var SomeObj[] $collectionObj */terminar foreache funciona corretamente com o objeto de coleção, não há necessidade de retornar a coleção com o método específico descrito como @return SomeObj[].

Eu suspeito que nem todos os IDE o suportam, mas ele funciona perfeitamente no PhpStorm, o que me deixa mais feliz.

Exemplo:

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
}

Que utilidade eu adicionaria ao postar esta resposta

No meu caso, o current()restante dos interfacemétodos é implementado na Abstractclasse -collection e não sei que tipo de entidades serão armazenadas na coleção.

Então, aqui está o truque: não especifique o tipo de retorno na classe abstrata, em vez disso, use a instrução PhpDoc @methodna descrição de uma classe de coleção específica.

Exemplo:

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...

}

Agora, uso de classes:

$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();
}

Mais uma vez: suspeito que nem todos os IDE suportam, mas o PhpStorm suporta. Experimente o seu, postar nos comentários os resultados!

Sei que estou atrasado para a festa, mas venho trabalhando neste problema recentemente. Espero que alguém veja isso porque a resposta aceita, embora correta, não é a melhor maneira de fazer isso. Não no PHPStorm, pelo menos, ainda não testei o NetBeans.

A melhor maneira envolve estender a classe ArrayIterator em vez de usar tipos de matriz nativos. Isso permite que você digite dica no nível da classe e não no nível da instância, o que significa que você precisa apenas do PHPDoc uma vez, não em todo o seu código (que não é apenas confuso e viola o DRY, mas também pode ser problemático quando se trata de refatoração - PHPStorm tem o hábito de perder o PHPDoc ao refatorar)

Veja o código abaixo:

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();

A chave aqui é o PHPDoc @method MyObj current()substituindo o tipo de retorno herdado de ArrayIterator (que é mixed). A inclusão desse PHPDoc significa que, quando iteramos sobre as propriedades da classe usandoforeach($this as $myObj) , obtemos a conclusão do código quando nos referimos à variável$myObj->...

Para mim, esta é a maneira mais clara de conseguir isso (pelo menos até o PHP apresentar as matrizes digitadas, se é que o fazem), como declaramos o tipo de iterador na classe iterável, não nas instâncias da classe espalhadas pelo código.

Não mostrei aqui a solução completa para estender o ArrayIterator; portanto, se você usar esta técnica, também poderá:

• Inclua outro PHPDoc em nível de classe, conforme necessário, para métodos como offsetGet($index)enext()
• Mover a verificação de sanidade is_a($object, MyObj::class) do construtor para um método privado
• Chame isso de verificação de integridade (agora privada) a partir de substituições de métodos como offsetSet($index, $newval)eappend($value)

O problema é que @varpode apenas indicar um único tipo - Não contém uma fórmula complexa. Se você tinha uma sintaxe para "array of Foo", por que parar por aí e não adicionar uma sintaxe para "array of array, que contém 2 Foo's e três Bar's"? Entendo que uma lista de elementos talvez seja mais genérica que isso, mas é uma ladeira escorregadia.

Pessoalmente, usei algumas vezes @var Foo[]para significar "uma matriz de Foo's", mas não é suportada pelos IDE.

<?php foreach($this->models as /** @var Model_Object_WheelModel */ $model): ?>
    <?php
    // Type hinting now works:
    $model->getImage();
    ?>
<?php endforeach; ?>

Eu encontrei algo que está funcionando, ele pode salvar vidas!

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