Wie kann ich auf ein Array / Objekt zugreifen?

Um auf ein array oder object zuzugreifen, verwenden Sie zwei verschiedene Operatoren.

Arrays

Um auf Array-Elemente zuzugreifen, müssen Sie entweder [] Oder {} Verwenden.

echo $array[0];
echo $array{0};
//Both are equivalent and interchangeable

Unterschied zwischen der Deklaration eines Arrays und dem Zugriff auf ein Array-Element

Das Definieren eines Arrays und der Zugriff auf ein Array-Element sind zwei verschiedene Dinge. Verwechseln Sie sie also nicht.

Um ein Array zu definieren, können Sie array() oder PHP> = 5.4 [] Verwenden und ein Array/-Element zuweisen/setzen Wenn Sie wie oben erwähnt mit [] oder {} auf ein Array-Element zugreifen, erhalten Sie den Wert eines Array-Elements im Gegensatz zum Festlegen eines Elements.

//Deklarieren ein Array 
 $ arrayA = array ( / * Einige Sachen hier * / ); 
 $ arrayB = [ / * Einige Sachen hier * / ]; // Nur für PHP> = 5.4
 
 //Zugreifen ein Array-Element 
 echo $ array[]; 
 echo $ array{}; 

Greifen Sie auf das Array-Element zu

Um auf ein bestimmtes Element in einem Array zuzugreifen, können Sie einen beliebigen Ausdruck in [] Oder {} Verwenden, der dann den Schlüssel ergibt, auf den Sie zugreifen möchten:

$ array [(Beliebiger Ausdruck)] 

Achten Sie also darauf, welchen Ausdruck Sie als Schlüssel verwenden und wie er von PHP interpretiert wird:

echo $ array []; // Der Schlüssel ist ein ganze Zahl; Es greift auf das Element der 0 zu 
 Echo $ array ["0"]; // Der Schlüssel ist a zeichenfolge; Es greift auf das Element der 0 zu 
 Echo $ array ["string"]; // Der Schlüssel ist a zeichenfolge; Der Zugriff auf das Element erfolgt mit dem Schlüssel 'string' 
 Echo $ array [KONSTANTE]; // Der Schlüssel ist a konstante und es wird durch den entsprechenden Wert ersetzt 
 echo $ array [konstante]; // Der Schlüssel ist auch ein konstante und kein String 
 echo $ array [$ anyVariable] // Der Schlüssel ist a variable und es wird durch den Wert ersetzt, der sich in '$ anyVariable' befindet 
 echo $ array [functionXY ()]; // Der Schlüssel wird der sein rückgabewert der Funktion 

Greifen Sie auf mehrdimensionale Arrays zu

Wenn Sie mehrere Arrays ineinander haben, haben Sie einfach ein mehrdimensionales Array. Um auf ein Array-Element in einem Sub-Array zuzugreifen, müssen Sie nur mehrere [] Verwenden.

echo $array["firstSubArray"]["SecondSubArray"]["ElementFromTheSecondSubArray"]
         // ├─────────────┘  ├──────────────┘  ├────────────────────────────┘
         // │                │                 └── 3rd Array dimension;
         // │                └──────────────────── 2d  Array dimension;
         // └───────────────────────────────────── 1st Array dimension;

Objekte

Um auf eine Objekteigenschaft zuzugreifen, müssen Sie -> Verwenden.

echo $ object->eigentum;

Wenn Sie ein Objekt in einem anderen Objekt haben, müssen Sie nur mehrere -> Verwenden, um zu Ihrer Objekteigenschaft zu gelangen.

echo $objectA->objectB->property;

Hinweis:

1. Sie müssen auch vorsichtig sein, wenn Sie einen ungültigen Eigenschaftsnamen haben! Um alle Probleme zu sehen, denen Sie mit einem ungültigen Eigenschaftsnamen gegenüberstehen, lesen Sie diese Frage/Antwort . Und besonders dieses wenn Sie Zahlen am Anfang des Eigenschaftsnamens haben.

2. Sie können nur mit public visible von außerhalb der Klasse auf Eigenschaften zugreifen. Andernfalls (privat oder geschützt) benötigen Sie eine Methode oder Reflektion, mit der Sie den Wert der Eigenschaft ermitteln können.

