Skip to content

Wie kann ich auf ein Array/Objekt zugreifen?

Wir überprüfen jedes Schriftstück in unserem Bereich vollständig mit dem Ziel, Ihnen jederzeit die genauesten und aktuellsten Informationen zu zeigen.

Lösung:

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

Arrays

Um auf Array-Elemente zuzugreifen, musst du entweder [] oder, was man nicht so oft sieht, aber auch verwenden kann, ist {}.

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

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

Ein Array zu deklarieren und auf ein Array-Element zuzugreifen sind zwei verschiedene Dinge. Man sollte sie also nicht verwechseln.

Um ein Array zu definieren, kann man verwenden array() oder für PHP >=5.4 [] und Sie weisen ein Array/Element zu oder setzen es. Wenn Sie jedoch auf ein Array-Element mit [] oder {} auf ein Array-Element zugreift, erhält man, wie oben erwähnt, den Wert eines Array-Elements, während man ein Element setzt.

//Declaring an array
$arrayA = array ( /*Some stuff in here*/ );
$arrayB = [ /*Some stuff in here*/ ]; //Only for PHP >=5.4

//Accessing an array element
echo $array[0];
echo $array{0};

Zugriff auf ein Array-Element

Um auf ein bestimmtes Element in einem Array zuzugreifen, kann man einen beliebigen Ausdruck innerhalb des Arrays verwenden [] oder verwenden. {} verwenden, der dann zu dem Schlüssel ausgewertet wird, auf den Sie zugreifen möchten:

$array[(Any expression)]

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

echo $array[0];            //The key is an integer; It accesses the 0's element
echo $array["0"];          //The key is a string; It accesses the 0's element
echo $array["string"];     //The key is a string; It accesses the element with the key 'string'
echo $array[CONSTANT];     //The key is a constant and it gets replaced with the corresponding value
echo $array[cOnStAnT];     //The key is also a constant and not a string
echo $array[$anyVariable]  //The key is a variable and it gets replaced with the value which is in '$anyVariable'
echo $array[functionXY()]; //The key will be the return value of the function

Zugriff auf ein mehrdimensionales Array

Wenn Sie mehrere Arrays ineinander haben, haben Sie einfach ein multidimensionales Array. Um auf ein Array-Element in einem Sub-Array zuzugreifen, muss man einfach mehrere [].

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

Objekte

Um auf eine Objekteigenschaft zuzugreifen, muss man ->.

echo $object->property;

Wenn Sie ein Objekt in einem anderen Objekt haben, müssen Sie nur mehrere -> verwenden, um an die Eigenschaft des Objekts zu gelangen.

echo $objectA->objectB->property;

Anmerkung:

  1. Auch bei einem ungültigen Eigenschaftsnamen muss man aufpassen! Um alle Probleme zu sehen, die mit einem ungültigen Eigenschaftsnamen auftreten können, siehe diese Frage/Antwort. Und besonders dieses, wenn Sie Zahlen am Anfang des Eigenschaftsnamens haben.

  2. Sie können nur auf Eigenschaften mit öffentlicher Sichtbarkeit von außerhalb der Klasse zugreifen. Ansonsten (privat oder geschützt) brauchst du eine Methode oder Reflexion, mit der du den Wert der Eigenschaft abrufen kannst.

Arrays und Objekte

Wenn man nun Arrays und Objekte miteinander vermischt hat, muss man nur schauen, ob man nun auf ein Arrayelement oder eine Objekteigenschaft zugreift und den entsprechenden Operator dafür verwenden.

//Object
echo $object->anotherObject->propertyArray["elementOneWithAnObject"]->property;
    //├────┘  ├───────────┘  ├───────────┘ ├──────────────────────┘   ├──────┘
    //│       │              │             │                          └── property ; 
    //│       │              │             └───────────────────────────── array element (object) ; Use -> To access the property 'property'
    //│       │              └─────────────────────────────────────────── array (property) ; Use [] To access the array element 'elementOneWithAnObject'
    //│       └────────────────────────────────────────────────────────── property (object) ; Use -> To access the property 'propertyArray'
    //└────────────────────────────────────────────────────────────────── object ; Use -> To access the property 'anotherObject'

