Ich habe das folgende Array und wenn ich es tue print_r(array_values($get_user));, bekomme ich:

Array (
          [0] => 10499478683521864
          [1] => 07/22/1983
          [2] => [email protected]
          [3] => Alan [4] => male
          [5] => Malmsteen
          [6] => https://www.facebook.com  app_scoped_user_id/1049213468352864/
          [7] => stdClass Object (
                   [id] => 102173722491792
                   [name] => Jakarta, Indonesia
          )
          [8] => id_ID
          [9] => El-nino
          [10] => Alan El-nino Malmsteen
          [11] => 7
          [12] => 2015-05-28T04:09:50+0000
          [13] => 1
        ) 

Ich habe versucht, wie folgt auf das Array zuzugreifen:

echo $get_user[0];

Aber das zeigt mir:

undefiniert 0

Hinweis:

Ich bekomme dieses Array aus dem Facebook SDK 4 , daher kenne ich die ursprüngliche Array-Struktur nicht.

Wie kann ich als Beispiel auf den Wert [email protected]aus dem Array zugreifen ?

Zugriff auf ein arrayoder objectSie, wie Sie zwei verschiedene Operatoren verwenden.

Arrays

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};
//Both are equivalent and interchangeable

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"]
         // ├─────────────┘  ├──────────────┘  ├────────────────────────────┘
         // │                │                 └── 3rd Array dimension;
         // │                └──────────────────── 2d  Array dimension;
         // └───────────────────────────────────── 1st Array dimension;

Objekte

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:

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 begegnen können, lesen Sie diese Frage / Antwort . Und besonders dieses, wenn Sie Zahlen am Anfang des Eigenschaftsnamens haben.

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

1. 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().

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 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 (  //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:

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

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

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

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

2. 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();  //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-Analyse- / Syntaxfehler; 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?

Aus der Frage können wir die Struktur des Eingabearrays nicht erkennen. Es vielleicht array ('id' => 10499478683521864, 'date' => '07/22/1983'). Wenn Sie also $ demo [0] fragen, verwenden Sie den Index undefind.

Array_values ​​verlor Schlüssel und gab Array mit zahlreichen Schlüsseln zurück, die Array als array(10499478683521864, '07/22/1983'...). Dieses Ergebnis sehen wir in der Frage.

Sie können also auf die gleiche Weise Werte für Array-Elemente verwenden

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

Wenn Ihre Ausgabe von print_r($var)zB ist:

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

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

Wenn die Ausgabe von print_r($var)zB ist:

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

dann mach $var[0]

Ich habe eine kleine Funktion für den Zugriff auf Eigenschaften in Arrays oder Objekten geschrieben. Ich benutze es ziemlich oft und finde es ziemlich praktisch

/**
 * Access array or object values easily, with default fallback
 */
if( ! function_exists('element') )
{
  function element( &$array, $key, $default = NULL )
  {
    // Check array first
    if( is_array($array) )
    {
      return isset($array[$key]) ? $array[$key] : $default;
    }

    // Object props
    if( ! is_int($key) && is_object($array) )
    {
      return property_exists($array, $key) ? $array->{$key} : $default;
    }

    // Invalid type
    return NULL;
  }
}

Sie können verwenden

$ar = (array) $get_user;

dann können Sie arra-weise auf ihre Indizes zugreifen:

echo $ar[0];