Yani, PHPDoc'da türünün @varipucu vermek için üye değişken bildiriminin yukarısında belirtilebilir. Sonra bir IDE, örn. PHPEd, ne tür bir nesne ile çalıştığını bilecek ve bu değişken için bir kod bilgisi sağlayabilecektir.

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

Daha sonra bu nesneler arasında yineleme yaparken uygun bir ipucu elde edebilmek için bir dizi nesneye aynı şeyi yapmam gerekene kadar bu harika çalışıyor.

Yani, üye değişkeninin SomeObjs dizisi olduğunu belirtmek için bir PHPDoc etiketi bildirmenin bir yolu var mı? @vardizi yeterli değildir ve @var array(SomeObj)örneğin geçerli görünmemektedir.

kullanın:

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

satır içi değişkenleri belirtirken ve

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

sınıf özellikleri için.

PHPDoc (ve Zend Studio ve Netbeans gibi IDE'ler) bu seçeneğe sahip olmadığında '09'dan önceki yanıt:

Yapabileceğiniz en iyi şey,

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

Bunu Zend Studio'da çok yapıyorum. Diğer editörleri bilmiyorum, ama çalışması gerekiyor.

JetBrains'ten PhpStorm IDE'de şunları kullanabilirsiniz /** @var SomeObj[] */:

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

Phpdoc belgeleri , bu yöntem önerir:

Tek bir tür içeren belirtildiğinde, Tür tanımı okuyucuya her dizi öğesinin türünü bildirir. Belirli bir dizi için öğe olarak yalnızca bir Tür beklenir.

Misal: @return int[]

Netbeans ipuçları:

Üzerinde kod tamamlama almak $users[0]->ve için $this->Kullanıcı sınıfları bir dizi için.

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

Dizinin türünü, tamamladığınızda sınıf üyeleri listesinde de görebilirsiniz. $this->...

Bir değişken belirtmek bir nesne dizisidir:

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

Bu Netbeans 7.2'de çalışıyor (kullanıyorum)

Şununla da çalışır:

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

Bu nedenle, içinde bildirim kullanmak foreachgerekli değildir.

PSR-5: PHPDoc bir çeşit Generics tarzı gösterim önerir.

Sözdizimi

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

Bir Koleksiyondaki değerler başka bir dizi ve hatta başka bir Koleksiyon olabilir.

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

Örnekler

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

Not: Bir IDE'nin kod yardımı yapmasını bekliyorsanız, IDE'nin PHPDoc Generic-style collection gösterimini destekleyip desteklemediği hakkında başka bir soru daha vardır.

Cevabım bu soruya .

Temiz kod okumayı ve yazmayı tercih ediyorum - Robert C. Martin tarafından "Clean Code" da belirtildiği gibi. Kredisini takip ederken geliştiricinin (API'nızın kullanıcısı olarak) dizinizin (dahili) yapısını bilmesini istememeniz gerekir.

API kullanıcısı şunu sorabilir: Bu yalnızca bir boyutu olan bir dizi mi? Nesneler çok boyutlu bir dizinin tüm düzeylerine yayılmış mı? Tüm nesnelere erişmek için kaç tane iç içe döngü (foreach vb.) Gerekir? Bu dizide ne tür nesneler "depolanır"?

Ana hatlarıyla belirttiğiniz gibi, o diziyi (nesneleri içeren) tek boyutlu bir dizi olarak kullanmak istersiniz.

Nishi tarafından belirtildiği gibi şunları kullanabilirsiniz:

/**
 * @return SomeObj[]
 */

bunun için.

Ama tekrar: farkında olun - bu standart bir docblock gösterimi değildir. Bu gösterim bazı IDE üreticileri tarafından tanıtıldı.

Tamam, tamam, bir geliştirici olarak "[]" in PHP'deki bir diziye bağlı olduğunu biliyorsunuz. Ancak normal PHP bağlamında bir "şey []" ne anlama gelir? "[]" şu anlama gelir: "bir şey" içinde yeni bir öğe yaratmak. Yeni unsur her şey olabilir. Ancak ifade etmek istediğiniz şey: aynı türdeki nesnelerin dizisi ve tam türü. Gördüğünüz gibi, IDE üreticisi yeni bir bağlam sunuyor. Öğrenmeniz gereken yeni bir bağlam. Diğer PHP geliştiricilerinin öğrenmesi gereken yeni bir bağlam (docblock'larınızı anlamak için). Kötü stil (!).

Dizinizin bir boyutu olduğundan, "nesne dizisi" ni "liste" olarak adlandırmak isteyebilirsiniz. "Liste" nin diğer programlama dillerinde çok özel bir anlamı olduğunu unutmayın. Mesela "koleksiyon" demek daha iyi olurdu.

Unutmayın: tüm OOP seçeneklerini sağlayan bir programlama dili kullanırsınız. Dizi yerine bir sınıf kullanın ve sınıfınızı bir dizi gibi gezilebilir yapın. Örneğin:

class orderCollection implements ArrayIterator

Veya dahili nesneleri çok boyutlu bir dizi / nesne yapısı içinde farklı düzeylerde saklamak istiyorsanız:

class orderCollection implements RecursiveArrayIterator

Bu çözüm dizinizi "orderCollection" türündeki bir nesne ile değiştirir, ancak şu ana kadar IDE'nizde kod tamamlamayı etkinleştirmeyin. Tamam. Sonraki adım:

Arayüz tarafından tanıtılan yöntemleri docblocks ile uygulayın - özellikle:

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

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

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

Aşağıdakiler için tür ipucunu kullanmayı unutmayın:

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

Bu çözüm aşağıdakileri sunmayı bırakır:

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

Zahymaka'nın yanıtıyla doğruladığı gibi, kod dosyalarınızın her yerinde (örn. döngüler içinde). API kullanıcısı, kod tamamlama için bu docblock'ları tanıtmak zorunda değildir. @ Geri dönüşünün tek bir yerde olması yedekliliği (@var) mümkün olduğunca mutch azaltır. Serpin "@var ile docBlocks" kodunuzu en kötü okunabilir yapar.

Sonunda bitti. Başarmak zor görünüyor mu? Bir ceviz kırmak için balyoz almak gibi mi? O arayüzlere ve temiz kodlara aşina olduğunuzdan, gerçek değil. Unutmayın: kaynak kodunuz bir kez yazılır / çok okunur.

IDE'nizin kodunun tamamlanması bu yaklaşımla çalışmazsa, daha iyi olana geçin (örn. IntelliJ IDEA, PhpStorm, Netbeans) veya IDE üreticinizin sorun izleyicisine bir özellik isteği gönderin.

Eğitmenim olduğu ve bana çok güzel şeyler öğrettiği için Christian Weiss'a (Almanya'dan) teşekkürler. PS: Ben ve onunla XING'de buluş.

