Quindi, in PHPDoc si può specificare @varsopra la dichiarazione della variabile membro per suggerire il suo tipo. Quindi un IDE, per es. PHPEd, saprà con quale tipo di oggetto sta lavorando e sarà in grado di fornire una visione del codice per quella variabile.

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

Funziona alla grande fino a quando non ho bisogno di fare lo stesso con una serie di oggetti per essere in grado di ottenere un suggerimento adeguato quando ripasso questi oggetti in seguito.

Quindi, c'è un modo per dichiarare un tag PHPDoc per specificare che la variabile membro è un array di SomeObjs? @varl'array non è sufficiente e @var array(SomeObj)non sembra essere valido, ad esempio.

Uso:

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

quando si digitano le variabili incorporate e

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

per le proprietà di classe.

Risposta precedente del '09 quando PHPDoc (e gli IDE come Zend Studio e Netbeans) non avevano questa opzione:

Il meglio che puoi fare è dire

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

Lo faccio molto in Zend Studio. Non so di altri redattori, ma dovrebbe funzionare.

Nell'IDE PhpStorm di JetBrains, è possibile utilizzare /** @var SomeObj[] */, ad esempio:

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

La documentazione di phpdoc raccomanda questo metodo:

specificata contenente un singolo tipo, la definizione del tipo informa il lettore del tipo di ciascun elemento dell'array. Si prevede quindi un solo tipo come elemento per un determinato array.

Esempio: @return int[]

Suggerimenti di Netbeans:

Ottieni il completamento del codice su $users[0]->e $this->per una matrice di classi utente.

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

Puoi anche vedere il tipo di array in un elenco di membri della classe quando esegui il completamento di $this->...

Per specificare una variabile è una matrice di oggetti:

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

Funziona con Netbeans 7.2 (lo sto usando)

Funziona anche con:

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

Pertanto foreachnon è necessario l' uso della dichiarazione all'interno del documento .

PSR-5: PHPDoc propone una forma di notazione in stile Generico .

Sintassi

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

I valori in una raccolta POSSONO persino essere un altro array e persino un'altra raccolta.

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

Esempi

<?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 ti aspetti che un IDE esegua il code assist, è un'altra domanda se l'IDE supporta la notazione di raccolte in stile generico PHPDoc.

Dalla mia risposta a questa domanda .

Preferisco leggere e scrivere codice pulito, come indicato in "Codice pulito" di Robert C. Martin. Quando segui il suo credo non devi richiedere allo sviluppatore (come utente della tua API) di conoscere la struttura (interna) del tuo array.

L'utente API può chiedere: è un array con una sola dimensione? Gli oggetti sono sparsi su tutti i livelli di un array multidimensionale? Di quanti loop nidificati (foreach, ecc.) Devo accedere a tutti gli oggetti? Che tipo di oggetti sono "memorizzati" in quell'array?

Come hai delineato, vuoi usare quell'array (che contiene oggetti) come un array monodimensionale.

Come indicato da Nishi è possibile utilizzare:

/**
 * @return SomeObj[]
 */

per quello.

Ma ancora: attenzione: questa non è una notazione standard di blocco dei documenti. Questa notazione è stata introdotta da alcuni produttori IDE.

Ok, ok, come sviluppatore sai che "[]" è legato a un array in PHP. Ma cosa significa "qualcosa []" in un normale contesto PHP? "[]" significa: crea un nuovo elemento all'interno di "qualcosa". Il nuovo elemento potrebbe essere tutto. Ma quello che vuoi esprimere è: matrice di oggetti con lo stesso tipo ed è il tipo esatto. Come puoi vedere, il produttore IDE introduce un nuovo contesto. Un nuovo contesto che dovevi imparare. Un nuovo contesto che altri sviluppatori PHP hanno dovuto imparare (per capire i tuoi blocchi di documenti). Cattivo stile (!).

Poiché la tua matrice ha una dimensione, potresti voler chiamare quella "matrice di oggetti" un "elenco". Tenere presente che "elenco" ha un significato molto speciale in altri linguaggi di programmazione. Sarebbe molto meglio chiamarlo "raccolta" per esempio.

Ricorda: usi un linguaggio di programmazione che ti consente tutte le opzioni di OOP. Usa una classe invece di un array e rendi la tua classe percorribile come un array. Per esempio:

class orderCollection implements ArrayIterator

O se si desidera archiviare gli oggetti interni su livelli diversi all'interno di una struttura di matrice / oggetto multidimensionale:

class orderCollection implements RecursiveArrayIterator

Questa soluzione sostituisce l'array con un oggetto di tipo "orderCollection", ma finora non consente il completamento del codice all'interno dell'IDE. Va bene. Passo successivo:

Implementare i metodi introdotti dall'interfaccia con docblocks, in particolare:

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

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

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

Non dimenticare di utilizzare i suggerimenti sul tipo per:

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

Questa soluzione smette di introdurre molti:

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

