Array of PHP Objects
The best place to find answers to general (and somewhat easy questions) such as this is to read up on PHP docs. Specifically in your case you can read more on objects. You can store stdObject and instantiated objects within an array. In fact, there is a process known as 'hydration' which populates the member variables of an object with values from a database row, then the object is stored in an array (possibly with other objects) and returned to the calling code for access.
-- Edit --
class Car
{
public $color;
public $type;
}
$myCar = new Car();
$myCar->color = 'red';
$myCar->type = 'sedan';
$yourCar = new Car();
$yourCar->color = 'blue';
$yourCar->type = 'suv';
$cars = array($myCar, $yourCar);
foreach ($cars as $car) {
echo 'This car is a ' . $car->color . ' ' . $car->type . "\n";
}
How to convert an array to object in PHP?
This one worked for me
function array_to_obj($array, &$obj)
{
foreach ($array as $key => $value)
{
if (is_array($value))
{
$obj->$key = new stdClass();
array_to_obj($value, $obj->$key);
}
else
{
$obj->$key = $value;
}
}
return $obj;
}
function arrayToObject($array)
{
$object= new stdClass();
return array_to_obj($array,$object);
}
usage :
$myobject = arrayToObject($array);
print_r($myobject);
returns :
[127] => stdClass Object
(
[status] => Have you ever created a really great looking website design
)
[128] => stdClass Object
(
[status] => Figure A.
Facebook's horizontal scrollbars showing up on a 1024x768 screen resolution.
)
[129] => stdClass Object
(
[status] => The other day at work, I had some spare time
)
like usual you can loop it like:
foreach($myobject as $obj)
{
echo $obj->status;
}
Most efficient way to search for object in an array by a specific property's value
You can iterate that objects:
function findObjectById($id){
$array = array( /* your array of objects */ );
foreach ( $array as $element ) {
if ( $id == $element->id ) {
return $element;
}
}
return false;
}
Edit:
Faster way is to have an array with keys equals to objects' ids (if unique);
Then you can build your function as follow:
function findObjectById($id){
$array = array( /* your array of objects with ids as keys */ );
if ( isset( $array[$id] ) ) {
return $array[$id];
}
return false;
}
Convert a PHP object to an associative array
Just typecast it
$array = (array) $yourObject;
From Arrays:
If an object is converted to an array, the result is an array whose elements are the object's properties. The keys are the member variable names, with a few notable exceptions: integer properties are unaccessible; private variables have the class name prepended to the variable name; protected variables have a '*' prepended to the variable name. These prepended values have null bytes on either side.
Example: Simple Object
$object = new StdClass;
$object->foo = 1;
$object->bar = 2;
var_dump( (array) $object );
Output:
array(2) {
'foo' => int(1)
'bar' => int(2)
}
Example: Complex Object
class Foo
{
private $foo;
protected $bar;
public $baz;
public function __construct()
{
$this->foo = 1;
$this->bar = 2;
$this->baz = new StdClass;
}
}
var_dump( (array) new Foo );
Output (with \0s edited in for clarity):
array(3) {
'\0Foo\0foo' => int(1)
'\0*\0bar' => int(2)
'baz' => class stdClass#2 (0) {}
}
Output with var_export
instead of var_dump
:
array (
'' . "\0" . 'Foo' . "\0" . 'foo' => 1,
'' . "\0" . '*' . "\0" . 'bar' => 2,
'baz' =>
stdClass::__set_state(array(
)),
)
Typecasting this way will not do deep casting of the object graph and you need to apply the null bytes (as explained in the manual quote) to access any non-public attributes. So this works best when casting StdClass objects or objects with only public properties. For quick and dirty (what you asked for) it's fine.
Also see this in-depth blog post:
- Fast PHP Object to Array conversion
Making a PHP object behave like an array?
If you extend ArrayObject
or implement ArrayAccess
then you can do what you want.
How can I access an array/object?
To access an array
or object
you how to use two different operators.
Arrays
To access array elements you have to use []
.
echo $array[0];
On older PHP versions, an alternative syntax using {}
was also allowed:
echo $array{0};
Difference between declaring an array and accessing an array element
Defining an array and accessing an array element are two different things. So don't mix them up.
To define an array you can use array()
or for PHP >=5.4 []
and you assign/set an array/-element. While when you are accessing an array element with []
as mentioned above, you get the value of an array element opposed to setting an element.
//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];
Access array element
To access a particular element in an array you can use any expression inside []
or {}
which then evaluates to the key you want to access:
$array[(Any expression)]
So just be aware of what expression you use as key and how it gets interpreted by 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
Access multidimensional array
If you have multiple arrays in each other you simply have a multidimensional array. To access an array element in a sub array you just have to use multiple []
.
echo $array["firstSubArray"]["SecondSubArray"]["ElementFromTheSecondSubArray"]
// ├─────────────┘ ├──────────────┘ ├────────────────────────────┘
// │ │ └── 3rd Array dimension;
// │ └──────────────────── 2d Array dimension;
// └───────────────────────────────────── 1st Array dimension;
Objects
To access an object property you have to use ->
.
echo $object->property;
If you have an object in another object you just have to use multiple ->
to get to your object property.
echo $objectA->objectB->property;
Note:
Also you have to be careful if you have a property name which is invalid! So to see all problems, which you can face with an invalid property name see this question/answer. And especially this one if you have numbers at the start of the property name.
You can only access properties with public visibility from outside of the class. Otherwise (private or protected) you need a method or reflection, which you can use to get the value of the property.
Arrays & Objects
Now if you have arrays and objects mixed in each other you just have to look if you now access an array element or an object property and use the corresponding operator for it.
//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'
I hope this gives you a rough idea how you can access arrays and objects, when they are nested in each other.
Note:
If it is called an array or object depends on the outermost part of your variable. So [new StdClass]
is an array even if it has (nested) objects inside of it and $object->property = array();
is an object even if it has (nested) arrays inside.
And if you are not sure if you have an object or array, just use gettype()
.
Don't get yourself confused if someone uses another coding style than you:
//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, Objects and Loops
If you don't just want to access a single element you can loop over your nested array / object and go through the values of a particular dimension.
For this you just have to access the dimension over which you want to loop and then you can loop over all values of that dimension.
As an example we take an array, but it could also be an object:
Array (
[data] => Array (
[0] => stdClass Object (
[propertyXY] => 1
)
[1] => stdClass Object (
[propertyXY] => 2
)
[2] => stdClass Object (
[propertyXY] => 3
)
)
)
If you loop over the first dimension you will get all values from the first dimension:
foreach($array as $key => $value)
Means here in the first dimension you would only have 1 element with the key($key
) data
and the value($value
):
Array ( //Key: array
[0] => stdClass Object (
[propertyXY] => 1
)
[1] => stdClass Object (
[propertyXY] => 2
)
[2] => stdClass Object (
[propertyXY] => 3
)
)
If you loop over the second dimension you will get all values from the second dimension:
foreach($array["data"] as $key => $value)
Means here in the second dimension you would have 3 element with the keys($key
) 0
, 1
, 2
and the values($value
):
stdClass Object ( //Key: 0
[propertyXY] => 1
)
stdClass Object ( //Key: 1
[propertyXY] => 2
)
stdClass Object ( //Key: 2
[propertyXY] => 3
)
And with this you can loop through any dimension which you want no matter if it is an array or object.
Analyse var_dump()
/ print_r()
/ var_export()
output
All of these 3 debug functions output the same data, just in another format or with some meta data (e.g. type, size). So here I want to show how you have to read the output of these functions to know/get to the way how to access certain data from your array/object.
Input array:
$array = [
"key" => (object) [
"property" => [1,2,3]
]
];
var_dump()
output:
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()
output:
array (
'key' =>
(object) array(
'property' =>
array (
0 => 1,
1 => 2,
2 => 3,
),
),
)
So as you can see all outputs are pretty similar. And if you now want to access the value 2 you can just start from the value itself, which you want to access and work your way out to the "top left".
1. We first see, that the value 2 is in an array with the key 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,
)
This means we have to use []
to access the value 2 with [1]
, since the value has the key/index 1.
2. Next we see, that the array is assigned to a property with the name property of an object
// var_dump()
object(stdClass)#1 (1) {
["property"]=>
/* Array here */
}
// print_r()
stdClass Object
(
[property] => /* Array here */
)
// var_export()
(object) array(
'property' =>
/* Array here */
),
This means we have to use ->
to access the property of the object, e.g. ->property
.
So until now, we know that we have to use ->property[1]
.
3. And at the end we see, that the outermost is an array
// var_dump()
array(1) {
["key"]=>
/* Object & Array here */
}
// print_r()
Array
(
[key] => stdClass Object
/* Object & Array here */
)
// var_export()
array (
'key' =>
/* Object & Array here */
)
As we know that we have to access an array element with []
, we see here that we have to use ["key"]
to access the object. We now can put all these parts together and write:
echo $array["key"]->property[1];
And the output will be:
2
Don't let PHP troll you!
There are a few things, which you have to know, so that you don't spend hours on it finding them.
"Hidden" characters
Sometimes you have characters in your keys, which you don't see on the first look in the browser. And then you're asking yourself, why you can't access the element. These characters can be: tabs (\t
), new lines (\n
), spaces or html tags (e.g. </p>
, <b>
), etc.
As an example if you look at the output of print_r()
and you see:
Array ( [key] => HERE )
Then you are trying to access the element with:
echo $arr["key"];
But you are getting the notice:
Notice: Undefined index: key
This is a good indication that there must be some hidden characters, since you can't access the element, even if the keys seems pretty correct.
The trick here is to use var_dump()
+ look into your source code! (Alternative: highlight_string(print_r($variable, TRUE));
)
And all of the sudden you will maybe see stuff like this:
array(1) {
["</b>
key"]=>
string(4) "HERE"
}
Now you will see, that your key has a html tag in it + a new line character, which you didn't saw in the first place, since print_r()
and the browser didn't showed that.
So now if you try to do:
echo $arr["</b>\nkey"];
You will get your desired output:
HERE
Never trust the output of print_r()
or var_dump()
if you look at XML
You might have an XML file or string loaded into an object, e.g.
<?xml version="1.0" encoding="UTF-8" ?>
<rss>
<item>
<title attribute="xy" ab="xy">test</title>
</item>
</rss>
Now if you use var_dump()
or print_r()
you will see:
SimpleXMLElement Object
(
[item] => SimpleXMLElement Object
(
[title] => test
)
)
So as you can see you don't see the attributes of title. So as I said never trust the output of var_dump()
or print_r()
when you have an XML object. Always use asXML()
to see the full XML file/string.
So just use one of the methods shown below:
echo $xml->asXML(); //And look into the source code
highlight_string($xml->asXML());
header ("Content-Type:text/xml");
echo $xml->asXML();
And then you will get the output:
<?xml version="1.0" encoding="UTF-8"?>
<rss>
<item>
<title attribute="xy" ab="xy">test</title>
</item>
</rss>
For more information see:
General (symbols, errors)
- Reference — What does this symbol mean in PHP?
- Reference - What does this error mean in PHP?
- PHP parse/syntax errors; and how to solve them
Property name problems
- How can I access a property with an invalid name?
- How to access object properties with names like integers or invalid property names?
How to create javascript like object in php
The universal key-value data structure in PHP is not an object, it's an associative array. Your code would look like this:
$users = [
[
'id' => 1,
'name' => 'John',
'amount' => 1000,
],
[
'id' => 2,
'name' => 'Smith',
'amount' => 2000,
],
];
You then access elements using square brackets:
$users[0]['amount'] = 0;
$users[1]['amount'] = 3000;
echo $users[0]['amount'];
While using an object for this may be more familiar to a JS developer, using arrays for ad hoc data will let you use much more of PHP's built-in functionality, which is designed around associative arrays.
On the other hand, if you actually have the same fields in every object, you should declare a class listing those fields. This will give you better performance, better error handling, clearer code, and the ability to encapsulate logic in those classes in future.
In PHP 8, you can write this using constructor property promotion which looks like this:
class User
{
public function __construct(
public int $id,
public string $name,
public int $amount
) {}
}
You would then create the array like this (using named parameters, also new in PHP 8.0):
$users = [
new User(
id: 1,
name: 'John',
amount: 1000,
),
new User(
id: 2,
name: 'Smith',
amount: 2000,
),
];
And use it like this:
$users[0]->amount = 0;
$users[1]->amount = 3000;
echo $users[0]->amount;
In older versions of PHP, the code to declare the classes and create the objects would have to be slightly different, but the benefits would be the same.
In PHP, how can I add an object element to an array?
Just do:
$object = new stdClass();
$object->name = "My name";
$myArray[] = $object;
You need to create the object first (the new
line) and then push it onto the end of the array (the []
line).
You can also do this:
$myArray[] = (object) ['name' => 'My name'];
However I would argue that's not as readable, even if it is more succinct.
Related Topics