Question
why the unset function is different between global and $GLOBALS ?
here is my code , the $GLOBALS version will echo nothing ,but the global will echo "hi".
//$GLOBALS version
<?php
function foo()
{
unset($GLOBALS['bar']);
}
$bar ="hi";
foo();
echo $bar;
?>
the code above echo nothing
but when i change $GLOBALS['bar'] to global $bar ,it echo "hi"
//global version
<?php
function foo()
{
global $bar;
unset($bar);
}
$bar = "hi";
foo();
echo $bar;
?>
I have search in google and php manual , but it seems not detail about this problem .
what is the difference between GLOBALS and GLOBAL?
A true global variable imported inside a function scope with the global statement actually creates a reference to the global variable. When you use unset() it unsets the variable that is referencing the global variable, the same as other references. When you unset the reference, you just break the binding between variable name and variable content. This does not mean that variable content will be destroyed. For example:
$a = 1;
//assign a reference to $a
$b =& $a;
unset($b);
var_dump($a);
Yields: int(1) See Unsetting References.
When you access $GLOBALS you are accessing a superglobal array and unsetting the actual variable contained in the array.
Related
Why is $a not printing?
And what is the alternate of this, and I dont want to use return.
function abc () {
$a = 'abc';
global $a;
}
abc();
echo $a;
The reason why it's not echoing is because of two things:
1) You need to declare global "before" the variable you wish to define as being global.
and
2) You also need to call the function.
Rewrite:
<?php
function abc()
{
global $a;
$a = 'abc';
}
abc();
echo $a;
For more information on variable scopes, visit the PHP.net website:
http://www.php.net/manual/en/language.variables.scope.php
You can get your variable as:
echo $GLOBALS['a'];
see http://php.net/manual/en/language.variables.scope.php
You can use define():
function abc() {
define("A", "abc");
}
abc();
echo A;
Make sure you call the function. I added that just above echo.
First you must create and assign a variable. And then in you function describe that is a global var you want to use.
$a = 'zxc';
function abc() {
global $a;
$a = 'abc';
}
abc();
echo $a;
This is not really good idea to use golbal such way. I don't really understand why I so much want to use a global var...
But my opinion is better for you to use a pointer to variable.
function abc(&$var){
$var = 'abc';
}
$a = 'zxc';
abc(&$a);
echo $a;
Or even would be better to create an object and then access variable with-in this object
The following code produces a warning:
<?php
$GLOBALS['foo'] = "Example content<BR><BR>";
echo $foo; // that works!
Test();
function Test()
{
echo $foo; // that doesn't work!
}
?>
The warning is:
Notice: Undefined variable: foo
How come ?
Inside the function, $foo is out of scope unless you call it as $GLOBALS['foo'] or use global $foo. Defining a global with $GLOBALS, although it improves readability, does not automatically reserve the variable name for use in all scopes. You still need to explicitly call the global variable inside lower scopes to make use of it.
function Test()
{
echo $GLOBALS['foo'];
// Or less clear, use the global keyword
global $foo;
echo $foo;
}
It's even possible to have both a local and a global $foo in the same function (though not at all recommended):
$GLOBALS['foo'] = "foo! :)";
function getFoo()
{
$foo = "boo :(";
echo $GLOBALS['foo'] . "\n"; // Global $foo
echo $foo; // Local scope $foo since it has no global keyword
}
getFoo();
// foo! :)
// boo :(
Review the PHP documentation on variable scope and the $GLOBALS documentation for more examples.
You will need to refer to it via the $GLOBALS array all the time. Read about variable scope to get the full descriptve answer.
<?php
$GLOBALS['foo'] = "Example content<BR><BR>";
echo $foo; // that works!
Test();
function Test()
{
echo $GLOBALS['foo']; // that doesn't work!
}
?>
you can change your code to:
function Test() {
global $foo;
echo $GLOBALS['foo'];
echo $foo;
}
you have to declare which global variables you access from your PHP function. See: http://php.net/manual/en/language.variables.scope.php
What exactly is the difference between the GLOBAL and STATIC variables in PHP? And which one is preferable to use, when we want to use a variable in multiple functions?
Thanks.
A static variable just implies that the var belongs to a class but can be referenced without having to instantiate said class. A global var lives in the global namespace and can be referenced by any function in any class. Global vars are always frowned upon because they're so easily misused, overwritten, accidentally referenced, etc. At least with static vars you need to reference via Class::var;
Global is used to get the global vars which may be defined in other scripts, or not in the same scope.
e.g.
<?php
$g_var = 1;
function test() {
var_dump($GLOBAL['g_var']);
global $g_var;
var_dump($g_var);
}
Static is used to define an var which has whole script life, and init only once.
e.g.
<?php
function test() {
static $cnt = 0;
$cnt ++;
echo $cnt;
}
$i = 10;
while (-- $i) {
test();
}
A global variable is a variable which is defined in a scope and can span to included and required scopes. (in simple terms by scope I mean the php file/function/class)
Here are some examples of how global variables work.
Example 1: Variable declared in scope and used in function using global keyword
<?php
$a = 1;
function add_a() {
global $a;
$a++;
}
add_a();
echo $a;
In the above example we declare variable $a and assign it value 1 in the scope. We then declare a function add_a in the same scope and try to increment the $a variable value. The add_a function is called and then we echo the $a variable expecting the result to display 2.
Example 2: Variable declared in scope and used in function using the $GLOBALS variable
<?php
$a = 1;
function add_a() {
$GLOBALS['a']++;
}
add_a();
echo $a;
The result from example 2 above is exactly the same as the result from example 1.
There is no difference with using the global keyword and the special PHP defined $GLOBALS array variable. However they both have their advantages and disadvantages.
Read more about $GLOBALS on official PHP website $GLOBALS
If you want to span a scope declared variable to a included or required scope see example below.
Example 3:
file a.php
<?php
global $a;
$a = 1;
require 'b.php';
add_a();
echo $a;
file b.php
<?php
function add_a() {
global $a;
$a++;
}
In the above example we have file a.php and b.php. File b.php is required in file a.php because we use a function declared in file b.php. To use the $a variable in file b.php we must first declare $a as global to be used outside the local scope and we do this by first calling global $a and then we define a value like so $a = 1. Variable $a is now available to be used anywhere in any included scopes by first calling global $a before manipulation.
Static Variables
Usually found in classes but in some well developed PHP project you can find them in recursive functions. A static variable is a variable that remembers its value and can be reused every time the function or method is called.
Here are some examples of a static variable in use.
Example 1: Static variable in a function
function add() {
static $a = 1;
$a++;
echo $a;
}
add(); //2
add(); //3
add(); //4
Example 2: Static variable in class
class A {
public static $a = 1;
public static function add() {
self::$a++;
echo self::$a;
}
}
echo A::$a; //1
A::add(); //2
echo A::$a; //2
A::add(); //3
echo A::$a; //3
A::add(); //4
Note that you cannot assign a return value from a function to a static variable. For example you cannot do static $a = rand(). See Example 3 below on how to assign return value to static variable.
Example 3: Assign return variable from function to static variable
function add() {
static $a;
$a = rand();
echo $a;
}
Read more about global and static variables on PHP official website Variable scope
Global variable is created before the function is created, but global keyword is added in function
$g_var = 1;
function test() {
var_dump($GLOBAL['g_var']);
global $g_var;
var_dump($g_var);
}
static is created and declared static in function
function test() {
static $cnt = 0;
$cnt ++;
echo $cnt;
}
$i = 10;
while(--$i) test();
I have a problem with the below:-
//index.php
<?php
define('PATH','Ajfit/');
/* Get all the required files and functions */
require(PATH . 'settings.inc.php');
require(PATH . 'inc/common.inc.php');
?>
//setting.inc.php
<?php
$settings['language']='English';
?>
//inc/common.inc.php
<?php
//global $settings, $lang, $_SESSION; //$setting = null????
$language = $settings['language']; //$language is still null
?>
when i try and access the global variable $settings within common.inc.php it is set null even though i set the variable within setting.inc.php. If i debug, when i step out of setting.inc.php the $settings valiable is set within the index.php, however when i step into common.inc.php the $settings valiable is set to null.
Does anyone have any ideas?
Answer: In the inc/common.inc.php file, you don't need to use the global keyword, the variable is already accessible. Using global redefines the variable, and is thus made null.
Explanation:
Variable Scope is the key here. The global keyword is only required when scope changes. The scope of regular files (including include()s) is all the same, so all of your variables are accessible by any php in the same scope, even if it comes from a different file.
An example of where you need to use global is inside of functions. The scope of a function is different than that of plain php, which is different from class scope, and so on.
Example:
//foo.php
$foo = "bar";
echo $foo; //prints "bar" since scope hasn't changed.
function zoo() {
echo $foo; //prints "" because of scope change.
}
function zoo2() {
global $foo;
echo $foo; //prints "bar" because $foo is recognized as in a higher scope.
}
include('bar.php');
//bar.php
echo $foo; //prints "bar" because scope still hasn't changed.
function zoo3() {
echo $foo; //prints "" for the same reason as in zoo()
}
function zoo4() {
global $foo;
echo $foo; //prints "bar" for the same reason as in zoo2()
}
More Information:
If you want more information on when to use global and when not to, check the php.net documentation on variable scope.
I have two PHP files. In the first I set a cookie based on a $_GET value, and then call a function which then sends this value on to the other file. This is some code which I'm using in join.php:
include('inc/processJoin.php');
setcookie("site_Referral", $_GET['rid'], time()+10000);
$joinProc = new processJoin();
$joinProc->grabReferral($_COOKIE["site_Referral"]);
The other file (processJoin.php) will then send this value (among others) to further files which will process and insert the data into the database.
The problem I'm having is that when the grabReferral() function in processJoin.php is called, the $referralID variable isn't being defined on a global scale - other functions in processJoin.php can't seem to access it to send to other files/processes.
I've tried this in processJoin.php:
grabReferral($rid) {
global $ref_id;
$ref_id = $rid;
}
someOtherFunction() {
sendValue($ref_id);
}
But the someOtherFunction can't seem to access or use the $ref_id value. I've also tried using define() to no avail. What am I doing wrong?
you have to define the global var in the second function as well..
// global scope
$ref_id = 1;
grabReferral($rid){
global $ref_id;
$ref_id = $rid;
}
someOtherFunction(){
global $ref_id;
sendValue($ref_id);
}
felix
personally, I would recommend the $GLOBALS super variable.
function foo(){
$GLOBALS['foobar'] = 'foobar';
}
function bar(){
echo $GLOBALS['foobar'];
}
foo();
bar();
DEMO
This is a simple and working code to initialize global variable from a function :
function doit()
{
$GLOBALS['val'] = 'bar';
}
doit();
echo $val;
Gives the output as :
bar
The following works.
<?php
foo();
bar();
function foo()
{
global $jabberwocky;
$jabberwocky="Jabberwocky<br>";
bar();
}
function bar()
{
global $jabberwocky;
echo $jabberwocky;
}
?>
to produce:
Jabberwocky
Jabberwocky
So it seems that a variable first declared as global inside a function and then initalised inside that function acquires global scope.
The global keyword lets you access a global variable, not create one. Global variables are the ones created in the outermost scope (i.e. not inside a function or class), and are not accessible inside function unless you declare them with global.
Disclaimer: none of this code was tested, but it definitely gets the point across.
Choose a name for the variable you want to be available in the global scope.
Within the function, assign a value to the name index of the $GLOBALS array.
function my_function(){
//...
$GLOBALS['myGlobalVariable'] = 42; //globalize variable
//...
}
Now when you want to access the variable from code running in the global scope, i.e. NOT within a function, you can simply use $ name to access it, without referencing the $GLOBALS array.
<?php
//<global scope>
echo $myGlobalVariable; //outputs "42"
//</global scope>
?>
To access your global variable from a non-global scope such as a function or an object, you have two options:
Access it through the appropriate index of the $GLOBALS array. Ex: $GLOBALS['myGlobalVariable'] This takes a long time to type, especially if you need to use the global variable multiple times in your non-global scope.
A more concise way is to import your global variable into the local scope by using the 'global' statement. After using this statement, you can reference the global variable as though it were a local variable. Changes you make to the variable will be reflected globally.
//<non global scopes>
function a(){
//...
global $myGlobalVariable;
echo $myGlobalVariable; // outputs "42"
//...
}
function b(){
//...
echo $GLOBALS['myGlobalVariable']; // outputs "42"
echo $myGlobalVariable; // outputs "" (nothing)
// ^also generates warning - variable not defined
//...
}
//</non global scopes>
Please use global variables in any language with caution, especially in PHP.
See the following resources for discussion of global variables:
http://chateau-logic.com/content/dangers-global-variables-revisited-because-php
http://c2.com/cgi/wiki?GlobalVariablesAreBad
The visibility of a variable
I hope that helped
<?php
$a = 1;
$b = 2;
function Sum()
{
global $a, $b;
$b = $a + $b;
}
Sum();
echo $b;
?>