如何访问阵列/对象？

Question

我有以下数组，当我做print_r（array_values（$get_user））；，我得到：

Array (
          [0] => 10499478683521864
          [1] => 07/22/1983
          [2] => [e-mail]
          [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
        ) 

我尝试按如下方式访问阵列：

echo $get_user[0];

但这让我明白：

未定义的0

注：

我从Facebook SDK 4中获得了这个数组，所以我不知道最初的数组结构。

作为示例，我如何访问值[e-mail]来自阵列？

Answer 1

匿名用户

如果您的打印（$var）输出为：

    Array ( [demo] => Array ( [0] => 10499478683521864 [1] => 07/22/1983 [2] => [e-mail] ) )

然后执行$var['demo'][0]

如果打印（$var）的输出为：

    Array ( [0] => 10499478683521864 [1] => 07/22/1983 [2] => [e-mail] )

然后执行$var[0]

Answer 2

从这个问题中我们看不到输入数组的结构。它可能数组（'id'=

Array_为丢失的键赋值，并返回包含多个键的数组，使数组成为数组（10499478683521864，'07/22/1983'…） 。我们在问题中看到了这个结果。

因此，可以用同样的方法获取数组项的值

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

Answer 3

要访问数组或对象，您将如何使用两个不同的运算符。

要访问数组元素，必须使用[]。

echo $array[0];

在较旧的PHP版本上，还允许使用{}的替代语法：

echo $array{0};

定义数组和访问数组元素是两件不同的事情。所以不要把它们混在一起。

要定义数组，可以使用array（）或for PHP

//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];

要访问数组中的特定元素，可以使用[]或{}中的任何表达式，然后计算出要访问的键：

$array[(Any expression)]

因此，请注意您使用什么表达式作为键以及PHP如何解释它：

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

如果您彼此有多个数组，您只需拥有一个多维数组。要访问子数组中的数组元素，您只需使用多个[]。

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

要访问对象属性，您必须使用-

echo $object->property;

如果你在另一个对象中有一个对象，你只需要使用多个-

echo $objectA->objectB->property;

注：

>

只能从类外部访问具有公共可见性的属性。否则（私有或受保护），您需要一个方法或反射，可以使用它来获取属性的值。

现在，如果数组和对象相互混合，只需查看是否访问数组元素或对象属性，并使用相应的运算符即可。

//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'

我希望这能让您大致了解如何访问数组和对象，当它们相互嵌套时。

注：

>

如果您不确定是否有对象或数组，只需使用gettype（）。

如果有人使用的编码风格与你不同，请不要感到困惑：

 //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"];

如果不想只访问单个元素，可以在嵌套数组/对象上循环，并遍历特定维度的值。

为此，您只需访问要循环的维度，然后就可以循环该维度的所有值。

作为一个例子，我们以一个数组为例，但它也可以是一个对象：

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

如果您循环遍历第一个维度，您将获得来自第一个维度的所有值：

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

这意味着在第一个维度中，只有一个元素包含键（$key）数据和值（$value）：

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

如果在第二个维度上循环，将获得第二个维度的所有值：

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

这意味着在第二维度中，你将有3个元素，其中包含键（$key）0，1，2，以及值（$value）：

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

有了这个，你可以循环通过任何你想要的维度，不管它是数组还是对象。

所有这3个调试函数都输出相同的数据，只是以另一种格式或使用一些元数据（例如类型、大小）。因此，在这里我想展示您必须如何读取这些函数的输出才能知道/了解如何从数组/对象中访问某些数据。

输入阵列：

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

var_dump（）输出：

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

print_r（）输出：

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

        )

)

var_export（）输出：

array (
  'key' => 
  (object) array(
     'property' => 
    array (
      0 => 1,
      1 => 2,
      2 => 3,
    ),
  ),
)

正如你所看到的，所有的输出都非常相似。如果你现在想访问值2，你可以从值本身开始，你想访问它，然后找到“左上角”。

1.我们首先看到，值2在一个键为1的数组中

// var_dump()
array(3) {
  [0]=>
  int(1)
  [1]=>
  int(2)    // <-- value we want to access
  [2]=>
  int(3)
}

// print_r()
Array
(
    [0] => 1
    [1] => 2    // <-- value we want to access
    [2] => 3
)

// var_export()
array (
  0 => 1,
  1 => 2,    // <-- value we want to access
  2 => 3,
)

这意味着我们必须使用[]使用[1]访问值2，因为该值具有键/索引1。

2.接下来我们看到，数组被分配给一个具有对象名称属性的属性

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

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

// var_export()
(object) array(
    'property' => 
  /* Array here */
),

这意味着我们必须使用-

所以到目前为止，我们知道我们必须使用-

3.最后我们看到，最外层是一个数组

// var_dump()
array(1) {
  ["key"]=>
  /* Object & Array here */
}

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

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

正如我们知道我们必须使用[]访问数组元素，我们在这里看到我们必须使用["key"]来访问对象。我们现在可以将所有这些部分放在一起并编写：

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

输出将是：

2

有几件事你必须知道，这样你就不用花几个小时去寻找它们了。

>

“隐藏”字符

有时您的键中有字符，您在浏览器中第一次查看时看不到。然后您会问自己，为什么您无法访问该元素。这些字符可以是：制表符（\t）、新行（\n）、空格或html标签（例如

例如，如果您查看print_r（）的输出，您会看到：

Array ( [key] => HERE ) 

然后，您正试图通过以下方式访问该元素：

echo $arr["key"];

但是你得到了通知：

注意：未定义索引：键

这很好地表明一定有一些隐藏字符，因为您无法访问该元素，即使键看起来非常正确。

这里的诀窍是使用var_dump（）查看您的源代码！（可选：突出显示字符串（print_r（$variable，TRUE）） ）

你可能会突然看到这样的东西：

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

现在您将看到，您的密钥中有一个html标记，一个新行字符，这是您最初没有看到的，因为print\r（），而浏览器没有显示这一点。

所以现在如果你想做：

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

您将获得所需的输出：

HERE

如果查看XML，千万不要相信print_r（）或var_dump（）的输出

您可能将XML文件或字符串加载到对象中，例如。

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

现在，如果使用var_dump（）或print_r（）您将看到：

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

)

如您所见，您看不到title的属性。因此，正如我所说，当您有XML对象时，永远不要相信var_dump（）或print_r（）的输出。始终使用asXML（）来查看完整的XML文件/字符串。

因此，只需使用以下方法之一：

echo $xml->asXML();  //And look into the source code

highlight_string($xml->asXML());

header ("Content-Type:text/xml");
echo $xml->asXML();

然后你会得到输出：

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

有关更多信息，请参阅：

概述（符号、错误）

• 参考-这个符号在PHP中是什么意思？
• 参考-这个错误在PHP中是什么意思？
• PHP解析/语法错误；以及如何解决它们

财产名称问题

• 如何访问名称无效的属性？
• 如何使用整数或无效属性名称等名称访问对象属性？