Entonces, en PHPDoc se puede especificar @vararriba de la declaración de la variable miembro para insinuar su tipo. Luego un IDE, por ej. PHPEd, sabrá con qué tipo de objeto está trabajando y podrá proporcionar una idea del código para esa variable.

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

Esto funciona muy bien hasta que necesito hacer lo mismo con una matriz de objetos para poder obtener una pista adecuada cuando repita esos objetos más adelante.

Entonces, ¿hay alguna manera de declarar una etiqueta PHPDoc para especificar que la variable miembro es una matriz de SomeObjs? @varLa matriz no es suficiente, y @var array(SomeObj)no parece ser válida, por ejemplo.

Utilizar:

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

al teclear las variables en línea, y

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

para propiedades de clase.

Respuesta anterior de '09 cuando PHPDoc (e IDEs como Zend Studio y Netbeans) no tenían esa opción:

Lo mejor que puedes hacer es decir:

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

Lo hago mucho en Zend Studio. No sé sobre otros editores, pero debería funcionar.

En PhpStorm IDE de JetBrains, puede usar /** @var SomeObj[] */, por ejemplo:

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

La documentación de phpdoc recomienda este método:

especificado que contiene un solo tipo, la definición de Tipo informa al lector del tipo de cada elemento de la matriz. Solo se espera un tipo como elemento para una matriz dada.

Ejemplo: @return int[]

Consejos Netbeans:

Obtiene la finalización del código en $users[0]->y $this->para una variedad de clases de usuario.

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

También puede ver el tipo de matriz en una lista de miembros de la clase cuando completa $this->...

Para especificar una variable es una matriz de objetos:

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

Esto funciona en Netbeans 7.2 (lo estoy usando)

Funciona también con:

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

Por lo tanto, foreachno es necesario el uso de declaraciones dentro de .

PSR-5: PHPDoc propone una forma de notación de estilo genérico.

Sintaxis

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

Los valores en una Colección PUEDEN ser incluso otra matriz e incluso otra Colección.

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

Ejemplos

<?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: Si espera que un IDE haga asistencia de código, entonces es otra cuestión sobre si el IDE admite la notación de colecciones de estilo genérico PHPDoc.

De mi respuesta a esta pregunta .

Prefiero leer y escribir código limpio, como se describe en "Código limpio" de Robert C. Martin. Al seguir su credo, no debe exigir al desarrollador (como usuario de su API) que conozca la estructura (interna) de su matriz.

El usuario de la API puede preguntar: ¿Es eso una matriz con una sola dimensión? ¿Se extienden los objetos en todos los niveles de una matriz multidimensional? ¿Cuántos bucles anidados (foreach, etc.) necesito para acceder a todos los objetos? ¿Qué tipo de objetos están "almacenados" en esa matriz?

Como describió, desea usar esa matriz (que contiene objetos) como una matriz unidimensional.

Como lo describe Nishi, puede usar:

/**
 * @return SomeObj[]
 */

para eso.

Pero de nuevo: tenga en cuenta que esta no es una notación estándar de docblock. Esta notación fue introducida por algunos productores de IDE.

Ok, ok, como desarrollador sabes que "[]" está vinculado a una matriz en PHP. Pero, ¿qué significa "algo []" en el contexto normal de PHP? "[]" significa: crear un nuevo elemento dentro de "algo". El nuevo elemento podría ser todo. Pero lo que quiere expresar es: una matriz de objetos con el mismo tipo y su tipo exacto. Como puede ver, el productor de IDE presenta un nuevo contexto. Un nuevo contexto que tenías que aprender. Un nuevo contexto que otros desarrolladores de PHP tuvieron que aprender (para comprender sus bloques de documentos). Mal estilo (!).

Debido a que su matriz tiene una dimensión, tal vez quiera llamar a esa "matriz de objetos" una "lista". Tenga en cuenta que "lista" tiene un significado muy especial en otros lenguajes de programación. Sería mejor llamarlo "colección", por ejemplo.

Recuerde: utiliza un lenguaje de programación que le permite todas las opciones de OOP. Use una clase en lugar de una matriz y haga que su clase sea transitable como una matriz. P.ej:

class orderCollection implements ArrayIterator

O si desea almacenar los objetos internos en diferentes niveles dentro de una estructura de objeto / matriz multidimensional:

class orderCollection implements RecursiveArrayIterator

Esta solución reemplaza su matriz por un objeto de tipo "orderCollection", pero hasta ahora no habilita la finalización de código dentro de su IDE. Bueno. Próximo paso:

Implemente los métodos introducidos por la interfaz con docblocks, en particular:

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

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

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

No olvide usar sugerencias de tipo para:

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

Esta solución deja de introducir muchos:

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

en todos sus archivos de código (por ejemplo, dentro de bucles), como lo confirmó Zahymaka con su respuesta. Su usuario de API no está obligado a introducir ese bloque de documentos para completar el código. Tener @return en un solo lugar reduce la redundancia (@var) lo más posible. Espolvoree "docBlocks con @var" haría que su código sea peor legible.