kullanım array[type]Zend Studio'da .

Zend Studio, içinde array[MyClass]veya array[int]hatta array[array[MyClass]]çalışan harika.

NetBeans 7.0'da (çok daha düşük olabilir), dönüş türünü "Metin nesneleriyle dizi" olarak @return Texttanımlayabilir ve kod ipucu işe yarayacaktır:

Düzenle: örneği @Bob Fanger önerisiyle güncelledi

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

ve sadece kullanın:

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

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

Mükemmel değil ama o zaman sadece "karışık" bırakmak daha iyidir, bu da hiçbir değer getirmez.

CONS diziyi hataları atacak Metin Nesnesi olarak basmanıza izin verilir.

DanielaWaranie onu cevapta belirtildiği üzere - Eğer $ collectionObject içinde $ ürün üzerinde ilerlerken $ öğenin türünü belirtmek için bir yol yoktur: Ekle @return MyEntitiesClassNameetmek current()ve dinlenme Iteratorve ArrayAccess-Kullanılan hangi dönüş değerleri.

Boom! /** @var SomeObj[] $collectionObj */Üzerinden gerek yok foreachve toplama nesnesi ile doğru çalışır, koleksiyon olarak tarif edilen belirli bir yöntemle koleksiyonu döndürmeye gerek yoktur @return SomeObj[].

