Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Language Reference : Variables : Variable scope

Variable scope

The scope of a variable is the context within which it is defined. For the most part all PHP variables only have a single scope. This single scope spans included and required files as well. For example:

copy to clipboard
<?php
$a = 1;
include 'b.inc';
?>

Here the $a variable will be available within the included b.inc script. However, within user-defined functions a local function scope is introduced. Any variable used inside a function is by default limited to the local function scope. For example:

copy to clipboard
<?php
$a = 1; /* global scope */

function Test()
{
   echo $a; /* reference to local scope variable */
}

Test();
?>

This script will not produce any output because the echo statement refers to a local version of the $a variable, and it has not been assigned a value within this scope. You may notice that this is a little bit different from the C language in that global variables in C are automatically available to functions unless specifically overridden by a local definition. This can cause some problems in that people may inadvertently change a global variable. In PHP global variables must be declared global inside a function if they are going to be used in that function.

The global keyword

First, an example use of global:

Example 3.2. Using global

copy to clipboard
<?php
$a = 1;
$b = 2;

function Sum()
{
   global $a, $b;

   $b = $a + $b;
}

Sum();
echo $b;
?>


The above script will output "3". By declaring $a and $b global within the function, all references to either variable will refer to the global version. There is no limit to the number of global variables that can be manipulated by a function.

A second way to access variables from the global scope is to use the special PHP-defined $GLOBALS array. The previous example can be rewritten as:

Example 3.3. Using $GLOBALS instead of global

copy to clipboard
<?php
$a = 1;
$b = 2;

