Zugriff auf ein arrayoder objectSie, wie Sie zwei verschiedene Operatoren verwenden.
Um auf Array-Elemente zugreifen zu können, müssen Sie entweder verwenden []oder Sie sehen nicht so viel, aber Sie können auch verwenden {}.
echo $array[0];
echo $array{0};
Unterschied zwischen dem Deklarieren eines Arrays und dem Zugriff auf ein Array-Element
Das Definieren eines Arrays und der Zugriff auf ein Array-Element sind zwei verschiedene Dinge. Also nicht verwechseln.
Zum Definieren eines Arrays können Sie verwenden array() oder für PHP> = 5.4 verwenden []und Sie ordnen / setzen ein Array / -Element. Während, wenn Sie mit []oder auf ein Array-Element zugreifen{} wie oben erwähnt Sie den Wert eines Array-Elements, das dem Festlegen eines Elements entgegengesetzt ist.
// Deklarieren Ein Array
$ arrayA = array ( / * Einige Sachen hier * / ) ;
$ arrayB = [ / * Einige Sachen hier * / ] ; // Nur für PHP> = 5.4
// Zugriff ein Array-Element
echo $ array [ 0 ] ;
echo $ array { 0 } ;
Zugriff auf Array-Element
Um auf ein bestimmtes Element in einem Array zuzugreifen, können Sie einen beliebigen Ausdruck in []oder verwenden{} die dann wertet der Schlüssel 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 [ 0 ]; // Der Schlüssel ist eine ganze Zahl ; Es greift auf das Element 0 zu
echo $ array [ "0" ]; // Der Schlüssel ist eine Zeichenfolge ; Es greift auf das Element 0 zu
echo $ array [ "string" ]; // Der Schlüssel ist a Zeichenfolge ; Es greift mit dem Schlüssel 'string' auf das Element zu
echo $ array [ CONSTANT ]; // Der Schlüssel ist eine Konstante und wird durch den entsprechenden Wert ersetzt
echo $ array [ cOnStAnT ]; // Der Schlüssel ist auch eine Konstante und kein String
echo $ array [ $ anyVariable ] // Der Schlüssel ist eine Variable und wird durch den Wert in '$ anyVariable' ersetzt.
echo $ array [ functionXY () ]; // Der Schlüssel ist der Rückgabewert der Funktion
Zugriff auf mehrdimensionale Arrays
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"]
Um auf eine Objekteigenschaft zuzugreifen, müssen Sie verwenden ->.
echo $ object -> property;
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:
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 begegnen können, lesen Sie diese Frage / Antwort . Und besonders dieses, wenn Sie Zahlen am Anfang des Eigenschaftsnamens haben.
Sie können nur von außerhalb der Klasse auf Objekte mit öffentlicher Sichtbarkeit zugreifen . Andernfalls (privat oder geschützt) benötigen Sie eine Methode oder Reflexion, mit der Sie den Wert der Eigenschaft ermitteln können.
Arrays & Objekte
Wenn Sie nun Arrays und Objekte miteinander gemischt haben, müssen Sie nur noch prüfen, ob Sie jetzt auf ein Array-Element oder eine Objekteigenschaft zugreifen und den entsprechenden Operator dafür verwenden.
//Objekt
echo $ object-> anotherObject-> propertyArray ["elementOneWithAnObject"] -> property;
// ├────┘ ├───────────┘ ├───────────┘ ├─────────────── ───────┘ ├──────┘
// │ │ │ │ └ property Eigenschaft;
// element │ │ └ ────────────────────────────── Arrayelement (Objekt); Verwenden Sie -> Um auf die Eigenschaft 'Eigenschaft' zuzugreifen
// │ │ └───────────────────────────────────────────── Array ( Eigentum) ; Verwenden Sie [], um auf das Array-Element 'elementOneWithAnObject' zuzugreifen.
// │ │ ───────────────────────────────────────────────── ───────────── Eigenschaft (Objekt); Verwenden Sie ->, um auf die Eigenschaft 'propertyArray' zuzugreifen.
// └────────────────────────────────────────────────── ──────────────────── Objekt; Verwenden Sie ->, um auf die Eigenschaft 'anotherObject' zuzugreifen.
// Array
echo $ array ["arrayElement"] ["anotherElement"] -> object-> property ["element"];
// ├───┘ ├─────────────┘ ├──────────────┘ ├────┘ ├────── ┘ ├───────┘
// element │ │ │ │ └ Array-Element;
// (│ │ │ └─────────── Eigenschaft (Array); Verwenden Sie [], um auf das Array-Element 'element' zuzugreifen.
// (│ │ └──────────────────── Eigenschaft (Objekt); Verwenden Sie -> Um auf die Eigenschaft 'Eigenschaft' zuzugreifen
// │ │ └──────────────────────────────────────── Arrayelement (Objekt); Verwenden Sie ->, um auf die Eigenschaft 'Objekt' zuzugreifen.
// │ │ ───────────────────────────────────────────────── ──────── Array-Element (Array); Verwenden Sie [], um auf das Array-Element 'anotherElement' zuzugreifen.
// └────────────────────────────────────────────────── ────────────── Array; Verwenden Sie [], um auf das Array-Element 'arrayElement' zuzugreifen.
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:
Ob es als Array oder Objekt bezeichnet wird, hängt vom äußersten Teil Ihrer Variablen ab. Dies [new StdClass]gilt auch für ein Array, selbst wenn es (verschachtelte) Objekte enthält, und $object->property = array();für ein Objekt, selbst wenn es (verschachtelte) Arrays enthält.
Und wenn Sie nicht sicher sind, ob Sie ein Objekt oder Array haben, verwenden Sie einfach gettype().
Lassen Sie sich nicht verwirren, wenn jemand einen anderen Codierungsstil als Sie verwendet:
echo $object->anotherObject->propertyArray["elementOneWithAnObject"]->property;
echo $object->
anotherObject
->propertyArray
["elementOneWithAnObject"]->
property;
echo $array["arrayElement"]["anotherElement"]->object->property["element"];
echo $array["arrayElement"]
["anotherElement"]->
object
->property["element"];
Arrays, Objekte und Schleifen
Wenn Sie nicht nur auf ein einzelnes Element zugreifen möchten, können Sie Ihr verschachteltes Array / Objekt durchlaufen 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 alle Werte dieser Dimension durchlaufen.
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:
foreach ( $ array als $ key => $ value)
Bedeutet hier in der ersten Dimension, dass Sie nur 1 Element mit dem Schlüssel ( $key) dataund dem Wert ( $value) haben würden:
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:
foreach ( $ array ["data"] als $ key => $ value)
Mittel hier in der zweiten Dimension Sie 3 Element mit den Tasten haben würden ( $key) 0, 1, 2und die Werte ( $value):
stdClass Object (
[propertyXY] => 1
)
stdClass Object (
[propertyXY] => 2
)
stdClass Object (
[propertyXY] => 3
)
Und damit können Sie jede gewünschte Dimension durchlaufen, egal ob es sich um ein Array oder ein Objekt handelt.
Alle diese 3 Debug-Funktionen geben dieselben Daten nur in einem anderen Format oder mit einigen Metadaten (z. B. Typ, Größe) aus. 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.
Eingabearray:
$array = [
"key" => (object) [
"property" => [1,2,3]
]
];
var_dump() Ausgabe:
array(1) {
["key"]=>
object(stdClass)
["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 oben links arbeiten.
1. Wir sehen zuerst, dass sich der Wert 2 in einem Array mit dem Schlüssel 1 befindet
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 auf den Wert 2 mit zuzugreifen [1], da der Wert den Schlüssel / Index 1 hat.
2. Als nächstes sehen wir, dass das Array einer Eigenschaft mit der Eigenschaft name eines Objekts zugewiesen ist
object (stdClass) # 1 (1) { // var_dump ()
["property"] =>
/ * Array hier * /
}}
stdClass- Objekt // print_r ()
(
[Eigenschaft] => / * Array hier * /
)
stdClass :: __ set_state ( array (// var_export ()
'property' =>
/ * 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 verwenden müssen ->property[1].
3. Und am Ende sehen wir, dass das äußerste ein Array ist
array (1) { // var_dump ()
["key"] =>
/ * Objekt & Array hier * /
}}
Array // print_r ()
(
[Schlüssel] =>
/ * Objekt & Array hier * /
)
array ( // var_export ()
'key' =>
/ * Objekt & Array hier * /
)
Da wir wissen, dass wir mit auf ein Array-Element zugreifen müssen [], sehen wir hier, dass wir verwenden müssen, um ["key"]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
Lass dich nicht von PHP trollen!
Es gibt ein paar Dinge, die Sie wissen müssen, damit Sie nicht stundenlang damit verbringen, sie zu finden.
"Versteckte" Zeichen
Manchmal haben Sie Zeichen in Ihren Schlüsseln, die Sie beim ersten Blick im Browser nicht sehen. Und dann fragen Sie sich, warum Sie nicht auf das Element zugreifen können. Diese Zeichen können sein: Registerkarten ( \t), neue Linien ( \n), Leerzeichen oder HTML - Tags (zB </p>, <b>) usw.
Als Beispiel, wenn Sie sich die Ausgabe von ansehen print_r()und 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 einige versteckte Zeichen vorhanden sein müssen, da Sie nicht auf das Element zugreifen können, selbst wenn die Schlüssel ziemlich korrekt erscheinen.
Der Trick hier ist, var_dump()+ in Ihren Quellcode zu schauen! (Alternative: highlight_string(print_r($variable, TRUE));)
Und plötzlich werden Sie vielleicht solche Dinge sehen:
array(1) {
["</b>
key"]=>
string(4) "HERE"
}
Jetzt werden Sie sehen, dass Ihr Schlüssel ein HTML-Tag + ein neues Zeilenzeichen enthält, das Sie seitdem überhaupt nicht gesehen haben, print_r()und der Browser hat das nicht angezeigt.
Wenn Sie also versuchen, Folgendes zu tun:
echo $arr["</b>\nkey"];
Sie erhalten die gewünschte Ausgabe:
HERE
Vertrauen Sie niemals der Ausgabe von print_r()oder var_dump()wenn Sie sich XML ansehen
Möglicherweise ist eine XML-Datei oder eine Zeichenfolge 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 jetzt verwenden var_dump()oder print_r()Sie werden sehen:
SimpleXMLElement Object
(
[item] => SimpleXMLElement Object
(
[title] => test
)
)
Wie Sie sehen können, sehen Sie die Attribute des Titels nicht. Also, 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.
Verwenden Sie also einfach eine der folgenden Methoden:
echo $xml->asXML();
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)
Probleme mit Eigenschaftsnamen