Tüm IDE'nin desteklediğinden şüphelenmiyorum, ancak PhpStorm'da mükemmel çalışıyor, bu da beni daha mutlu ediyor.

Misal:

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
}

Bu yanıtı yayınlamak için ne kadar faydalı olacaktım

Benim durumumda current()ve yöntemlerin geri kalanı interfacetoplama Abstractsınıfında uygulanır ve sonunda ne tür varlıkların koleksiyonda saklanacağını bilmiyorum.

İşte hile: Soyut sınıfta dönüş türü belirtmeyin, bunun yerine @methodbelirli toplama sınıfının açıklamasında PhpDoc instuction kullanın .

Misal:

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

}

Şimdi, sınıfların kullanımı:

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

Bir kez daha: Tüm IDE'nin desteklemediğinden şüpheleniyorum, ancak PhpStorm destekliyor. Sizinkini deneyin, sonuçları yorumda yayınlayın!

Partiye geç kaldığımı biliyorum, ama son zamanlarda bu sorun üzerinde çalışıyorum. Kabul edilen cevap, doğru olsa, çünkü umut birisi bunu görür değil bunu yapmanın en iyi yolu . En azından PHPStorm'da değil, NetBeans'i test etmedim.

En iyi yol, yerel dizi türlerini kullanmak yerine ArrayIterator sınıfını genişletmektir. Bu, örnek düzeyinde değil, sınıf düzeyinde bir ipucu yazmanıza olanak tanır, yani kodunuz boyunca değil, sadece bir kez PHPDoc'a ihtiyacınız vardır (bu sadece dağınık değildir ve DRY'yi ihlal eder, ancak söz konusu olduğunda da sorunlu olabilir) yeniden düzenleme - PHPStorm'un yeniden düzenleme yaparken PHPDoc'u eksik alışkanlığı vardır)

Aşağıdaki koda bakı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();

Buradaki anahtar, ArrayIterator öğesinden @method MyObj current()devralınan dönüş türünü geçersiz kılan PHPDoc'tur mixed. Sınıfsal özellikleri kullanılarak yineleme zaman bu PHPDoc aracının dahil edilmesi foreach($this as $myObj), o zaman kod tamamlama elde değişken atıfta$myObj->...

Bana göre, bunu başarmanın en iyi yolu (en azından PHP Yazılmış Dizileri tanıtana kadar, eğer yaparlarsa), yinelenen sınıfta yineleyici türünü bildiriyoruz, kod boyunca dağılmış sınıf örnekleri üzerinde değil.

Burada ArrayIterator'ı genişletmek için tam bir çözüm göstermedim, bu nedenle bu tekniği kullanırsanız, şunları da yapmak isteyebilirsiniz:

• Gibi yöntemler için gerekli olan diğer sınıf düzeyindeki phpdoc dahil edin offsetGet($index)venext()
• Akıl sağlığı kontrolünü is_a($object, MyObj::class)yapıcıdan özel bir yönteme taşıyın
• Bu gibi yöntem geçersiz kılmalarından bu (şimdi özel) sağlık kontrolü olarak adlandırın offsetSet($index, $newval)veappend($value)

Problem şu @var sadece tek bir türü gösterebilir - Karmaşık bir formül içermez. "Foo dizisi" için bir sözdiziminiz varsa, neden orada durun ve "dizi dizisi için 2 Foo ve üç Bar" içeren bir sözdizimi eklemiyorsunuz? Öğelerin bir listesinin belki de bundan daha genel olduğunu anlıyorum, ancak kaygan bir eğim.

Şahsen ben @var Foo[]"Foo bir dizi" belirtmek için kullanılan bazı zamanlar var, ama IDE tarafından desteklenmiyor.

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

Çalışan bir şey buldum, hayat kurtarabilir!

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