In PHPDoc kann man also @varüber der Deklaration der Mitgliedsvariablen angeben, um auf ihren Typ hinzuweisen. Dann eine IDE, zum Beispiel. PHPEd weiß, mit welcher Art von Objekt es arbeitet, und kann einen Code-Einblick für diese Variable geben.

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

Dies funktioniert so lange, bis ich dasselbe mit einem Array von Objekten tun muss, um einen richtigen Hinweis zu erhalten, wenn ich diese Objekte später durchlaufe.

Gibt es also eine Möglichkeit, ein PHPDoc-Tag zu deklarieren, um anzugeben, dass die Mitgliedsvariable ein Array von SomeObjs ist? @varArray ist nicht genug und @var array(SomeObj)scheint zum Beispiel nicht gültig zu sein.

Verwenden:

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

beim Eingeben von Inline-Variablen und

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

für Klasseneigenschaften.

Vorherige Antwort von '09, als PHPDoc (und IDEs wie Zend Studio und Netbeans) diese Option nicht hatten:

Das Beste, was Sie tun können, ist zu sagen:

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

Das mache ich oft in Zend Studio. Ich weiß nichts über andere Editoren, aber es sollte funktionieren.

In der PhpStorm-IDE von JetBrains können Sie Folgendes verwenden /** @var SomeObj[] */: z.

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

Die phpdoc-Dokumentation empfiehlt diese Methode:

Die Typdefinition enthält einen einzelnen Typ und informiert den Leser über den Typ jedes Array-Elements. Es wird dann nur ein Typ als Element für ein bestimmtes Array erwartet.

Beispiel: @return int[]

Netbeans Hinweise:

Sie erhalten Code - Vervollständigung auf $users[0]->und $this->für eine Reihe von Benutzerklassen.

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

Sie können den Typ des Arrays auch in einer Liste der Klassenmitglieder sehen, wenn Sie den Vorgang abgeschlossen haben $this->...

So geben Sie eine Variable an: ein Array von Objekten:

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

Dies funktioniert in Netbeans 7.2 (ich benutze es)

Funktioniert auch mit:

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

Daher ist die Verwendung einer Deklaration innerhalb der foreachnicht erforderlich.

PSR-5: PHPDoc schlägt eine Form der Notation im Generics-Stil vor.

Syntax

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

Werte in einer Sammlung können sogar ein anderes Array und sogar eine andere Sammlung sein.

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

Beispiele

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

Hinweis: Wenn Sie erwarten, dass eine IDE Codeunterstützung ausführt, ist es eine weitere Frage, ob die IDE die Notation von Sammlungen im generischen PHPDoc-Stil unterstützt.

Von meiner Antwort auf diese Frage .

Ich lese und schreibe lieber sauberen Code - wie in "Clean Code" von Robert C. Martin beschrieben. Wenn Sie seinem Credo folgen, sollten Sie nicht verlangen, dass der Entwickler (als Benutzer Ihrer API) die (interne) Struktur Ihres Arrays kennt.

Der API-Benutzer kann fragen: Ist das ein Array mit nur einer Dimension? Sind die Objekte auf allen Ebenen eines mehrdimensionalen Arrays verteilt? Wie viele verschachtelte Schleifen (foreach usw.) benötige ich, um auf alle Objekte zuzugreifen? Welche Art von Objekten wird in diesem Array "gespeichert"?

Wie Sie beschrieben haben, möchten Sie dieses Array (das Objekte enthält) als eindimensionales Array verwenden.

Wie von Nishi beschrieben, können Sie Folgendes verwenden:

/**
 * @return SomeObj[]
 */

dafür.

Aber noch einmal: Seien Sie sich bewusst - dies ist keine Standard-Docblock-Notation. Diese Notation wurde von einigen IDE-Herstellern eingeführt.

Okay, okay, als Entwickler wissen Sie, dass "[]" an ein Array in PHP gebunden ist. Aber was bedeutet ein "etwas []" im normalen PHP-Kontext? "[]" bedeutet: Neues Element in "etwas" erstellen. Das neue Element könnte alles sein. Was Sie jedoch ausdrücken möchten, ist: Array von Objekten mit demselben Typ und genauem Typ. Wie Sie sehen können, führt der IDE-Produzent einen neuen Kontext ein. Ein neuer Kontext, den man lernen musste. Ein neuer Kontext, den andere PHP-Entwickler lernen mussten (um Ihre Docblocks zu verstehen). Schlechter Stil (!).