Finalmente has terminado. ¿Parece difícil de lograr? Parece que tomar un mazo para romper una nuez? No realmente, ya que está familiarizado con esas interfaces y con el código limpio. Recuerde: su código fuente se escribe una vez / lee muchos.

Si la finalización del código de su IDE no funciona con este enfoque, cambie a uno mejor (por ejemplo, IntelliJ IDEA, PhpStorm, Netbeans) o presente una solicitud de función en el rastreador de problemas de su productor de IDE.

Gracias a Christian Weiss (de Alemania) por ser mi entrenador y por enseñarme cosas tan maravillosas. PD: Encuéntrate conmigo y con él en XING.

Uso array[type]en Zend Studio.

En Zend Studio, array[MyClass]o array[int]incluso array[array[MyClass]]un gran trabajo.

En NetBeans 7.0 (también puede ser inferior), podría declarar el tipo de retorno "matriz con objetos de texto" tal como @return Textlo haría y la sugerencia de código funcionará:

Editar: actualizado el ejemplo con la sugerencia de @Bob Fanger

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

y solo úsalo:

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

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

No es perfecto, pero es mejor dejarlo simplemente "mezclado", lo que no aporta ningún valor.

CONTRAS es que puedes pisar la matriz como objeto de texto que arrojará errores.

Como DanielaWaranie menciona en su respuesta - hay una forma de especificar el tipo de $ item cuando iterar sobre los elementos en $ $ collectionObject: Añadir @return MyEntitiesClassNamea current()y el resto de la Iteratory ArrayAccess-Métodos que los valores de retorno.

¡Auge! No hay necesidad de /** @var SomeObj[] $collectionObj */más foreach, y trabaja bien con objeto de colección, no hay necesidad de recogida de retorno con un método específico descrito como @return SomeObj[].

Sospecho que no todos los IDE lo admiten, pero funciona perfectamente bien en PhpStorm, lo que me hace más feliz.

Ejemplo:

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
}

Qué útil iba a agregar publicando esta respuesta

En mi caso current()y el resto de los interfacemétodos se implementan en la Abstractclase de colección y no sé qué tipo de entidades se almacenarán eventualmente en la colección.

Así que aquí está el truco: no especifique el tipo de retorno en la clase abstracta, en su lugar use la instrucción PhpDoc @methoden la descripción de la clase de colección específica.

Ejemplo:

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

}

Ahora, uso de clases:

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

Una vez más: sospecho que no todos los IDE lo admiten, pero PhpStorm sí. ¡Prueba el tuyo, publica en comentarios los resultados!

Sé que llego tarde a la fiesta, pero he estado trabajando en este problema recientemente. Espero que alguien vea esto porque la respuesta aceptada, aunque correcta, no es la mejor manera de hacerlo. No en PHPStorm al menos, sin embargo, no he probado NetBeans.

La mejor manera implica extender la clase ArrayIterator en lugar de usar tipos de matriz nativos. Esto le permite escribir una sugerencia a nivel de clase en lugar de a nivel de instancia, lo que significa que solo tiene que usar PHPDoc una vez, no en todo el código (que no solo es desordenado y viola DRY, sino que también puede ser problemático cuando se trata de refactorización: PHPStorm tiene la costumbre de perder PHPDoc cuando se refactoriza)

Ver código a continuación:

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

La clave aquí es el PHPDoc que @method MyObj current()anula el tipo de retorno heredado de ArrayIterator (que es mixed). La inclusión de este PHPDoc significa que cuando iteramos sobre las propiedades de la clase usando foreach($this as $myObj), obtenemos la finalización del código al referirnos a la variable$myObj->...

Para mí, esta es la mejor manera de lograr esto (al menos hasta que PHP introduzca las matrices con tipo, si alguna vez lo hacen), ya que estamos declarando el tipo de iterador en la clase iterable, no en instancias de la clase dispersa en todo el código.

No he mostrado aquí la solución completa para extender ArrayIterator, por lo que si usa esta técnica, es posible que también desee:

• Incluya otros PHPDoc a nivel de clase según sea necesario, para métodos como offsetGet($index)ynext()
• Mueva la verificación de cordura is_a($object, MyObj::class)del constructor a un método privado
• Llame a esta verificación de cordura (ahora privada) desde las anulaciones de métodos como offsetSet($index, $newval)yappend($value)

El problema es que @varpuede denotar un solo tipo: no contiene una fórmula compleja. Si tenía una sintaxis para "matriz de Foo", ¿por qué detenerse allí y no agregar una sintaxis para "matriz de matriz, que contiene 2 Foo y tres barras"? Entiendo que una lista de elementos es quizás más genérica que eso, pero es una pendiente resbaladiza.

Personalmente, algunas veces he usado @var Foo[]para significar "una variedad de Foo", pero no es compatible con IDE.

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

¡He encontrado algo que funciona, puede 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();
}