[RESOLVED] converting indexed array into object

nrg_alpha

I find it peculiar converting an indexed array to an object. Consider the following:

$arr = array('John', 'Jenny');
$obj = (object) $arr;
echo $obj->{0}; // Notice: Undefined property: stdClass::$0

The goal here is to be able to simply tap into and echo out the value 'John' via $obj while making use of stdClass. Since arrays being converted to objects assign array keys to object properties while the array values become those properties' values, this means that the property 0 will have the value 'John' while the property 1 will have 'Jenny'.

Simply using print_r in place of that last line in the snippet demonstrates this:

echo '<pre>'.print_r($obj, true);
//Output:
stdClass Object
(
    [0] => John
    [1] => Jenny
)

According to this comment from the manual, these properties cannot be accessed (due to variable naming convention violations - as we know that you cannot start a variable name with a number; therefore I am confused by this allowance in cases like this).

So, in light of all this, I find one way of doing things as such:

$arr = array('John', 'Jenny');
$obj = (object) $arr;
foreach($arr as $val){
    $obj->index[] = $val;
}
echo $obj->index[0]; // echo out an individual index of choice

However, I am wondering of there is a way of actually tapping into properties that are given numbers as names without the need to looping shenanigans like foreach...

NogDog

Well, I'm not sure what you gain by converting an array to a stdclass object, other than you get to type arrows instead of square brackets. :p

However, I suppose you could do the following to skip the foreach loop:

$array = array('foo', 'bar');
$obj = (object) array('prop' => $array);
echo $obj->prop[0];

But this seems silly, since you now have to type both an arrow and brackets.

nrg_alpha

NogDog;10926594 wrote:
Well, I'm not sure what you gain by converting an array to a stdclass object, other than you get to type arrows instead of square brackets. :p[/QUOTING]

It's not so much what I gain, as it is simply experimenting to see what I can and cannot get away with. The devil's in the details as they say.. just trying to see if there's nice little gold glowing halos to be found along the way 😉
NogDog wrote:
However, I suppose you could do the following to skip the foreach loop:
$array = array('foo', 'bar');
$obj = (object) array('prop' => $array);
echo $obj->prop[0];
But this seems silly, since you now have to type both an arrow and brackets.
That's a much nicer solution to the foreach loop imo. It achieves the same thing as what I did in the loop (as in, I would still have to type in both the arrow and square brackets. Thanks for the heads up, Nog. Much appreciated as usual. 🙂

Cheers

Weedpacket

There is one noteworthy difference...

function fun1($foo)
{
    $foo['bar'] = 42;
}
function fun2($foo)
{
    $foo->bar = 42;
}

$wibble1 = array('bar'=>17);
$wibble2 = (object)$wibble1;

fun1($wibble1);
fun2($wibble2);

echo $wibble1['bar'],"\n",$wibble2->bar;

nrg_alpha

Weedpacket;10926607 wrote:
There is one noteworthy difference...
....

Yep, objects definitely have their 'global' uses.

johanafm

But

// Now they do the exact same thing again
function fun1(&$foo)
{
    $foo['bar'] = 42;
}
function fun2($foo)
{
    $foo->bar = 42;
}

$wibble1 = array('bar'=>17);
$wibble2 = (object)$wibble1;

fun1($wibble1);
fun2($wibble2);

echo $wibble1['bar'],"\n",$wibble2->bar;

Or, if you rather

fun2(clone $wibble2);

Weedpacket

But

function fun1(&$foo)
{
    $foo['bar'] = 42;
    $foo = array('bar'=>-1);
}
function fun2($foo)
{
    $foo->bar = 42;
    $foo = (object)array('bar'=>-1);
}
$wibble1 = array('bar'=>17);
$wibble2 = (object)$wibble1;

fun1($wibble1);
fun2($wibble2);

echo $wibble1['bar'],"\n",$wibble2->bar;

johanafm

Good point. Since it's not possible, afaik, to add another level of indirection I suppose the only way to deal with this would be return by reference. Or am I misstaken?

johanafm

It struck me that an ugly way of dealing with this does exist