Da Ihr Array eine Dimension hat, möchten Sie dieses "Array von Objekten" möglicherweise als "Liste" bezeichnen. Beachten Sie, dass "Liste" in anderen Programmiersprachen eine ganz besondere Bedeutung hat. Es wäre besser, es zum Beispiel "Sammlung" zu nennen.

Denken Sie daran: Sie verwenden eine Programmiersprache, die Ihnen alle Optionen von OOP ermöglicht. Verwenden Sie eine Klasse anstelle eines Arrays und machen Sie Ihre Klasse wie ein Array durchlaufbar. Z.B:

class orderCollection implements ArrayIterator

Oder wenn Sie die internen Objekte auf verschiedenen Ebenen in einer mehrdimensionalen Array- / Objektstruktur speichern möchten:

class orderCollection implements RecursiveArrayIterator

Diese Lösung ersetzt Ihr Array durch ein Objekt vom Typ "orderCollection", aktiviert jedoch noch nicht die Code-Vervollständigung in Ihrer IDE. Okay. Nächster Schritt:

Implementieren Sie die Methoden, die von der Schnittstelle mit docblocks eingeführt werden - insbesondere:

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

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

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

Vergessen Sie nicht, Typhinweise zu verwenden für:

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

Diese Lösung führt nicht mehr viele ein:

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

Überall in Ihren Codedateien (z. B. innerhalb von Schleifen), wie Zahymaka mit seiner Antwort bestätigt hat. Ihr API-Benutzer ist nicht gezwungen, diese Dokumentblöcke einzuführen, um den Code zu vervollständigen. Wenn Sie @return nur an einer Stelle haben, wird die Redundanz (@var) so weit wie möglich reduziert. Wenn Sie "docBlocks with @var" streuen, ist Ihr Code am schlechtesten lesbar.

Endlich bist du fertig. Sieht schwer zu erreichen aus? Sieht aus wie ein Vorschlaghammer, um eine Nuss zu knacken? Nicht wirklich, da Sie mit diesen Schnittstellen und mit sauberem Code vertraut sind. Denken Sie daran: Ihr Quellcode wird einmal geschrieben / viele gelesen.

Wenn die Code-Vervollständigung Ihrer IDE mit diesem Ansatz nicht funktioniert, wechseln Sie zu einem besseren (z. B. IntelliJ IDEA, PhpStorm, Netbeans) oder reichen Sie eine Funktionsanforderung im Issue-Tracker Ihres IDE-Herstellers ein.

Vielen Dank an Christian Weiss (aus Deutschland), der mein Trainer war und mir so tolle Sachen beigebracht hat. PS: Triff mich und ihn auf XING.

Verwendung array[type]in Zend Studio.

In Zend Studio, array[MyClass]oder array[int]oder sogar array[array[MyClass]]Arbeit groß.

In NetBeans 7.0 (möglicherweise auch niedriger) können Sie den Rückgabetyp "Array mit Textobjekten" genauso deklarieren, @return Textund der Code-Hinweis funktioniert:

Bearbeiten: Das Beispiel wurde mit dem Vorschlag von @Bob Fanger aktualisiert

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

und benutze es einfach:

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

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

Es ist nicht perfekt, aber es ist besser, es einfach "gemischt" zu lassen, was keinen Wert bringt.

CONS ist, dass Sie das Array als Textobjekt betreten dürfen, das Fehler auslöst.

Wie DanielaWaranie in ihrer Antwort erwähnt - gibt es einen Weg , um die Art von $ item angeben , wenn Sie $ Artikel in $ collectionObject iterieren: In @return MyEntitiesClassNamezu current()und der Rest der Iteratorund ArrayAccess-methoden , welche Rückgabewerte.

