PHP-Casting-Variable als Object-Typ in der foreach-Schleife

Innerhalb des folgenden code $quiz_object->personalities enthält ein array von Personality Objekte.

//Loop through each personality that exists for the quiz
foreach($quiz_object->personalities AS $existing_personality)
{

    //Show all of the existing personalities
    echo $existing_personality->GetQuizMakerPersonalityHTML();
}

Wie kann ich "cast" (ich denke, das ist das richtige Wort) meine variable $existing_personality innerhalb der foreach-Schleife als Objekt-Typ?

Möchte ich dies tun, so dass wenn ich $existing_personality-> bekomme ich die Liste der öffentlichen Funktionen, die verfügbar für dieses Objekt geben.

UPDATE

Im moment Zend Studio nicht wissen, ich bin einer Schleife durch ein array von Personality Objekte innerhalb der Schleife nur denkt, es ist eine standard-variable. Jedoch, es ist ein geben und mein code funktioniert bestens. Ich will nur die IDE Hinweise auf meine variable innerhalb der foreach-Schleife.

Nur so, ich bin klar, die Hinweise erscheinen für jedes andere Objekt, wenn ich:

$personality_object = new Personality();

//I get the IDE hints here
echo $personality_object->MyFunction();

Aber sobald ich in einer foreach-Schleife, Zend hat keine Möglichkeit zu wissen, dass ich die Schleife durch ein array von Objekten.

Dies ist, wie die Reihe von Persönlichkeiten definiert zunächst innerhalb meiner Personality Objekt:

class Personality
{

    //Array of Personality objects
    public $personalities = array();

}

InformationsquelleAutor der Frage Luke | 2012-09-13

53

Es hängt viel von der IDE Sie verwenden.

In Netbeans und IntelliJ, die Sie verwenden können @var in einem Kommentar:
```
/* @var $variable ClassName */
$variable->
```
Wird die IDE wissen jetzt, dass $variable ist von der Klasse ClassName und Hinweis nach der ->.

Können Sie es ausprobieren in Ihren eigenen IDE-als auch.

Können Sie auch eine @return Anmerkungen im getPersonalities() - Methode, die besagt, dass die Rendite einer ClassName[]also ein array von ClassName-Objekte:
```
/**
 * Returns a list of Personality objects
 * @return Personality[]
 */
function getPersonalities() {
    return $this->personalities;
}
```
hängt dies auch davon ab, wie deine IDE ist die Interpretation dieser Art des hinting.

Verwenden diese in foreach-Schleifen, die Sie tun können 1:
```
/* @var $existing_personality Personality */
foreach( $quiz_object->personalities as $existing_personality ){
}
```
oder 2:
```
foreach( $quiz_object->getPersonalities() as $existing_personality ){
}
```
beide sollten aktivieren Sie die IDE-hinting, wenn Ihre IDE-freundlich ist.

Als eine zusätzliche Anmerkung, wenn Sie dies nutzen wollen, ist es innen eine eigene Klasse, die Sie verwenden können, die gleiche Signatur bei der Deklaration einer Klasse, variable:
```
class MyClass
{ 

    /** 
    * @var ClassName[] $variable List of ClassName objects. 
    */ 
    var $variable;

}
```
InformationsquelleAutor der Antwort Krycke
7

dachte, ich würde werfen in der es für diejenigen, die sich mit phpStorm.

Fand ich die Art und Weise, um die IDE-auto-Auffüllen der Methoden für ein Objekt, indem Sie eine schnelle, wenn check-beforeheand überprüfen, dass das Objekt existiert und dass die $var wurde eine Instanz der besagten Objekt.

Beispiel:
```
            foreach ($objArray as $obj) {
            if (is_object($obj) && $obj instanceof DataObject) {

                $obj->thisMethodShouldBeAvailableInPHPStormNow();

            }
```
Fand diese Frage bei der Suche nach einem besseren Weg, aber die oben genannten arbeiten für mich.

Prost!

InformationsquelleAutor der Antwort lordvig

Können Sie immer rufen, um eine separate Funktion innerhalb der foreach-Schleife, und deklarieren Sie die Klasse in der Deklaration der Funktion. Dies könnte auch den Vorteil haben, dass Sie die Wiederverwendung dieser code an anderer Stelle. Zum Beispiel in der Funktion getPriceFromProduct unten sehen Sie, wie erkläre ich der Klasse von $Produkt zu Produkt.

Ich natürlich Zustimmen, es wäre schön, nicht zu tun es auf diese Weise, aber hey, es funktioniert.

class ProductBundle {

  private $products; //buy this
  public function get_products() { return $this->products; }
  public function add_product($product) { $this->products[] = $product; }

  public function get_price() {
        $products = $this->get_products();
        $prices = array();
        foreach($products as $product) {
            $prices[] = $this->getPriceFromProduct($product);
        }
        return array_sum($prices);
    }

    private function getPriceFromProduct(Product $product) {
        $price = $product->get_price();
        return $price;
    }

InformationsquelleAutor der Antwort CommaToast

3

Ich weiß, dieser Beitrag ist alt, aber ich denke, das kann jemand helfen:

In PhpStorm funktioniert auf diese Weise, vielleicht auch in anderen Menschen.
```
/**
 * @param ClassName[] $variables
 */
public function loopFunction($variables){
    foreach ($variables as $variable) {
        echo $variable->functionName();
    }
}
```
InformationsquelleAutor der Antwort Daniel Guerrero
1

Wenn Sie möchten, dass der tatsächliche Typ-Deklarationen im code, im Gegensatz zu Kommentaren, die könnte auch abgeholt werden unterschiedlich, je nach IDE, können Sie die array_* Funktionen, zum Beispiel array_walk.
```
array_walk($quiz_object->personalities, function (Personality $p) {
    echo $existing_personality->GetQuizMakerPersonalityHTML();
});
```
InformationsquelleAutor der Antwort jleeothon
-1

PHP ist nicht eine stark typisierten Sprache wie C#

Dies ist völlig in Ordnung in PHP
```
$i = 0;
$i = 'Hello World';
echo $i;
```
Gibt es eine Möglichkeit, 'cast' - Variablen wie diese:
```
$i = '12.3';
echo (int)$i;
```
Für Objekte, es gibt keine build-in-Methode "cast"

InformationsquelleAutor der Antwort JvdBerg

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.