function fun2($foo)
{
    global $$foo;
    $$foo->bar = 42;
    $$foo = (object)array('bar'=>-1);
}
$wibble1 = array('bar'=>17);
$wibble2 = (object)$wibble1;

fun1($wibble1);
fun2("wibble2");

nrg_alpha

Johanafm,

As I have learned the hard way, the problems with declaring variables as global or passing them by reference is that the underlying issues remain.. (think potential namespace collision with other variables, lack of encapsulation, etc.)

Objects are already global in scope, yet they retain their own namespacing, encapsulation and what not. IMO, that's the beauty of OOP (well, at least part of the beauty anyway, as the rabbit hole goes much deeper still.. but I digress).

johanafm

I'm not sure I follow you. I agree that the global thing above isn't nice, but what do you mean by "the underlying issue remains when passing by reference"?

I havn't coded at all for many years and started coding again a while ago, which is when I took up PHP. So, I'm mainly trying to get what's happening and also what's possible. Or in other words, trying to squeeze some additional info out of Weedpacket, and now you.

But, from what I weakly remember from previous coding I actually would have expected fun2 to get a reference and then change the data at the referenced address, rather than to get a copy of a pointer and change what the new pointer references.

So, I was actually wondering if it was possible to do something along the lines of

*$foo = &(object)

But after thinking about it, I realized that you might as well get this behaviour by

function fun2(&$foo)
{
    $foo->bar = 42;
    $foo = (object)array('bar'=>-1);
}

nrg_alpha

johanafm;10926695 wrote:
I'm not sure I follow you. I agree that the global thing above isn't nice, but what do you mean by "the underlying issue remains when passing by reference"?

IMO, the main issue is encapsulation and nonlocality. When using a regular variable and declaring it global or passing by reference doesn't do anything to 'protect' it against other possible accidentally identical named variables (namespace collisions - perhaps from outside 3rd party libraries and such).. nor is it protected against modifications from anywhere in the page script..(nonlocality) but with an object, you can set properties' visibility (private or protected), which help protect and control how those properties are set and maintained.

Granted, in this thread's case, we can modifiy the sample objects as needed from anywhere, (which more or less falls into the same trap, unless we start including additional object methods for more strict control).

This is not to suggest that you can't get away with using a globally declared variable or pass it by reference... under controlled circumstances they will perform just fine. But 'as a rule', it is generally regarded as bad practice. Simply google something along the lines of 'are global variables bad?'.. you'll get enough additional content explaining things more thoroughly. I'm still learning about OOP myself, so I haven't mastered it (unlike say NogDog or Weedpacket over there 😉 )

johanafm

I'm all with you on the globals.

But, from what I learnt a long time ago, pass by reference was best practice in most cases. Granted, that was with the possibility of assuring that no modifications would be possible through the use of 'const', either by having a const object on which no member data modifications is allowed, or by a const reference which will not allow me to change what data is referenced, or a const reference to const data.

Still, I can't find anything on the net by searching for combinations of php, pass by reference and code smell, bad or similar. So I'm curious if Weedpacket agrees with you, if you have links or other resources with this kind of information or if you could elaborate on the subject. It's always interesting to get more input and feedback.

nrg_alpha

johanafm;10926733 wrote:
I'm all with you on the globals.
So I'm curious if Weedpacket agrees with you, if you have links or other resources with this kind of information or if you could elaborate on the subject. It's always interesting to get more input and feedback.

I'm not nearly as knowledgable nor experienced as Weedpacket nor NogDog, so they may very well have a differeing opinion on this (and as such, I too would be interested in knowing otherwise).

On the one hand, I suppose one could argue that if object properties are private or protected, it isn't globally accessable from anywhere as you would need to access these from some method as opposed to say regular functions. On the other hand, I would think that using objects would reduce the potential namespace issues. I suppose if your script is small enough, it might not matter (as I mentioned previously, under certain circumstances, it will be fine).

As for resources, again, I can only think of googling it..Other members might have better resouces... here are some links I quickly found:

http://en.wikipedia.org/wiki/Global_variable
http://www.c2.com/cgi/wiki?GlobalVariablesAreBad

I'm sure there's better resources out there though.. You would need to spend some time sifting through them.