//Array
echo $array["arrayElement"]["anotherElement"]->object->property["element"];
    //├───┘ ├────────────┘  ├──────────────┘   ├────┘  ├──────┘ ├───────┘
    //│     │               │                  │       │        └── array element ; 
    //│     │               │                  │       └─────────── property (array) ; Use [] To access the array element 'element'
    //│     │               │                  └─────────────────── property (object) ; Use -> To access the property 'property'
    //│     │               └────────────────────────────────────── array element (object) ; Use -> To access the property 'object'
    //│     └────────────────────────────────────────────────────── array element (array) ; Use [] To access the array element 'anotherElement'
    //└──────────────────────────────────────────────────────────── array ; Use [] To access the array element 'arrayElement'

Ich hoffe, das gibt dir eine grobe Vorstellung, wie du auf Arrays und Objekte zugreifen kannst, wenn sie ineinander verschachtelt sind.

Anmerkung:

  1. Ob es sich um ein Array oder ein Objekt handelt, hängt von dem äußersten Teil deiner Variablen ab. Also . [new StdClass] ist eine Array auch wenn es (verschachtelte) Objekte enthält 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().

  1. Lassen Sie sich nicht verwirren, wenn jemand einen anderen Kodierungsstil 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 Schleifen

Wenn du nicht nur auf ein einzelnes Element zugreifen willst, kannst du eine Schleife über dein verschachteltes Array / Objekt ziehen und die Werte einer bestimmten Dimension durchgehen.

Dazu muss man nur auf die Dimension zugreifen, über die man eine Schleife machen will, und kann dann über alle Werte dieser Dimension eine Schleife machen.

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

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

Wenn man eine Schleife über die erste Dimension macht, erhält man alle Werte der ersten Dimension:

foreach($array as $key => $value)

Das bedeutet, dass man hier in der ersten Dimension nur 1 Element mit dem Schlüssel hat($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 eine Schleife über die zweite Dimension machen, erhalten Sie alle Werte der zweiten Dimension:

foreach($array["data"] as $key => $value)

Das bedeutet, dass Sie hier in der zweiten Dimension 3 Elemente mit den Schlüsseln($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 kann man durch jede beliebige Dimension schleifen, egal ob es sich um ein Array oder ein Objekt handelt.

analysieren. var_dump() / print_r() / var_export() Ausgabe

Alle diese 3 Debug-Funktionen geben die gleichen Daten aus, nur in einem anderen Format oder mit einigen Metadaten (z.B. Typ, Größe). Daher möchte ich hier zeigen, wie man die Ausgabe dieser Funktionen lesen muss, um zu wissen/zu erfahren, wie man auf bestimmte Daten aus dem Array/Objekt zugreifen kann.

Eingabe Array:

$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() output:

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

        )

)

var_export() Ausgang:

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

Wie Sie sehen, sind also alle Ausgaben ziemlich ähnlich. Und wenn Sie nun auf den Wert 2 zugreifen wollen, können Sie einfach bei dem Wert selbst anfangen, auf den Sie zugreifen wollen, und sich nach "oben links" vorarbeiten.

1. Wir sehen zunächst, 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,
),

Das bedeutet, wir müssen []/{} verwenden, um auf den Wert 2 mit [1] zugreifen, 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

object(stdClass)#1 (1) {  //var_dump()
  ["property"]=>
    /* Array here */
}

stdClass Object  //print_r()
([property] => /* Array here */
)

stdClass::__set_state(array(  //var_export()
  'property' => 
    /* Array here */
)),

Das heißt, wir müssen -> verwenden, um auf die Eigenschaft des Objekts zuzugreifen, z. B. ->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"]=>
    /* Object & Array here */
}

Array  //print_r()
([key] => 
    /* Object & Array here */
)

array (  //var_export()
  'key' =>
    /* Object & Array here */
)