Boom! Keine Notwendigkeit in /** @var SomeObj[] $collectionObj */over foreachund funktioniert direkt mit dem Auflistungsobjekt, keine Notwendigkeit, die Auflistung mit der spezifischen Methode zurückzugeben, die als beschrieben wird @return SomeObj[].

Ich vermute, dass nicht alle IDE es unterstützen, aber es funktioniert einwandfrei in PhpStorm, was mich glücklicher macht.

Beispiel:

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
}

Was für ein Nutzen wollte ich hinzufügen, um diese Antwort zu veröffentlichen

In meinem Fall current()und in anderen interfaceFällen sind AbstractMethoden in der Klasse -collection implementiert, und ich weiß nicht, welche Art von Entitäten eventuell in der Sammlung gespeichert werden.

Hier ist also der Trick: Geben Sie keinen Rückgabetyp in der abstrakten Klasse an, sondern verwenden Sie stattdessen die PhpDoc-Anweisung @methodzur Beschreibung einer bestimmten Auflistungsklasse.

Beispiel:

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

}

Nun, Verwendung von Klassen:

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

Noch einmal: Ich vermute, dass nicht alle IDE dies unterstützen, PhpStorm jedoch. Probieren Sie es aus, posten Sie die Ergebnisse im Kommentar!

Ich weiß, dass ich zu spät zur Party komme, aber ich habe kürzlich an diesem Problem gearbeitet. Ich hoffe, jemand sieht das, denn die akzeptierte Antwort ist zwar richtig, aber nicht der beste Weg, dies zu tun. Zumindest nicht in PHPStorm, aber ich habe NetBeans noch nicht getestet.

Am besten erweitern Sie die ArrayIterator-Klasse, anstatt native Array-Typen zu verwenden. Auf diese Weise können Sie Hinweise auf Klassenebene und nicht auf Instanzebene eingeben. Dies bedeutet, dass Sie nur einmal PHPDoc ausführen müssen, nicht im gesamten Code (was nicht nur chaotisch ist und gegen DRY verstößt, sondern auch problematisch sein kann, wenn es darum geht Refactoring - PHPStorm hat die Angewohnheit, beim Refactoring PHPDoc zu vermissen.)

Siehe Code unten:

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

Der Schlüssel hier ist das PHPDoc, @method MyObj current()das den von ArrayIterator (dh mixed) geerbten Rückgabetyp überschreibt . Die Aufnahme dieses PHPDoc bedeutet, dass wir beim Durchlaufen der Klasseneigenschaften mit foreach($this as $myObj)die Code-Vervollständigung erhalten, wenn wir auf die Variable verweisen$myObj->...

Für mich ist dies der beste Weg, dies zu erreichen (zumindest bis PHP typisierte Arrays einführt, falls dies jemals der Fall sein sollte), da wir den Iteratortyp in der iterierbaren Klasse deklarieren, nicht in Instanzen der im Code verteilten Klasse.

Ich habe hier nicht die vollständige Lösung für die Erweiterung von ArrayIterator gezeigt. Wenn Sie diese Technik verwenden, möchten Sie möglicherweise auch:

• Fügen Sie nach Bedarf andere PHPDocs auf Klassenebene für Methoden wie offsetGet($index)und hinzunext()
• Verschieben Sie die Überprüfung der Integrität is_a($object, MyObj::class)vom Konstruktor in eine private Methode
• Nennen Sie diese (jetzt private) Überprüfung der Integrität anhand von Methodenüberschreibungen wie offsetSet($index, $newval)undappend($value)

Das Problem ist, dass @varnur ein einzelner Typ bezeichnet werden kann - keine komplexe Formel enthalten. Wenn Sie eine Syntax für "Array of Foo" hatten, warum sollten Sie dort anhalten und keine Syntax für "Array of Array, das 2 Foo's und drei Bar's enthält" hinzufügen? Ich verstehe, dass eine Liste von Elementen vielleicht allgemeiner ist, aber es ist ein rutschiger Hang.

Persönlich habe ich einige Male verwendet @var Foo[], um "ein Array von Foo's" zu bezeichnen, aber es wird von IDEs nicht unterstützt.

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

Ich habe etwas gefunden, das funktioniert, es kann Leben retten!

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