Arrays & Objekte

Wenn Sie nun Arrays und Objekte miteinander vermischt haben, müssen Sie nur noch nachsehen, ob Sie jetzt auf ein Array-Element oder eine Objekteigenschaft zugreifen und den entsprechenden Operator dafür verwenden.

//Object[.____.₱echo $ object-> anotherObject-> propertyArray ["elementOneWithAnObject"] -> property; 
 // ├────┘ ├────────── ─┘ ─┘ ├──────────────────────┘ ├──────┘ 
 // │ │ │ │ │ Eigenschaft; 
 // │ │ │ └───────────────────────────── Array-Element (Objekt); Verwenden -> Zugriff auf die Eigenschaft 'property' 
 // │ │ └───────────────────────────────── ────────── array (Eigenschaft); Verwenden [] Zugriff auf das Array-Element 'elementOneWithAnObject' 
 // │ └───────────────────────────────── ───────────────────────── Eigentum (Objekt); Verwenden -> Zugriff auf die Eigenschaft 'propertyArray' 
 // └─────────────────────────────────── ─────────────────────────────── Objekt; Verwenden -> Um auf die Eigenschaft 'anotherObject' 
 
 
 // Array 
 Zuzugreifen, geben Sie $ array ["arrayElement"] ["anotherElement"] -> object-> property [ "Element"]; 
 // ├───┘ ├────────────┘ ├──────────────┘ ├── ──┘ ──┘ ├───────┘ 
 // │ │ │ │ │ └── Array-Element; 
 // │ │ │ │ └─────────── Eigenschaft (Array); Verwenden [] Zugriff auf das Array-Element 'element' 
 // │ │ │ └─────────────────── property (object); Verwenden -> Zugriff auf die Eigenschaft 'property' 
 // │ │ └───────────────────────────────── ───── Array-Element (Objekt); Verwenden -> Zugriff auf die Eigenschaft 'Objekt' 
 // │ └────────────────────────────────── ──────────────────── Array-Element (Array); Verwenden [] Zugriff auf das Array-Element 'anotherElement' 
 // └────────────────────────────────── ────────────────────────── Array; Verwenden [] Zugriff auf das Array-Element 'arrayElement' 
 

Ich hoffe, dies gibt Ihnen eine ungefähre Vorstellung davon, wie Sie auf Arrays und Objekte zugreifen können, wenn diese ineinander verschachtelt sind.

Hinweis:

1. Ob es sich um ein Array oder ein Objekt handelt, hängt vom äußersten Teil Ihrer Variablen ab. Also [new StdClass] ist ein Array , auch wenn es hat (verschachtelte) Objekte in ihm und $object->property = array(); ist ein Objekt auch wenn es (verschachtelte) Arrays enthält.

   Und wenn Sie nicht sicher sind, ob Sie ein Objekt oder ein Array haben, verwenden Sie einfach gettype() .

2. Lassen Sie sich nicht verwirren, wenn jemand einen anderen Codierungsstil als Sie verwendet:

   //Both methods/styles work and access the same data
   echo $object->anotherObject->propertyArray["elementOneWithAnObject"]->property;
   echo $object->
           anotherObject
           ->propertyArray
           ["elementOneWithAnObject"]->
           property;
   
   //Both methods/styles work and access the same data
   echo $array["arrayElement"]["anotherElement"]->object->property["element"];
   echo $array["arrayElement"]
        ["anotherElement"]->
            object
      ->property["element"];
   

Arrays, Objekte und Loops

Wenn Sie nicht nur auf ein einzelnes Element zugreifen möchten, können Sie eine Schleife über Ihr verschachteltes Array/Objekt ausführen und die Werte einer bestimmten Dimension durchgehen.

Dazu müssen Sie nur auf die Dimension zugreifen, über die Sie eine Schleife ausführen möchten, und dann können Sie über alle Werte dieser Dimension eine Schleife ausführen.

Als Beispiel nehmen wir ein Array, aber es könnte auch ein Objekt sein:

Array (
    [data] => Array (
            [0] => stdClass Object (
                    [propertyXY] => 1
                )    
            [1] => stdClass Object (
                    [propertyXY] => 2
                )   
            [2] => stdClass Object (
                    [propertyXY] => 3                   
               )    
        )
)

