[Resolved] When you have to globalize an autoglobal

[ppowell]

I know that this is highly discouraged in the PHP community, but I'm afraid I have come up with a scenario where you have no choice but to globalize an autoglobal, whether you like it or not, and I welcome arguments to the contrary.

I've done this successfully in PHP versions 4.1.2, 4.3.2 and 4.3.6, always with register_globals off, performing this action within a class method:

class Foo {
  function Foo() {}

  function doStuff() {
   if (!$_REQUEST['myVar']) {
    $_REQUEST['myVar'] = $myVar;
    global $_REQUEST; 
   }
  }

}

$foo =& new Foo();
$foo->doStuff();
$foo = null;

With the global line:

Array (... [myvar] => 'hello world', [myOtherVar] => 'foo' ...)

Without the global line, this is what $_REQUEST will look like:

Array (...[myOtherVar] => 'foo'...)

There is no $REQUEST element named 'myVar' upon existing the class method, though $REQUEST is an autoglobal it retains its original elemental order w/o modification as performed in the class method. But if I put the global line back into the class method, $_REQUEST retains the 'myVar' element upon method exit and all is well.

This works in three different versions of PHP (4.1.2, 4.3.2, and 4.3.6) and is guaranteed only to perform properly within these versions if register_globals is off via php.ini or is turned off locally via ini_set().

So, there you have it.. globalizing an autoglobal appears to not such a bad idea after all, just like locally turning off register_globals at application level is also a doable option as well.

Phil

[drawmack]

Code:

<?php
<?php
class Foo { 
  function Foo() {} 

  function doStuff_wg() { 
   if (!array_key_exists('myVar',$_REQUEST)) { 
    echo 'here' . "\n"; 
    $_REQUEST['myVar'] = 'done'; 
    global $_REQUEST;  

   } 
  } 

  function doStuff_wog() {
   if (!array_key_exists('myVar',$_REQUEST)) {
    $_REQUEST['myVar'] = 'done'; 
   } 
  } 
} 

$foo = new Foo();
$foo->doStuff_wog();
echo "<pre>";
print_r($_REQUEST);
$foo->doStuff_wg();
print_r($_REQUEST);
echo "</pre>"; 
$foo = null;
?>

Output:

Array
(
    [myVar] => done
)
Array
(
    [myVar] => done
)

Note that not only does myVar exist in request both times but here is not printed from inside the second call which means that the array_key aleady exists. No global needed.

[ppowell]

Sorry but in my testing, the exact opposite occurs: without global the array key does not exist in $_REQUEST if set within a class method. And by the way, is register globals on or off in your testing?

Again, testing in 4.1.2, 4.3.2 Red Hat 7.3 and in FreeBSD Unix with PHP 4.3.6, all with register globals off.

Phil

[drawmack]

It is off, did you try running that code?

[ppowell]

Sure did.. there is no 'myVar' key in $_REQUEST unless you do global, again, in 4.1.2, 4.3.2 and 4.3.6 all with it off.

Phil

[drawmack]

have you tried passing by reference instead of globalizing?

<?php
class foo {
    function foo() {}

function doStuff(&$request) {
    if(!array_key_exists('myVar',$request))
        $request['myVar'] = 'bar';
} //end doStuff
} //end foo

$foo = new foo();
$foo->doStuff($_REQUEST);
echo "<pre>";
print_r($_REQUEST);
echo "</pre>";
?>

[ppowell]

Sure that will work if you do that, but then that would require the user to change their coding structure to accommodate, when, it seems more reasonable to perhaps globalize the autoglobal upon change instead, since it doesn't affect functionality, so it seems.

Perhaps this might have been resolved in PHP version 5?

Phil

[drawmack]

So you condede the point that you neve HAVE to globalize an autoglobal

[ppowell]

Not until either someone removes the "best practice" label out of the mix or that they can somehow prove that you can choose to not global an autoglobal with register_globals off within 4.1.2, 4.3.2 and 4.3.6, at the bare minimum, otherwise, I feel you should do so only to ensure retaining the changed autoglobal state within the beforementioned criteria.

Unless you plan to rewrite the whole functionality like you did and pass it as a parameter. I'm just saying that while it's been said "never global an autoglobal never, never, never", I proved that there can be a case where you - MIGHT - have to, at the very least, it's allowable and functional.

Nonetheless I'm sticking by this find.

Phil