Da wir wissen, dass wir auf ein Array-Element zugreifen müssen mit []zugreifen müssen, sehen wir hier, dass wir Folgendes verwenden müssen ["key"] um auf das Objekt zuzugreifen. Wir können nun 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 man wissen muss, damit man nicht Stunden damit verbringt, sie zu finden.

  1. "Versteckte" Zeichen

    Manchmal hat man Zeichen in seinen Schlüsseln, die man nicht auf den ersten Blick im Browser sieht. Und dann fragt man sich, warum man auf das Element nicht zugreifen kann. Diese Zeichen können sein: Tabulatoren (t), Zeilenumbrüche (n), Leerzeichen oder html-Tags (z.B.

    , ), usw.

    Wenn Sie sich zum Beispiel die Ausgabe von print_r() und Sie sehen:

    Array ( [key] => HERE ) 
    

    Dann versuchen Sie, auf das Element mit zuzugreifen:

    echo $arr["key"];
    

    Aber Sie erhalten die Meldung:

    Notice: Undefinierter Index: Schlüssel

    Dies ist ein guter Hinweis darauf, dass es einige versteckte Zeichen geben muss, da man auf das Element nicht zugreifen kann, auch wenn die Schlüssel ziemlich korrekt erscheinen.

    Der Trick hier ist die Verwendung von var_dump() + einen Blick in den Quellcode zu werfen! (Alternative: highlight_string(print_r($variable, TRUE));)

    Und plötzlich werden Sie vielleicht Dinge wie diese sehen:

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

    Jetzt wirst du sehen, dass dein Schlüssel ein html-Tag enthält + ein neues Zeilenzeichen, das du vorher nicht gesehen hast, denn print_r() und der Browser hat das nicht angezeigt.

    Wenn du jetzt also versuchst, zu tun:

    echo $arr["nkey"];
    

    Du wirst die gewünschte Ausgabe erhalten:

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

    Sie könnten eine XML-Datei oder einen String in ein Objekt geladen haben, z.B.

     
     
         
            test 
         
    
    

    Wenn Sie nun var_dump() oder print_r() werden Sie sehen:

    SimpleXMLElement Object
    (
        [item] => SimpleXMLElement Object
        (
            Wie kann ich auf ein Array/Objekt zugreifen? => test
        )
    
    )
    

    Sie sehen also, dass Sie die Attribute von title nicht sehen. Wie ich schon sagte, traue niemals der Ausgabe von var_dump() oder print_r() wenn Sie ein XML-Objekt haben. Verwenden Sie immer asXML() um die vollständige XML-Datei/String zu sehen.

    Verwenden Sie also einfach eine der unten aufgeführten Methoden:

    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:

    
     
         
            test 
         
    
    

Für weitere Informationen siehe:

Allgemein (Symbole, Fehler)

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

Probleme mit Eigenschaftsnamen

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

Aus der Frage können wir die Struktur des Eingabe-Arrays nicht erkennen. Vielleicht ist es array ('id' => 10499478683521864, 'date' => '07/22/1983'). Wenn Sie also $demo fragen[0] verwenden Sie undefind index.

Array_values verliert Schlüssel und gibt Array mit zahlreichen Schlüsseln zurück, so dass Array als array(10499478683521864, '07/22/1983'...). Dieses Ergebnis sehen wir in der Frage.

Man kann also die Werte eines Array-Elements auf die gleiche Weise übernehmen

echo array_values($get_user)[0]; // 10499478683521864 

Wenn Ihre Ausgabe von print_r($var) ist z.B.:

    Array ( [demo] => Array ( [0] => 10499478683521864 [1] => 07/22/1983 [2] => [email protected] ) )

dann mach $var['demo'][0]

Wenn die Ausgabe von print_r($var) ist z.B.:

    Array ( [0] => 10499478683521864 [1] => 07/22/1983 [2] => [email protected] )

dann mach $var[0]

Wenn Sie zögern oder bereit sind, unsere Nachrichten einzureichen, können Sie eine Disquisition machen, und wir werden sie gerne interpretieren.



Nutzen Sie unsere Suchmaschine

Suche
Generic filters

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.