Wenn Sie die erste Dimension durchlaufen, erhalten Sie alle Werte aus der ersten Dimension:

für jeden($ array als $ key => $ value) 

Bedeutet hier in der ersten Dimension nur 1 Element mit dem Schlüssel ($key) data und dem Wert ($value):

Array (  //Key: array
    [0] => stdClass Object (
            [propertyXY] => 1
        )
    [1] => stdClass Object (
            [propertyXY] => 2
        )
    [2] => stdClass Object (
            [propertyXY] => 3
        )
)

Wenn Sie die zweite Dimension durchlaufen, erhalten Sie alle Werte aus der zweiten Dimension:

für jeden($ array ["data"] als $ key => $ value) 

Bedeutet hier in der zweiten Dimension 3 Elemente mit den Tasten ($key) 0, 1, 2 Und den Werten ($value):

stdClass Object (  //Key: 0
    [propertyXY] => 1
)
stdClass Object (  //Key: 1
    [propertyXY] => 2
)
stdClass Object (  //Key: 2
    [propertyXY] => 3
)

Und damit können Sie jede gewünschte Dimension durchlaufen, egal ob es sich um ein Array oder ein Objekt handelt.

Analysiere var_dump() / print_r() / var_export() Ausgabe

Alle diese 3 Debug-Funktionen geben dieselben Daten aus, nur in einem anderen Format oder mit einigen Metadaten (z. B. Typ, Größe). Hier möchte ich zeigen, wie Sie die Ausgabe dieser Funktionen lesen müssen, um zu wissen, wie Sie auf bestimmte Daten von Ihrem Array/Objekt zugreifen können.

Eingangsarray:

$array = [
    "key" => (object) [
        "property" => [1,2,3]
    ]
];

var_dump() Ausgabe:

array(1) {
  ["key"]=>
  object(stdClass)#1 (1) {
    ["property"]=>
    array(3) {
      [0]=>
      int(1)
      [1]=>
      int(2)
      [2]=>
      int(3)
    }
  }
}

print_r() Ausgabe:

Array
(
    [key] => stdClass Object
        (
            [property] => Array
                (
                    [0] => 1
                    [1] => 2
                    [2] => 3
                )

        )

)

var_export() Ausgabe:

array (
  'key' => 
  stdClass::__set_state(array(
     'property' => 
    array (
      0 => 1,
      1 => 2,
      2 => 3,
    ),
  )),
)

Wie Sie sehen können, sind alle Ausgänge ziemlich ähnlich. Und wenn Sie jetzt auf den Wert 2 zugreifen möchten, können Sie einfach mit dem Wert selbst beginnen, auf den Sie zugreifen möchten, und sich nach links oben arbeiten.

1. Wir sehen zuerst, dass der Wert 2 in einem Array mit dem Schlüssel 1 steht

array (3) {  //var_dump()
 [0] => 
 int (1) 
 [1] => 
 Int (2)
 [2] => 
 Int (3) 
}

Array  //print_r()[.____.‹(
 [0] => 1 
 [1] => 2
 [2] => 3 
)

array (  //var_export()
 0 => 1, 
 1 => 2,
 2 => 3, 
),

Dies bedeutet, dass wir []/{} Verwenden müssen, um mit [1] auf den Wert 2 zuzugreifen. da der Wert den Schlüssel/Index 1 hat.

2. Als nächstes sehen wir, dass das Array einer Eigenschaft mit der Namenseigenschaft eines Objekts zugewiesen ist

objekt(stdClass) # 1 (1) {  //var_dump()
 ["Eigentum"]=> 
/* Array hier */
}

stdClass Objekt  //print_r()
([Eigentum] =>/* Array hier */
)

stdClass:: __ set_state(array (//var_export()
 'Eigentum' => 
/* Array hier */
)),

Dies bedeutet, dass wir -> Verwenden müssen, um auf die Eigenschaft des Objekts zuzugreifen, z. ->property.

Bis jetzt wissen wir also, dass wir ->property[1] verwenden müssen.

3. Und am Ende sehen wir, dass das Äußerste ein Array ist

array (1) {  //var_dump()
 ["Schlüssel"]=> 
/* Objekt & Array hier */
}

Array  //print_r()
([Schlüssel] => 
/* Objekt & Array hier */
)