in tutti i tuoi file di codice (ad es. all'interno di loop), come confermato da Zahymaka con la sua risposta. Il tuo utente API non è obbligato a introdurre quei blocchi di documenti, per avere il completamento del codice. Avere @return in un solo posto riduce la ridondanza (@var) il più possibile. Cospargere "docBlocks con @var" renderebbe il tuo codice peggiore leggibile.

Finalmente hai finito. Sembra difficile da raggiungere? Sembra di prendere un martello per rompere un dado? Non proprio, dal momento che hai familiarità con quelle interfacce e con il codice pulito. Ricorda: il tuo codice sorgente è scritto una volta / leggi molti.

Se il completamento del codice del tuo IDE non funziona con questo approccio, passa a uno migliore (ad esempio IntelliJ IDEA, PhpStorm, Netbeans) o invia una richiesta di funzione sul tracker del problema del tuo produttore IDE.

Grazie a Christian Weiss (dalla Germania) per essere stato il mio allenatore e per avermi insegnato cose fantastiche. PS: Incontriamoci con lui su XING.

Utilizzare array[type]in Zend Studio.

In Zend Studio, array[MyClass]o array[int]o anche array[array[MyClass]]grande opera.

In NetBeans 7.0 (potrebbe anche essere inferiore) è possibile dichiarare il tipo restituito "array con oggetti Text" così come funzionerà @return Texte il suggerimento sul codice:

Modifica: aggiornato l'esempio con il suggerimento di @Bob Fanger

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

e basta usarlo:

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

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

Non è perfetto, ma è meglio lasciarlo semplicemente "misto", il che non ha alcun valore.

CONTRO è il permesso di percorrere l'array come oggetto di testo che genererà errori.

Come DanielaWaranie menzionato nella sua risposta - c'è un modo per specificare il tipo di $ item quando l'iterazione di $ articoli in $ collectionObject: Aggiungi @return MyEntitiesClassNamealla current()e resto del Iteratore ArrayAccess-metodi che i valori di ritorno.

Boom! Non c'è bisogno di /** @var SomeObj[] $collectionObj */over foreache funziona perfettamente con l'oggetto collection, non è necessario restituire la collezione con il metodo specifico descritto come@return SomeObj[] .

Sospetto che non tutti gli IDE lo supportino ma funziona perfettamente in PhpStorm, il che mi rende più felice.

Esempio:

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
}

Quale utile stavo per aggiungere pubblicando questa risposta

Nel mio caso current()e nel resto dei interfacemetodi sono implementati inAbstract classe -collection e non so quale tipo di entità alla fine verrà archiviata nella raccolta.

Quindi, ecco il trucco: non specificare il tipo restituito in classe astratta, invece usa l'istruzione PhpDoc @method nella descrizione di una specifica classe di raccolta.

Esempio:

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

}

Ora, l'uso delle classi:

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

Ancora una volta: sospetto che non tutti gli IDE lo supportino, ma PhpStorm lo fa. Prova il tuo, pubblica nei commenti i risultati!

So di essere in ritardo alla festa, ma ho lavorato su questo problema di recente. Spero che qualcuno lo veda perché la risposta accettata, sebbene corretta, non lo è il modo migliore per farlo. Almeno non in PHPStorm, non ho testato NetBeans.

Il modo migliore prevede l'estensione della classe ArrayIterator piuttosto che l'utilizzo di tipi di array nativi. Questo ti permette di digitare un suggerimento a livello di classe piuttosto che a livello di istanza, il che significa che devi PHPDoc solo una volta, non in tutto il codice (che non è solo disordinato e viola DRY, ma può anche essere problematico quando si tratta di refactoring - PHPStorm ha l'abitudine di perdere PHPDoc durante il refactoring)

Vedi il codice qui sotto:

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 chiave qui è PHPDoc che @method MyObj current()sovrascrive il tipo restituito ereditato da ArrayIterator (che è mixed). L'inclusione di questo PHPDoc significa che quando si scorre le proprietà della classe usandoforeach($this as $myObj) , otteniamo quindi il completamento del codice quando ci riferiamo alla variabile$myObj->...

Per me, questo è il modo più semplice per raggiungere questo obiettivo (almeno fino a quando PHP non introdurrà Typed Arrays, se mai lo faranno), poiché stiamo dichiarando il tipo di iteratore nella classe iterabile, non su istanze della classe sparse nel codice.

Non ho mostrato qui la soluzione completa per l'estensione di ArrayIterator, quindi se usi questa tecnica, potresti anche voler:

• Includi altri PHPDoc a livello di classe come richiesto, per metodi come offsetGet($index)enext()
• Spostare il controllo di integrità is_a($object, MyObj::class)dal costruttore in un metodo privato
• Chiamare questo controllo di integrità (ora privato) da sostituzioni di metodi come offsetSet($index, $newval)eappend($value)

Il problema è che @varpuò semplicemente indicare un singolo tipo: non contiene una formula complessa. Se hai avuto una sintassi per "array di Foo", perché fermarsi qui e non aggiungere una sintassi per "array di array, che contiene 2 Foo e tre Bar"? Capisco che un elenco di elementi è forse più generico di quello, ma è una pendenza scivolosa.

Personalmente, ho usato alcune volte @var Foo[]per indicare "un array di Foo", ma non è supportato da IDE.

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

Ho trovato qualcosa che funziona, può salvare vite!

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