function Sum()
{
   $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

Sum();
echo $b;
?>


The $GLOBALS array is an associative array with the name of the global variable being the key and the contents of that variable being the value of the array element. Notice how $GLOBALS exists in any scope, this is because $GLOBALS is a superglobal. Here's an example demonstrating the power of superglobals:

Example 3.4. Example demonstrating superglobals and scope

copy to clipboard
<?php
function test_global()
{
   // Most predefined variables aren't "super" and require
   // 'global' to be available to the functions local scope.
   global $HTTP_POST_VARS;
   
   echo $HTTP_POST_VARS['name'];
   
   // Superglobals are available in any scope and do
   // not require 'global'. Superglobals are available
   // as of PHP 4.1.0, and HTTP_POST_VARS is now
   // deemed deprecated.
   echo $_POST['name'];
}
?>


Using static variables

Another important feature of variable scoping is the static variable. A static variable exists only in a local function scope, but it does not lose its value when program execution leaves this scope. Consider the following example:

Example 3.5. Example demonstrating need for static variables

copy to clipboard
<?php
function Test()
{
   $a = 0;
   echo $a;
   $a++;
}
?>


This function is quite useless since every time it is called it sets $a to 0 and prints "0". The $a++ which increments the variable serves no purpose since as soon as the function exits the $a variable disappears. To make a useful counting function which will not lose track of the current count, the $a variable is declared static:

Example 3.6. Example use of static variables

copy to clipboard
<?php
function Test()
{
   static $a = 0;
   echo $a;
   $a++;
}
?>


Now, every time the Test() function is called it will print the value of $a and increment it.

Static variables also provide one way to deal with recursive functions. A recursive function is one which calls itself. Care must be taken when writing a recursive function because it is possible to make it recurse indefinitely. You must make sure you have an adequate way of terminating the recursion. The following simple function recursively counts to 10, using the static variable $count to know when to stop:

Example 3.7. Static variables with recursive functions

copy to clipboard
<?php
function Test()
{
   static $count = 0;

   $count++;
   echo $count;
   if ($count < 10) {
       Test();
   }
   $count--;
}
?>


Note:

Static variables may be declared as seen in the examples above. Trying to assign values to these variables which are the result of expressions will cause a parse error.

Example 3.8. Declaring static variables

copy to clipboard
<?php
function foo(){
   static $int = 0;          // correct
   static $int = 1+2;        // wrong  (as it is an expression)
   static $int = sqrt(121);  // wrong  (as it is an expression too)

   $int++;
   echo $int;
}
?>


References with global and static variables

The Zend Engine 1, driving PHP 4, implements the static and global modifier for variables in terms of references. For example, a true global variable imported inside a function scope with the global statement actually creates a reference to the global variable. This can lead to unexpected behaviour which the following example addresses:

copy to clipboard
<?php
function test_global_ref() {
   global $obj;
   $obj = &new stdclass;
}

function test_global_noref() {
   global $obj;
   $obj = new stdclass;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

Executing this example will result in the following output:

copy to clipboard
NULL
object(stdClass)(0) {
}

A similar behaviour applies to the static statement. References are not stored statically:

copy to clipboard
<?php
function &get_instance_ref() {
   static $obj;

   echo 'Static object: ';
   var_dump($obj);
   if (!isset($obj)) {
       // Assign a reference to the static variable
       $obj = &new stdclass;
   }
   $obj->property++;
   return $obj;
}

function &get_instance_noref() {
   static $obj;

   echo 'Static object: ';
   var_dump($obj);
   if (!isset($obj)) {
       // Assign the object to the static variable
       $obj = new stdclass;
   }
   $obj->property++;
   return $obj;
}

$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>

Executing this example will result in the following output:

copy to clipboard
Static object: NULL
Static object: NULL

Static object: NULL
Static object: object(stdClass)(1) {
 ["property"]=>
 int(1)
}

This example demonstrates that when assigning a reference to a static variable, it's not remembered when you call the &get_instance_ref() function a second time.

Code Examples / Notes » language.variables.scope

rhett
You could get around that:
<?php
function someFunction () {
  static $isInitialized = 0;
  static $otherStatic = 0; // or whatever default you want
  if (!$isInitialized) {
     $otherStatic = function(); // or whatever
     $isInitialized = 1;
  }
  ...
}
?>
Needs an extra variable and evaluates a condition every time it's run, but it does get around your problem.

tomek
When defining static variables you may use such declarations:
static $var = 1; //numbers
static $var = 'strings';
static $var = array(1,'a',3); //array construct
but these ones would produce errors:
static $var = some_function('arg');
static $var = (some_function('arg'));
static $var = 2+3; //any expression
static $var = new object;

jmarbas
Whats good for the goose is not always good for the iterative gander. If you declare and initialize the static variable more than once inside a function ie.
function Test(){
  static $count = 0;
  static $count = 1;
  static $count = 2;
  echo $count;
}
the variable will take the value of the last declaration. In this case $count=2.
But! however when you make that function recursive ie.
 function Test(){
  static $count = 0;
  static $count = 1;
  static $count = 2;
  $count++;
  echo $count;
  if ($count<10){
    Test();
  }
 }
Every call to the function Test() is a differenct SCOPE and therefore the static declarations and initializations are NOT executed again. So what Im trying to say is that its OK to declare and initialize a static variable multiple times if you are in one function... but its NOT OK to declare and initialize a static variable multiple times if you call that same function multiple times. In other words the static variable is set once you LEAVE a function (even if you go back into that very same function).

danno
WARNING!  If you create a local variable in a function and then within that function assign it to a global variable by reference the object will be destroyed when the function exits and the global var will contain NOTHING!  This main sound obvious but it can be quite tricky you have a large script (like a phpgtk-based gui app ;-) ).
example:
function foo ()
{
  global $testvar;
  $localvar = new Object ();
  $testvar = &$localvar;
}
foo ();
print_r ($testvar);   // produces NOTHING!!!!
hope this helps someone before they lose all their hair

alan
Using the global keyword inside a function to define a variable is essentially the same as passing the variable by reference as a parameter:
somefunction(){
  global $var;
}
is the same as:
somefunction(& $a) {
}
The advantage to using the keyword is if you have a long list of variables  needed by the function - you dont have to pass them every time you call the function.

s dot radovanovic
To use the Singleton Pattern (as available in PHP5), we must do a little trick in PHP4.
Most examples I've seen look like this:
//Creation of singleton, Example, Example1 objects
//and then
<?
$myExample  =& singleton('Example');
$myExample1 =& singleton('Example1');
?>
What I wanted was a way to use the Singleton Pattern on initialization of a new object (no calling of a method by reference (or something like that)).
The initializor doesn't have to know that the object it is trying to initialize uses the Singleton Pattern.
Therefor I came up with the following:
Beneath is part of a Config object that allows me to retrieve configuration data read from specific ini files (through parse_ini_file). Because I wanted to use the Config object in different other objects without having to pass a reference to the Config object all the time and without some of them having to now how the Config object was loaded (which configuration file was used) I had the need for the Singleton pattern.
To accomplish the Singleton pattern in the Constructor I've created a static array containing references to configuration file specific objects (each new configuration file creates a new instance of the Config object).
If we then try to create a new instance of an already loaded Config object (with the same configuration file), the objects set this to the reference of the previously created object, thus pointing both instances to the same object.
Here's the main part of the script.
Here's an example of how to use the Config object:
<?php
//dataheader
Config::setIniPath("/home/mydir/data/conffiles");
//object screen
$objTemplateConfig = new Config("template.conf");
$objErrorConfig = new Config("error.conf");
//objTemplateConfig and objErrorConfig are 2 different instances
$templatePath = $objTemplateConfig->get("template_path");
$errorColor = $objErrorConfig->get("error_color");
//object factory
//If no file is stated, the last one is used, this way this instance will have the reference to the previously created instance of objErrorConfig in object screen
$objErrorConfig = new Config();
$errorMessage = $objErrorConfig->get($errorName);
?>
So without the initializor knowing it he/she has retrieved a reference to a previously instantiated Config object (knowledge of this resides with the object).
Here's the constructor part of the config object:

17-jul-2005 01:42
To the last poster, regarding the speed tests:
<?php
$a = str_repeat('text', 100);
$b = $a;
$c =& $a;
// $c == $b == $a
// But you assigned a different value within the functions:
$len = strlen($a); // $len != $a
?>
I was bemused; how could the processing times of the functions/no-functions tests be compared in this way? And calling the strlen() function within each iteration of the loop must take more time anyway?

www dot php dot net dot 2nd
To the bemused poster: Of course you can't compare processing times between functions/no functions. I only wanted to see the difference between referenced and copied variables in different scenarios. Tests are only meant to compare between pairs (i.e., call a function with & and call the same function without &). I did 4 individual pairs of tests, so test 1 compares to test 2, test 3 compares to test 4, test 5 compares to test 6 and test 7 compares to test 8. The strlen() call was there only to make sure the value is actually accessed.

jason
This is probably self-evident to most folks here, and I expected this behavior, but it wasn't explicitly mentioned in the manual itself so I tested to find out: the global keyword *will* allow you to access variables in the global scope of your script, even if those variables were not made available locally to the parent function.  In other words, the following will work as expected, even though $a is never referenced as global within the function foo:
<?php
function foo() {
bar();
}
function bar() {
global $a;
echo $a;
}
$a = "works!";
foo();
?>

michael bailey jinxidoru
Static variables do not hold through inheritance.  Let class A have a function Z with a static variable.  Let class B extend class A in which function Z is not overwritten.  Two static variables will be created, one for class A and one for class B.
Look at this example:
<?php
class A {
function Z() {
static $count = 0;
printf("%s: %d\n", get_class($this), ++$count);
}
}
class B extends A {}
$a = new A();
$b = new B();
$a->Z();
$a->Z();
$b->Z();
$a->Z();
?>
This code returns:
A: 1
A: 2
B: 1
A: 3
As you can see, class A and B are using different static variables even though the same function was being used.

marcin
Sometimes in PHP 4 you need static variabiles in class. You can do it by referencing static variable in constructor to the class variable:
<?php
class test  {
  var $var;
  var $static_var;
function test()
{
static $s;
$this->static_var =& $s;
}
 
}
$a=new test();
$a->static_var=4;
$a->var=4;

$b=new test();

echo $b->static_var; //this will output 4
echo $b->var; //this will output nul
?>

info
Some times you need to access the same static in more than one function. There is an easy way to solve this problem:
<?php
 // We need a way to get a reference of our static
 function &getStatic() {
   static $staticVar;
   return $staticVar;
 }
 // Now we can access the static in any method by using it's reference
 function fooCount() {
   $ref2static = & getStatic();
   echo $ref2static++;
 }
 fooCount(); // 0
 fooCount(); // 1
 fooCount(); // 2
?>

heatwave
Some people (including me) had a problem with defining a long GLOBAL variable list in functions (very error prone). Here is a possible solution. My program parses php file for functions, and compiles GLOBAL variable lists. Then you can just remove from the list those variables which need not be global.
<?php
//parser for GLOBAL variable list
$pfile=file("myfile.php4");

for($i=0;$i<sizeof($pfile);$i++) {
if(eregi("function",$pfile[$i])) {
 list($part1,$part2)=sscanf($pfile[$i],"%s %s");
 echo "\n\n $part1 $part2:\nGLOBAL ";
 
 $varlist=array();
 $level=0; $end=$i;
 do {
  $lpar=explode("{",$pfile[$end]);
  $level+=sizeof($lpar)-1;
  $lpar=explode("}",$pfile[$end]);
  $level-=sizeof($lpar)-1;
  $end++;
 } while(($end<sizeof($pfile))&&($level>0));
 $pstr="";
 for($j=$i;$j<=$end;$j++) $pstr.=$pfile[$j];
 $lpar=explode("$",$pstr);
 for($j=1;$j<sizeof($lpar);$j++) {
  eregi('[a-zA-Z_][a-zA-Z0-9_]*',$lpar[$j],$cvar);
$varlist[$cvar[0]]=1;
 }
 array_walk($varlist,'var_print');
}
}
function var_print ($item, $key) {
    echo "$key,";
}
?>

warhog
Some interesting behavior (tested with PHP5), using the static-scope-keyword inside of class-methods.
<?php
class sample_class
{
 public function func_having_static_var($x = NULL)
 {
   static $var = 0;
   if ($x === NULL)
   { return $var; }
   $var = $x;
 }
}
$a = new sample_class();
$b = new sample_class();
echo $a->func_having_static_var()."\n";
echo $b->func_having_static_var()."\n";
// this will output (as expected):
//  0
//  0
$a->func_having_static_var(3);
echo $a->func_having_static_var()."\n";
echo $b->func_having_static_var()."\n";
// this will output:
//  3
//  3
// maybe you expected:
//  3
//  0
?>
One could expect "3 0" to be outputted, as you might think that $a->func_having_static_var(3); only alters the value of the static $var of the function "in" $a - but as the name says, these are class-methods. Having an object is just a collection of properties, the functions remain at the class. So if you declare a variable as static inside a function, it's static for the whole class and all of its instances, not for each object.
Maybe it's senseless to post that.. cause if you want to have the behaviour that I expected, you can simply use a variable of the object itself:
<?php
class sample_class
{ protected $var = 0;
 function func($x = NULL)
 { $this->var = $x; }
} ?>
I believe that all normal-thinking people would never even try to make this work with the static-keyword, for those who try (like me), this note maybe helpfull.

pim
shevek wrote:
>> If you include a file from within a function using include(),
>> the included file inherits the function scope as its own
>> global scope, it will not be able to see top level globals
>> unless they are explicit in the function.
in addition:
if you define a function in that included file, it can't get the variables from the inluded file's scope. global won't work. The only way to give such an include function access to global vars is via arguments. I don't know if this is a bug in PHP.
//---- from within function included file -----
echo $var1; // this one works
function foo()
{
global $var1;
echo $var1; // this one doesn't
}

30-apr-2002 09:14
Seems as though when a cookie is saved and referenced as a variable of the same name as the cookie, that variable is NOT global.  If you make a function ro read the value of the cookie, the cooke variable name must be declared as a global.
example:
function ReturnCookie()
{
       $cookieName = "Test_Cookie";
       global $$cookieName;
       if (isset($$cookieName))
       {
               echo ("$cookieName is set");
               $returnvalue = $$cookieName;
       }
       else
       {
               $newCookieValue = "Test Value";
               setcookie("$cookieName","$newCookieValue", (time() + 3153600));
               echo ("made a cookie:" . $newCookieValue ."
");
               $returnvalue = $newCookieValue;
       }
       echo ("the cookie that was set is now $returnvalue
");
       return $returnvalue;
}

s dot radovanovic
Sadly I have found out that I have been wrong about my statements below, why?
Well:
1. only the variables that were set in the constructor were 'live' in my referenced object
2. I was assigning this an object and not a reference
So:
I fixed nr. 1 by adding the & when initializing the object (this way this works on the initialized object and not a copy of it)
<?php
//screen factory
$objErrorConfig = & new Config("error.conf");
$objErrorConfig->setSection("messages");
//object factory
//If no file is stated, the last one is used, this way this instance will have the reference to the previously created instance of objErrorConfig in object screen
$objErrorConfig = & new Config();
$errorMessage = $objErrorConfig->get($errorName);
?>
Now the variables assigned after the constructor ($objErrorConfig->setSection("messages");) will also be 'live' in the static obj array.
I had to find a workaround for nr.2, since it is impossible to assign a reference to this. That's why I used code proposed by others, nl. I referenced all the members of the objects:
<?php
//Because we cannot make a direct reference from our object (by doing $this = & $theObject)
//we'll make references of our members
$arrClassVars = get_class_vars(get_class($theObject));
foreach($arrClassVars as $member=>$value) {
$this->$member = &$theObject->$member;
}
//To make sure we are working with a reference we will store our new object as the reference
//in the singeltonobject array (so all other initialized (referenced) objects will have the
//newest one as super referer
$arrSingletonObject[$this->_configfile] = & $this;
?>
So in the end, I had better used what everbody was using (creating a Singleton through an method, instead of through the constructor), but hey, I learned something again :)

ben-xo aatt dubplates.org
regarding the above "unset" example: I quote from the manual page for "unset".
"If a static variable is unset() inside of a function, unset() destroyes the variable and all its references. "
As mentioned above, on this page, static vars are implemented as references. When you unset() a reference, what you are doing is deleting a particular name for that variable. In your example, you delete the LOCAL NAME $a, but the static contents are still there (hidden) and next time you call your function, a NEW LOCAL NAME (again $a...) is linked to the SAME backing data.
Workaround would be something like "$a = null".
unset($a) is very much like $a = &null however, which, if you read the notes above, won't have the desired affect on static or global variables.

cellog
regarding May 27 comment.
Try this file, and you will see that what I said in my comment holds:
<?php
$testvar = 1 ;
$testvar2 = 2 ;
function foo ()
{
  global $testvar ;
  global $testvar2 ;
  $testvar3 = 6;
  $testvar =  3 ; //Assigning a constant works as expected.
  echo "$testvar,$GLOBALS[testvar],$GLOBALS[testvar2],$testvar3
" ;   // 3,3,2,6
  $testvar =  4 ; //Assigning a variable also works as expected.
  echo "$testvar,$GLOBALS[testvar],$GLOBALS[testvar2],$testvar3
" ;   // 4,4,2,6
  $testvar =  &$testvar2 ; // Assiging a reference points $testvar at what $testvar2
                         // is pointing at, which is $GLOBALS[testvar2]
  echo "$testvar,$GLOBALS[testvar],$GLOBALS[testvar2],$testvar3
" ;   // 2,4,2,6
  $testvar=5 ; // Assigning a value to testvar now modifies $GLOBALS[testvar2]
  echo "$testvar,$GLOBALS[testvar],$GLOBALS[testvar2],$testvar3
" ;    //5,4,5,6
 
  $testvar = &$testvar3;
  echo "$testvar,$GLOBALS[testvar],$GLOBALS[testvar2],$testvar3
" ;    //6,4,5,6
 
  $testvar = 7; // Assigning a value to testvar now modifies local $testvar3
  echo "$testvar,$GLOBALS[testvar],$GLOBALS[testvar2],$testvar3
" ;    //7,4,5,7
}
foo() ;
?>
doing $testvar = &$testvar2 assigns $testvar to point at $testvar2, which is pointing at $GLOBALS[testvar2].  Later, I assign $testvar = &$testvar3, which points it at the local variable.
The & operator *only* changes what the left-hand variable points at, and not the contents of what it used to point at (to borrow from old-fashioned pointer terminology :).

admin
Quick tip for beginners just to speed things up:


If you have a bunch of global variables to import into a function, it's best to put them into a named array like $variables[stuff].  


When it's time to import them you just so the following;


function here() {
 $vars = $GLOBALS['variables'];
 print $vars[stuff];
}
This really helps with big ugly form submissions.

jochen_burkhard
Please don't forget:
values of included (or required) file variables are NOT available in the local script if the included file resides on a remote server:
remotefile.php:
<?PHP
$paramVal=10;
?>
localfile.php:
<?PHP
include "http://otherserver.com/remotefile.php";
echo "remote-value= $paramVal";
?>
Will not work (!!)

sami doesn't want spam
PHP 5.1.4 doesn't seem to care about the static keyword. It doesn't let you use $this in a static method, but you can call class methods through an instance of the class using regular -> notation. You can also call instance methods as class methods through the class itself. The documentiation here is plain wrong.
class Foo {
 public static function static_fun()
 {
   return "This is a class method!\n";
 }
 
 public function not_static_fun()
 {
   return "This is an instance method!\n";
 }
}
echo '<pre>';
echo "From Foo:\n";
echo Foo::static_fun();
echo Foo::not_static_fun();
echo "\n";
echo "From \$foo = new Foo():\n";
$foo = new Foo();
echo $foo->static_fun();
echo $foo->not_static_fun();
echo '</pre>';
You'll see the following output:
From Foo:
This is a class method!
This is an instance method!
From $foo = new Foo():
This is a class method!
This is an instance method!

tc underline
Pay attention while unsetting variables inside functions:
<?php
$a = "1234";
echo "<pre>";
echo "outer: $a\n";
function testa()
{
global $a;
echo "   inner testa: $a\n";
unset ($a);
echo "   inner testa: $a\n";
}
function testb()
{
global $a;
echo "   inner testb: $a\n";
$a = null;
echo "   inner testb: $a\n";
}
testa();
echo "outer: $a\n";
testb();
echo "outer: $a\n";
echo "</pre>";
?>
/***** Result:
outer: 1234
  inner testa: 1234
  inner testa:
outer: 1234
  inner testb: 1234
  inner testb:
outer:
******/
Took me 1 hour to find out why my variable was still there after unsetting it ...
Thomas Candrian

carpathia_uk
On confusing aspect about global scope...
If you want to access a variable such as a cookie inside a function, but theres a chance it may not even be defined, you need to access it using he GLOBALS array, not by defining it as global.
This wont work correctly....
function isLoggedin()
{
global $cookie_username;
if (isset($cookie_username)
echo "blah..";
}
This will..
function isLoggedin()
{
if (isset($GLOBALS["cookie_username"]))
echo "blah..";
}

huntsbox
Not sure of the implications of this but...
You can create nested functions within functions but you must make sure they aren't defined twice, e.g.:
function norm($a, $b) {
static $first_time = true;
if ($first_time) {
function square($x) {
return $x * $x;
}
$first_time = false;
}
return sqrt(square($a) + square($b));
}
print square(5); // error, not defined yet
print norm(5,4);
print "
";
print norm(3,2);
print square(5); // OK
If you don't include the if ($first_time) you get an error saying you can't define square() twice.  Note that square is not local to the function it just appears there.  The last line successfully accesses square in the page scope.  This is not terribly useful, but interesting.

mu
morthanpurpl: You don't have to initialize variables you use first inside a variable, at least not in PHP4.2.2. The following will just work fine and output "iam":
<?php
function dumdum()
{
global $a;
$a = "iam";
}
dumdum();
echo $a;
?>

randolpho
More on static variables:
My first not is probably intuitive to most, but I didn't notice it mentioned explicitly, so I'll mention it: a static variable does not retain it's value after the script's execution. Don't count on it being available from one page request to the next; you'll have to use a database for that.
Second, here's a good pattern to use for declaring a static variable based on some complex logic:
<?
 function buildStaticVariable()
 {
     $foo = null;
     // some complex expression or set of
     // expressions/statements to build
     // the return variable.
     return $foo;
 }
 function functionWhichUsesStaticVar()
 {
     static $foo = null;
     if($foo === null) $foo = buildStaticVariable();
     // the rest of your code goes here.
 }
?>
Using such a pattern allows you to separate the code that creates your default static variable value from the function that uses it. Easier to maintain code is good. :)

jg
It's possible to use a variable variable when specifying a variable as global in a function. That way your function can decide what global variable to access in run-time.
function func($varname)
{
  global $$varname;
  echo $$varname;
}
$hello = "hello world!";
func("hello");
This will print "hello world!", and is roughly the same as passing by reference, in the case when the variable you want to pass is global. The advantage over references is that they can't have default parameters. With the method above, you can do the following.
function func($varname = FALSE)
{
  if ($varname === FALSE)
    echo "No variable.";
  else
  {
    global $$varname;
    echo $$varname;
  }
}
$hello = "hello world!";
func("hello");                   // prints "hello world!"
func();                          // prints "No variable."

jameslee
It should be noted that a static variable inside a method is static across all instances of that class, i.e., all objects of that class share the same static variable.  For example the code:
<?php
class test {
   function z() {
       static $n = 0;
       $n++;
       return $n;
   }
}
$a =& new test();
$b =& new test();
print $a->z();  // prints 1, as it should
print $b->z();  // prints 2 because $a and $b have the same $n
?>
somewhat unexpectedly prints:
1
2

variable_scope-php dot net
In response to: Variable scope
Quote: "the global keyword *will* allow you to access variables in the global scope of your script, even if those variables were not made available locally to the parent function."
Actually, the "parent" function does not access a variable in its global scope unless it specifically uses the global modifier on the variable.
See this test:
<?php
$var = ''; // global scope
function foo() {
$var = 'Hello from $foo';
bar();
echo $var;
}
function bar() {
global $var;
$var = 'Hello from $var';
}
foo(); // prints: "Hello from $foo"
?>
The global scope of the variable $var is only available to bar(), not to foo(). Even if you were to put foo() and bar() in the same parent class, this would still be the case.

shyam dot g
in response to Michael's comments, it is imperative to observe that static variables in methods of an object are not class level variables.
and since both a and b from the previous example are 2 different objects, there is no question of the static variable being shared between the objects.
The variable is static with respect to the function and not the class.
sam

mega-squall
In addition to sami's comment :
`static` keyword for class method is considered a compatibility feature in PHP5. In PHP6 however, calling an instance method (not defined using `static`) as a class method (using `class::method()` ) will display an EWarning. Also note that in PHP6, calling a class method (defined using `static`) as an instance method (using `$instance->method()`) will ALSO display an EWarning.

franp
If you want to access a table row using $GLOBALS, you must do it outside string delimiters or using curl braces :
$siteParams["siteName"] = "myweb";
function foo() {
$table = $GLOBALS["siteParams"]["siteName"]."articles";  // OK
echo $table; // output  "mywebarticles"
$table = "{$GLOBALS["siteParams"]["siteName"]}articles"; // OK
echo $table; // output  "mywebarticles"
$table = "$GLOBALS[siteParams][siteName]articles";       // Not OK
echo $table; // output  "Array[siteName]article"
$result = mysql_query("UPDATE $table ...");
}
Or use global :
function foo() {
global $siteParams;
$table = "$siteParams[siteName]articles";         // OK
echo $table; // output  "mywebarticles"
$result = mysql_query("UPDATE $table ...");
}

pulstar
If you need all your global variables available in a function, you can use this:
<?php
function foo(parameters) {
 if(version_compare(phpversion(),"4.3.0")>=0) {
   foreach($GLOBALS as $arraykey=>$arrayvalue) {
     global $$arraykey;
   }
 }
 // now all global variables are locally available...
}
?>

kouber
If you need all your global variables available in a function, you can use this:
<?
function foo() {
 extract($GLOBALS);
 // here you have all global variables
}
?>

shevek
If you include a file from within a function using include(), the included file inherits the function scope as its own global scope, it will not be able to see top level globals unless they are explicit in the function.
$foo = "bar";
function baz() {
global $foo; # NOTE THIS
include("qux");
}

jez
If anyone needs a permanent array / hash, similar in functionality to ASP's application object, check out the article on
http://zez.org/article/articleview/46/1/
which has some working code (written by me) attached. This code implements a hash with application scope, i.e. its contents can be accessed from all php scripts running on the same computer. You could use it, for example, to globally cache configuration settings for a site.

The hash is also cached in the db, i.e. it's inviolable. Its contents are buffered in memory, so there's no hit on the db when accessing the hash apart from the first time you read it, and of course when you write to it.

www dot php dot net dot 2nd
I've been doing some performance tests. I thought I could squeeze some extra cyles using references, but I discovered they are more mysterious than I imagined (5.0.3).
Consider this:
$a = str_repeat('hola',10000000);
for($n = 0 ; $n < 1000000 ; $n++ ) { $b = $a; unset($b); }
real    0m1.514s
user    0m1.433s
sys     0m0.071s
The above times (as others in this note) are the best out of three attempts in an idle Linux box.
I expected the above to be a bit slow, since constructing $b might imply copying the 40MB string each time. It was very fast, though. Let's try with references:
$a = str_repeat('hola',10000000);
for($n = 0 ; $n < 1000000 ; $n++ ) { $b =& $a; unset($b); }
real    0m1.488s
user    0m1.380s
sys     0m0.071s
Not much of a gain, but it did took less time to complete. Will this work with functions? Let's see:
$a = str_repeat('hola',10000000);
for($n = 0 ; $n < 1000000 ; $n++ ) dosome($a);
function dosome($arg){ $t = strlen($arg); }
real    0m3.518s
user    0m3.276s
sys     0m0.088s
Mmm... much slower, but still pretty nice. I didn't use references yet, so let's try them out:
$a = str_repeat('hola',10000000);
for($n = 0 ; $n < 100 ; $n++ ) dosome($a);
function dosome(&$arg){ $t = strlen($arg); }
real    0m12.071s
user    0m6.190s
sys     0m5.821s
You think it is 3.5 times slower? Think again. It is 350,000 times slower. I had to limit the $n loop to 100 iterations in order to get those figures! I wonder what happens if I try to access the variable globally:
$a = str_repeat('hola',10000000);
for($n = 0 ; $n < 1000000 ; $n++ ) dosome();
function dosome(){ $t = strlen($GLOBALS['a']); }
real    0m3.007s
user    0m2.918s
sys     0m0.074s
Notice that using $GLOBALS we're back in bussiness. So using the global keyword should be exactly the same, isn't it? Wrong again:
$a = str_repeat('hola',10000000);
for($n = 0 ; $n < 100 ; $n++ ) dosome();
function dosome(){ global $a; $t = strlen($a); }
real    0m12.423s
user    0m6.112s
sys     0m5.917s
We're in the '350,000 times slower' domain again. I wonder why the script is spending so much time in sys.
A couple of additional tests to complete the puzzle:
$a = str_repeat('hola',10000000); $b = Array(&$a);
for($n = 0 ; $n < 100 ; $n++ ) dosome();
function dosome(){ $t = strlen($GLOBALS['b'][0]); }
real    0m12.087s
user    0m6.068s
sys     0m5.955s
$a = str_repeat('hola',10000000); $b = Array(&$a);
for($n = 0 ; $n < 100 ; $n++ ) dosome();
function dosome(){ global $b; $t = strlen($b[0]); }
real    0m12.158s
user    0m6.023s
sys     0m5.971s
I guess the $GLOBALS trick doesn't help when we access a reference stored in the global variable.
I'm completely confused, now. At this light, I will review my usage of the global keyword as well as for the references. I hope someone can benefit from this study too.

steph_rondinaud
I'm using PHP 4.1.1
While designing a database access class, I needed a static variable that will be incremented for all instances of the class each time the class connected to the database. The obvious solution was to declare a "connection" class variable with static scope. Unfortunatly, php doesn't allow such a declaration.
So I went back to defining a static variable in the connect method of my class. But it seems that the static scope is not inherited: if class "a" inherit the "db access" class, then the "connection" variable is shared among "a" instances, not among both "a" AND "db access" instances.
Solution is to declare the static variable out of the db access class, and declare "global" said variable in the connect method.

flobee
i found out that on any (still not found) reason the <?php static $val =NULL; ?> is not working when trying to extract the data form the $var with a while statment
e.g.:
<?php
funktion get_data() {
static $myarray = null;
  if($myarray == NULL) {
    //get some info in an array();
    $myarray = array('one','two');
  }
  while(list($key,$val) = each( $myarray ) ) {
  // do something
  echo "x: $key , y: $val";
  }
}
?>
when using foreach($myarray AS $key => $val) { .... instad of while then i see the result!

ppo
Even if an included file return a value using return(), it's still sharing the same scope as the caller script!
<?php
$foo = 'aaa';
$bar = include('include.php');
echo($foo.' / '.$bar);
?>
where include.php is
<?php
$foo = 'bbb';
return $foo;
?>
The output is: bbb / bbb
Not: aaa / bbb

michael
davo971 (http://us2.php.net/manual/en/language.variables.scope.php#69765), it seems you're encountering the same mental block that jason (http://us2.php.net/manual/en/language.variables.scope.php#65337) was having.  I know how that goes, because I used to have this problem as well.  Don't think of permission to access a variable as being transferred from function to function.  There is exactly 1 global scope in any script, and that's the scope outside of all functions and classes.  If you specify a variable as global, it does not mean you are accessing a variable in the calling function's namespace, it means you are accessing the variable in the global namespace.  In your example, you seemed to think that declaring $new_var global in function2() would give it access to variables declared in function1()'s namespace.  In fact, acess to variables does not propagate up the function stack--declaring you wish to work on a global variable ALWAYS gives you access to the SINGLE variable declared in the global namespace with that name.  It's more easily understood when you work with the $GLOBALS array... there's only 1 such array, and consequently there's exactly 1 of each global variable.  So if we modify your example to work correctly, here's what it'll look like:
<?php
$var = 'foo';
$new_var = 'asdf';
function function1()
{
  global $new_var; //Now working with global $new_var, declared above
  $new_var = 'bar'; //Changing $new_var from 'asdf' to 'bar'
  function2();
}
function function2()
{
  global $var, $new_var; //Accessing global variables $var and $new_var, declared outside any functions
  echo($var . $new_var);
}
function1();
?>
Outputs foobar

jeanrobert
Comment on May 21.
This explanation does not explain why assigning a global variable
reference to a globalvariable does not modify it (See the statement
"$testvar =  &$testvar2" bellow).
Here is my own explanation:

Inside a function, if we assign a variable reference to a global
variable then this global variable is replaced by a new local
variable instance. In other words, once done, futur assignment to
this variable will only modify the local copy and leave the original
global variable unchanged. Looking at the following code will
help you to understand it. (Just as a reminder $GLOBALS[testvar]
always refers to the original $testvar global variable).
$testvar = 1 ;
$testvar2 = 2 ;
function foo ()
{
  global $testvar ;
  global $testvar2 ;
  $testvar =  3 ; //Assigning a constant works as expected.
  echo "$testvar,$GLOBALS[testvar] " ;   // 3,3
  $testvar =  4 ; //Assigning a variable also works as expected.
  echo "$testvar,$GLOBALS[testvar] " ;   // 4,4
  $testvar =  &$testvar2 ; // Assiging a reference allocates a new
   // local testvar instance.
  echo "$testvar,$GLOBALS[testvar] " ;   // 2,4
  $testvar=5 ; // Assigning a value to testvar now only modifies
// the local instance.
  echo "$testvar,$GLOBALS[testvar]" ;    //5,4
}
foo() ;
If you plan to assign a variable reference to a global variale then
you should use '$GLOBALS[testvar]=&$variable' instead of
'$testvar=&$variable'.

cellog
comment on april 9 regarding:
function foo ()
{
  global $testvar;
  $localvar = new Object ();
  $testvar = &$localvar;
}
The reason this doesn't work is that when you use & to assign to $testvar, it reassigns $testvar to point at what $localvar points at.
$testvar = $localvar should work as well as $GLOBALS['testvar'] = &$localvar, although instance data will be copied and any references to parent classes will be broken.  I hate that :).
In other words, the declaration "global $testvar;" is telling php "make $testvar point at the same location as $GLOBALS['testvar']" but "$testvar = &$localvar" tells php "make $testvar point at the same location as $localvar"!!!

mod
Can not access to global variables from destructor, if obj is not unseted at the end:
<?php
 class A
  {
    function __destruct()
     {
       global $g_Obj;
       echo "
#step 2: ";
       var_dump($g_Obj);
     }
    function start()
     {
       global $g_Obj;
       echo "
#step 1: ";
       var_dump($g_Obj);
     }
  };
 $g_Obj = new A(); // start here
 $g_Obj->start();
 $g_Obj = NULL; // !!! comment line and result will changed !!!
?>
Result, if line is not commented:
#step 1: object(A)#1 (0) { }
#step 2: object(A)#1 (0) { }
Result, if line is commented:
#step 1: object(A)#1 (0) { }
#step 2: NULL

wjs@sympaticodotca
Becareful where you define your global variables:
This will work:
<?php
 $MyArray = array("Dog");
 function SeeArray(){
   global $MyArray;
   if (in_array("Dog",$MyArray)){
     foreach ($MyArray as $Element){
       echo "$Element <hr/>";
     }
   }
 }
 SeeArray();
?>
while this will not:
<?php
 SeeArray();
 $MyArray = array("Dog");
 function SeeArray(){
   global $MyArray;
   if (in_array("Dog",$MyArray)){ // an error will generate here
     foreach ($MyArray as $Element){
       echo "$Element <hr/>";
     }
   }
 }
?>

vdephily
Be carefull about nested functions :
<?php
// won't work :
function foo1()
{
 $who = "world";
 function bar1()
 {
   global $who;
   echo "Hello $who";
 }
}
// will work :
function foo2()
{
 $GLOBALS['who'] = "world";
 function bar2()
 {
   global $who;
   echo "Hello $who";
 }
}
// also note, of course :
function foo3()
{
 $GLOBALS['who'] = "world";
 // won't work
 echo "Hello $who";
 // will work
 global $who;
 echo "Hello $who";
}
?>

davo971
Be careful, come across this a lot.
<?php
$var = 'foo';
function function1()
{
   global $var;
   $new_var = 'bar';
   function2();
}
function function2()
{
   global $var, $new_var;
   echo($var . $new_var);
}
function1();
?>
Outputs foo not foobar.

thomas
Be careful with "require", "require_once" and "include" inside functions. Even if the included file seems to define global variables, they might not be defined as such.
consider those two files:
---index.php------------------------------
function foo() {
require_once("class_person.inc");
$person= new Person();
echo $person->my_flag; // should be true, but is undefined
}
foo();
---class_person.inc----------------------------
$seems_global=true;
class Person {
 public $my_flag;
public function  __construct() {
  global $seems_global;
  $my_flag= $seems_global
}
}
---------------------------------
The reason for this behavior is quiet obvious, once you figured it out. Sadly this might not be always as easy as in this example. A solution  would be to add the line...
global $seems_global;
at the beginning of "class_person.inc". That makes sure you set the global-var.
  best regards
   tom
ps: bug search time approx. 1 hour.

27-apr-2005 12:46
Be careful if your static variable is an array and you return
one of it's elements: Other than a scalar variable, elements
of an array are returned as reference (regardless if you
didn't define them to be returned by reference).
<?php
function incr(&$int) {
 return $int++;
}
function return_copyof_scalar() {
 static $v;
 if (!$v)  
   $v = 1;
 return($v);
}
function return_copyof_arrayelement() {
 static $v;
 if (!$v) {
   $v = array();
   $v[0] = 1;
 }
 return($v[0]);
}
echo "scalar: ".
    incr(return_copyof_scalar()).
    incr(return_copyof_scalar()).
    "\n";
echo "arrayelement: ".
    incr(return_copyof_arrayelement()).
    incr(return_copyof_arrayelement()).
    "\n";
?>
Should print
scalar: 11
arrayelement: 11
but it prints:
scalar: 11
arrayelement: 12
as in the second case the arrays element was returned by
reference. According to a guy from the bug reports the
explanation for this behaviour should be somewhere here in
the documentation (in 'the part with title: "References with
global and static variables"'). Unfortunately I can't find
anything about that here. As the guys from the bug reports
are surely right in every case, maybe there is something
missing in the documentation. Sadly I don't have a good
explanation why this happens, so I decided to document at
least the behaviour.

aslak
Basicly what happens is this:
$var t;
function foo()
{
 global $t;
}
is identical to:
function foo()
{
 $t=&$GLOBALS[t];
}
which will answer the above argument becouse when you use
$t=&$somelocal;
you overwrite the first $t=&.....

stlawson
aslak is right!  Check this out:
$t1 = "outie";
function foo1()
{
 global $t1;
 $t1 = 'innie' ;
 echo ('in foo1() $t1 is an ' . $t1) ;
}
echo ('before foo1() $t1 is an ' . $t1) ;
foo1() ;
echo ('after foo1() $t1 is an ' . $t1) ;
// is identical to?:
$t2 = "outie";
function foo2()
{
 $t2 = &$GLOBALS['t2'];
 $t2 = 'innie' ;
 echo ('in foo2() $t2 is an ' . $t2) ;
}
echo ('before foo2() $t2 is an ' . $t2) ;
foo2() ;
echo ('after foo2() $t2 is an ' . $t2) ;
Output:
before foo1() $t1 is an outie
in foo1() $t1 is an innie
after foo1() $t1 is an innie
before foo2() $t2 is an outie
in foo2() $t2 is an innie
after foo2() $t2 is an innie
Also I cleaned up aslak's code a bit ;)

04-mar-2003 03:25
As far as I can see, it's not possible to unset() a static variable inside the function:
function Test($unset = false) {
static $a = 0;
echo $a++;
if ($unset) unset($a);
}
Test();
Test();
Test(true);
Test();
Test();
This will output 01234. I would expect it to at least show 01201.

crack wilding
Another way of dealing with a large number of globals is to declare a single global array and then put all your global variables into it. Like this:
$_G = array(
   'foo' => 'some text',
   'bar' => 4,
   'boo' => 'more text,
   'far' => 'yet more text'
);
Now you just declare the one global array in each function:
function blah() {
   global $_G;
   echo $_G['foo']; // or whatever
}
You can freely add to it without having to go back and add variable declarations to your functions. Kinda like using the $GLOBALS superglobal, except you don't have to  type so much.

jack
Alright, so you can't set a static variable with a reference.
However, you can set a static variable to an array with an element that is a reference:
<?php
class myReference {
   function getOrSet($array = null) {
       static $myValue;
       if (!$array) {
           return $myValue[0];     //Return reference in array
       }
       $myValue = $array;          //Set static variable with array
       static $myValue;
   }
}
$static = "Dummy";
$dummy = new myReference;
$dummy->getOrSet(array(&$static));
$static = "Test";
print $dummy->getOrSet();
?>

daniel
Ah, nested functions.  Thanks for your notes below, search on  page for "nested functions" folks.   This is how this seems to work.
The child function is seen at global level only after they have been seen once.  But, variables inside functions are only reachable within the functions scope.
<?php
$var1 = "This is \$var1 OUTSIDE parent function <br />";
function parent_function() {
   echo "Now inside parent <br />";
   $var1 = "This is \$var1 INSIDE parent function <br />";
   $var2 = "This is \$var2 INSIDE parent function <br />";
   function child_function() {
       echo "now inside child <br />";
       //global $var1; //Calls var1 outside parent_function;
       echo $var1; //doesn't work without global;
       // even if we comment out $var1 outside parent function.
       // global $var1 doesn't reach the one inside parent function.
       echo $var2; //doesn't work; Can't seem to reach parent variables.
   }
   echo "Now calling child<br />";
   //child_function();    //works
}
// child_function(); //causes fatal error: call to undefined function;
parent_function();  //works;
child_function(); //now works;
?>

12-mar-2007 08:13
addendum to warhog at warhog dot net
about static variables within methods
<?php
class A
{
   function incStaticVar()
   {
       static $var = 0;
       $var++;
       return $var;
   }
}
class B extends A
{
}
$a =& new A();
$b =& new B();
print_r(array(
   $a->incStaticVar(),
   $b->incStaticVar(),
   $a->incStaticVar(),
));
?>
expected result
Array
(
   [0] => 1
   [1] => 2
   [2] => 3
)
real result
Array
(
   [0] => 1
   [1] => 1
   [2] => 2
)
So I conclude that the PHP5 duplicates methods for each inherited classes.

zapakh
Addendum to the post by tc underline at gmx TLD ch, on unsetting global variables from inside functions:
If setting to null is not a suitable substitute for unset() in your application, you can unset the global variable's entry in the $GLOBALS superglobal.
<?php
function testc()
{
 global $a;
 echo "  inner testc: $a\n";
 unset($GLOBALS['a']);
 echo "  inner testc: $a\n";
}
$a = 5678;
echo "<pre>";
echo "outer: $a\n";
testc();
echo "outer: $a\n";
echo "</pre>\n";
?>
/***** Output:
outer: 5678
 inner testc: 5678
 inner testc: 5678
outer:
******/
If the behavior of testc (or testa or testb, for that matter) seems surprising, consider that the use of the 'global' keyword simply performs an assignment by reference.  In other words,
<?php
 global $a;              //these two lines
 $a =& $GLOBALS['a'];    //are equivalent.
?>
If you've read http://php.net/references , then everything behaves as you'd expect.

larax
About more complex situation using global variables..
Let's say we have two files:
a.php
<?php
function a() {
include("b.php");
}
a();
?>
b.php
<?php
$b = "something";
function b() {
global $b;
$b = "something new";
}
b();
echo $b;
?>
You could expect that this script will return "something new" but no, it will return "something". To make it working properly, you must add global keyword in $b definition, in above example it will be:
global $b;
$b = "something";

sasq
<?php
I use PHP 4.3 and it's impossible to assign a variable or function result to a static variable :-(  Example:
function SomeFunction()
{
$LocalVar = 5;
static $MyStaticVar1 = some_function();  //ERROR
static $MyStaticVar2 = $LocalVar            //ERROR
static $MyStaticVar3 = 7;                       //OK
return $MyStaticVar3++;
}
It's a little annoying, because in some cases the value of static variables aren't necessarily known at the moment of their initialisation. And sometimes it's required to be a value returned by some function or a value of some other function created earlier. Unfortunately, the moment of the initialization is the only moment, when this kind of assignment is possible to execute only on the first time the function is called.
?>

sid trivedi
<?php
/*
VARIABLE SCOPE : GLOBAL V/S STATIC
If variable $count is defined global as under, instead of static, it does not work well as desired in repeated function calls.
$count = 1; //if not defined STATIC, in each function call, it starts countig from one to 25.
global $count;
which gives folowing output:
0123456789101112131415161718192021222324
Total 24 numbers are printed.
So far 26 function call(s) made.
26272829303132333435363738394041424344454647484950
Total 50 numbers are printed.
So far 52 function call(s) made.
*/
function print_1to50()
{
// $count = 1;
// global $count;
static $count=1; // Initial assigment of One to $count, static declarion holds the last(previous) value of variable $count in each next function calls.
       $limit = $count+24;
       while($count<=$limit)
       {
       echo "$count";
       $count=$count+1;
       }
       $num_count= $count-1;
       echo "
\n". "Total $num_count numbers are printed.
";
       return; // return statement without parenthesis()or arguments denotes end of a function rather than returning any values to subsequent function call(s).
} // end of while loop
$count=0;
print_1to50();
$count=$count+1;
print "So far $count function call(s) made.
";
print_1to50();
$count=$count+1;
print "So far $count function call(s) made.
";
/*
Which gives following output:
12345678910111213141516171819202122232425
Now I have printed 25 numbers.
I have made 1 function call(s).
26272829303132333435363738394041424344454647484950
Now I have printed 50 numbers.
I have made 2 function call(s).
*/
?>

rohan
<?php
$a = 20;
function myfunction($b){
$a=30;   //Local Variable
global $a,$c; //here global $a overrides the local
return $c=($b+$a);
}
print myfunction(40)+$c;
?>
The output of this function will be 120.

s dot radovanovic
<?php
function __constructor($configfile = '', $blnSingleton = true) {
//We must define a static array that contains our reference(s) to the object(s)
static $arrSingletonObject = array();

//We also need to specify a static local member, that keeps track of the last
//initialize configfile, so that we can use this if no file has been specified
//(this way we enable it for the initializor, to work with a previously initialized
//config object, without knowing what configfile it uses
static $lastConfigfile;

if(!empty($configfile)) {
//Store the set configfile name in the static local member
$lastConfigfile = $configfile;

} else if(!empty($lastConfigfile)) {

//If the configfile was empty, we retrieve it from the last known initialized
$configfile = $lastConfigfile;

} else {
//if we've reached so far, it means no configfile has been set at all (now
//or previously), so we cannot continue
trigger_error("No configfile has been specified.", ERROR);

//Return (instead of an exit (or die)) so that the constructor isn't continued
return;
}

//Set the configuration file
$this->_configfile = $configfile;

//Only if we want to use singleton we may proceed
if($blnSingleton) {

//We must now check to see if we already have a reference to the (to be created) config
//object
if(!isset($arrSingletonObject[$this->_configfile])) {
//Create of reference of myself, so that it can be added to the singleton object array
$arrSingletonObject[$this->_configfile] = &$this;

//We can now proceed and read the contents of the specified ini file
$this->_parseIniFile();

} else {
//Associate myself with the reference of the existing config object
$this = $arrSingletonObject[$this->_configfile];
}
}
}
?>

j
> pim wrote:
> in addition:
> if you define a function in that included file, it can't get
> the variables from the inluded file's scope. global won't work.
> The only way to give such an include function access to global
> vars is via arguments. I don't know if this is a bug in PHP.
>
> //---- from within function included file -----
> echo $var1; // this one works
> function foo()
> {
> global $var1;
> echo $var1; // this one doesn't
> }
It works if you additionally declare the variables from the inluded file's scope as global.
example:
<?php
/* file1.php */
function func1() {
   include("file2.php");
   func2();
}
func1();
?>
<?php
/* file2.php */
global $var; // declare as global here
$var = 'something';
function func2() {
   global $var; // again here
   echo $var; // prints "something"
}
?>

Change Language


Follow Navioo On Twitter
Basics
Predefined variables
Variable scope
Variable variables
Variables from outside PHP
Terms of Service Privacy Policy Sitemap

©2024 -EPSILONSYS SOFTWARE inc

Other EPSILONSYS SOFTWARE Web Sites : Programming Resources | News Headline | Free local classifieds

eXTReMe Tracker