array (  //var_export()
 'Schlüssel' => 
/* Objekt & Array hier */
)

Da wir wissen, dass wir mit [] Auf ein Array-Element zugreifen müssen, müssen wir hier ["key"], um auf das Objekt zuzugreifen. Wir können jetzt alle diese Teile zusammenfügen und schreiben:

echo $array["key"]->property[1];

Und die Ausgabe wird sein:

2

Lassen Sie sich nicht von PHP trollen!

Es gibt ein paar Dinge, die Sie wissen müssen, damit Sie nicht stundenlang damit verbringen, sie zu finden.

1. "Versteckte" Zeichen

   Manchmal haben Sie Zeichen in Ihren Schlüsseln, die Sie nicht auf den ersten Blick im Browser sehen. Und dann fragst du dich, warum du nicht auf das Element zugreifen kannst. Diese Zeichen können sein: Tabulatoren (\t), Neue Zeilen (\n), Leerzeichen oder HTML-Tags (z. B. </p>, <b>) Usw.

   Ein Beispiel, wenn Sie sich die Ausgabe von print_r() ansehen und Folgendes sehen:

   Array ( [key] => HERE ) 
   

   Dann versuchen Sie auf das Element zuzugreifen mit:

   echo $arr["key"];
   

   Aber Sie bekommen die Nachricht:

   Hinweis: Undefinierter Index: Schlüssel

   Dies ist ein guter Hinweis darauf, dass es einige versteckte Zeichen geben muss, da Sie nicht auf das Element zugreifen können, auch wenn die Tasten ziemlich korrekt zu sein scheinen.

   Der Trick hier ist, var_dump() + in deinen Quellcode zu schauen! (Alternative: highlight_string(print_r($variable, TRUE));)

   Und auf einmal werden Sie vielleicht folgendes sehen:

   array(1) {
     ["</b>
   key"]=>
     string(4) "HERE"
   }
   

   Jetzt werden Sie sehen, dass Ihr Schlüssel ein HTML-Tag enthält + ein neues Zeilenzeichen, das Sie seit print_r() und dem Browser nicht mehr gesehen haben.

   Wenn Sie also versuchen, Folgendes zu tun:

   echo $arr["</b>\nkey"];
   

   Sie erhalten Ihre gewünschte Ausgabe:

   HERE
   

2. Vertrauen Sie niemals der Ausgabe von print_r() oder var_dump(), wenn Sie sich XML ansehen

   Möglicherweise wird eine XML-Datei oder ein XML-String in ein Objekt geladen, z.

   <?xml version="1.0" encoding="UTF-8" ?> 
   <rss> 
       <item> 
           <title attribute="xy" ab="xy">test</title> 
       </item> 
   </rss>
   

   Wenn Sie nun var_dump() oder print_r() verwenden, sehen Sie:

   SimpleXMLElement Object
   (
       [item] => SimpleXMLElement Object
       (
           [title] => test
       )
   
   )
   

   Wie Sie sehen, sehen Sie die Attribute des Titels nicht. Wie gesagt, vertraue niemals der Ausgabe von var_dump() oder print_r(), wenn du ein XML-Objekt hast. Verwenden Sie immer asXML() , um die vollständige XML-Datei/Zeichenfolge anzuzeigen.

   Wenden Sie einfach eine der folgenden Methoden an:

   echo $xml->asXML();  //And look into the source code
   
   highlight_string($xml->asXML());
   
   header ("Content-Type:text/xml");
   echo $xml->asXML();
   

   Und dann erhalten Sie die Ausgabe:

   <?xml version="1.0" encoding="UTF-8"?>
   <rss> 
       <item> 
           <title attribute="xy" ab="xy">test</title> 
       </item> 
   </rss>
   

Weitere Informationen finden Sie unter:

Allgemein (Symbole, Fehler)

• Referenz - Was bedeutet dieses Symbol in PHP?
• Referenz - Was bedeutet dieser Fehler in PHP?
• PHP Parse/Syntax Errors; und wie man sie löst?

Probleme mit Eigenschaftsnamen

• Wie kann ich auf eine Eigenschaft mit einem ungültigen Namen zugreifen?
• Wie greife ich auf Objekteigenschaften mit Namen wie Ganzzahlen zu?