Author: saqibkhan

In PHP, any variable that can be accessed from anywhere in a PHP script is called as a global variable. If the variable is declared outside all the functions or classes in the script, it becomes a global variable.

While global variables can be accessed directly outside a function, they aren’t automatically available inside a function.

Example

In the script below, $name is global for the function sayhello().

Open Compiler

<?php
   $name = "Amar";
   function sayhello() {
  echo "Hello " . $name;
   }
   sayhello();
?>

However, the variable is not accessible inside the function. Hence, you will get an error message “Undefined variable $name”.

Hello 
PHP Warning: Undefined variable $name in /home/cg/root/93427/main.php on line 5

Example

To get access within a function, you need to use the “global” keyword before the variable.

Open Compiler

<?php
   $name = "Amar";
   function sayhello() {
  GLOBAL $name;
  echo "Hello " . $name;
   }
   sayhello();
?>

It will produce the following output −

Hello Amar

If a function accesses a global variable and modifies it, the modified value is available everywhere after the function call is completed.

Let us change the value of $name inside the sayhello() function and check its value after the function is called.

Explore our latest online courses and learn new skills at your own pace. Enroll and become a certified expert to boost your career.

Example

Take a look at this following example −

Open Compiler

<?php
   $name = "Amar";
   function sayhello() {
  GLOBAL $name;
  echo "Global variable name: $name" .PHP_EOL;
  $name = "Amarjyot";
  echo "Global variable name changed to: $name" .PHP_EOL;
   }
   sayhello();
   echo "Global variable name after function call: $name" .PHP_EOL;
?>

It will produce the following output −

Global variable name: Amar
Global variable name changed to: Amarjyot
Global variable name after function call: Amarjyot

The $GLOBALS Array

PHP maintains an associative array named $GLOBALS that holds all the variables and their values declared in a global scope. The $GLOBALS array also stores many predefined variables called as superglobals, along with the user defined global variables.

Any of the global variables can also be accessed inside any function with the help of a regular syntax of accessing an arrow element. For example, the value of the global variable $name is given by $GLOBALS[“name”].

Example

In the following example, two global variable $x and $y are accessed inside the addition() function.

Open Compiler

<?php
   $x = 10;
   $y = 20;

   function addition() {
  $z = $GLOBALS&#91;'x']+$GLOBALS&#91;'y'];
  echo "Addition: $z" .PHP_EOL;
   }
   addition();
?>

It will produce the following output −

Addition: 30

Example

You can also add any local variable into the global scope by adding it in the $GLOBALS array. Let us add $z in the global scope.

Open Compiler

<?php
   $x = 10;
   $y = 20;
   function addition() {
  $z = $GLOBALS&#91;'x']+$GLOBALS&#91;'y'];
  $GLOBALS&#91;'z'] = $z;
   }
   addition();
   echo "Now z is the global variable. Addition: $z" .PHP_EOL;
?>

It will produce the following output −

Now z is the global variable. Addition: 30

Including One PHP Script in Another

You can include one PHP script in another. Variables declared in the included script are added in the global scope of the PHP script in which it is included.

Here is “a.php” file −

<?php
   include 'b.php';
   function addition() {
  $z = $GLOBALS&#91;'x']+$GLOBALS&#91;'y'];
  echo "Addition: $z" .PHP_EOL;
   }
   addition();
?>

It includes “b.php” that has the $x and $y variables, so they become the global variables for the addition() function in “a.php” script.

<?php
   $x = 10;
   $y = 20;
?>

Global variables are generally used while implementing singleton patterns, and accessing registers in embedded systems and also when a variable is being used by many functions.

Scope can be defined as the range of availability a variable has to the program in which it is declared. PHP variables can be one of four scope types −

• Local Variables
• Global Variables
• Static Variables
• Function Parameters

Local Variables

A variable declared in a function is considered local; that is, it can be referenced solely in that function. Any assignment outside of that function will be considered to be an entirely different variable from the one contained in the function −

Open Compiler

<?php
   $x = 4;
   
   function assignx () { 
  $x = 0;
  print "\$x inside function is $x. \n";
   }
   
   assignx();
   print "\$x outside of function is $x. \n";
?>

This will produce the following result −

$x inside function is 0. 
$x outside of function is 4. 

Arrow functions were introduced in PHP 7.4 version. Arrow functions provide a simpler and more concise syntax for writing anonymous functions. With PHP 7.4, a keyword “fn” has been introduced for defining arrow functions, instead of the conventional use of the “function” keyword.

fn(argument_list)=> expr

• There is only one expression after the “=>” symbol, and its value is the return value of the arrow function.
• The arrow function doesn’t have an explicit return statement.
• Like in the anonymous function, the arrow function is assigned to a variable for it to be called.

Example

The following example demonstrates how you can use the arrow function in PHP −

Open Compiler

<?php
   $add = fn ($a, $b) => $a + $b;

   $x = 10;
   $y = 20; 
   echo " x: $x y: $y Addition: " . $add($x, $y);
?>

It will produce the following output −

x: 10 y: 20 Addition: 30

Using the Arrow Function as a Callback Function

We can also use the arrow function as a callback function. Callback functions are used as one of the arguments of another function. The arrow function is executed on the fly and the value of the expression after “=>” becomes the argument of the parent function, which may be either a built-in or a user-defined function.

Example

In this example, we use an arrow function inside usort() function, a built_in function that sorts an array by values using a user-defined comparison function.

Open Compiler

<?php
   $arr = [10,3,70,21,54];
   usort ($arr, fn ($x , $y) => $x > $y);

   foreach ($arr as $x){
  echo $x . "\n";
   }
?>

It will produce the following output −

3
10
21
54
70

Explore our latest online courses and learn new skills at your own pace. Enroll and become a certified expert to boost your career.

Accessing Variables from the Parent Scope

Arrow functions can automatically access variables from the parent scope. Unlike the anonymous functions, the “use” keyword is not necessary for it to act as a closure. When a variable used in the expression is defined in the parent scope, it will be implicitly captured by-value.

Open Compiler

<?php
   $maxmarks=300;
   $percent=fn ($marks) => $marks*100/$maxmarks;

   $m = 250;
   echo "Marks = $m Percentage = ". $percent($m);
?>

It will produce the following output −

Marks = 250 Percentage = 83.333333333333

Example

Arrow functions capture variables by value automatically, even when nested.

In the following example, an arrow function is defined in the expression part of another arrow function.

Open Compiler

<?php
   $z = 1;
   $fn = fn($x) => fn($y) => $x * $y + $z;
   $x = 5;
   $y = 10; 
   echo "x:$x y:$y \n";
   echo "Result of nested arrow functions: " . ($fn($x)($y));
?>

It will produce the following output −

x:5 y:10 
Result of nested arrow functions: 51

Just like anonymous functions, the arrow function syntax allows arbitrary function signatures, including parameter and return types, default values, variadics, as well as by-reference passing and returning.

What are Anonymous Functions?

PHP allows defining anonymous functions. Normally, when we define a function in PHP, we usually provide it a name which is used to call the function whenever required. In contrast, an anonymous function is a function that doesn’t have any name specified at the time of definition. Such a function is also called closure or lambda function.

Sometimes, you may want a function for one time use only. The most common use of anonymous functions is to create an inline callback function.

Anonymous functions are implemented using the Closure class. Closure is an anonymous function that closes over the environment in which it is defined.

The syntax for defining an anonymous function is as follows −

$var=function($arg1,$arg2){return$val;};

Note that there is no function name between the function keyword and the opening parenthesis, and the fact that there is a semicolon after the function definition. This implies that anonymous function definitions are expressions. When assigned to a variable, the anonymous function can be called later using the variable’s name.

Example

Take a look at the following example −

Open Compiler

<?php
   $add = function ($a, $b) {
  return "a:$a b:$b addition: " . $a+$b; 
   };
   echo $add(5,10);
?>

It will produce the following output −

a:5 b:10 addition: 15

Anonymous Function as a Callback

Anonymous functions are often used as callbacks. Callback functions are used as one of the arguments of another function. An anonymous function is executed on the fly and its return value becomes the argument of the parent function, which may be either a built-in or a user-defined function.

Example

In this example, we use an anonymous function inside the usort() function, a built in function that sorts an array by values using a user-defined comparison function.

Open Compiler

<?php
   $arr = [10,3,70,21,54];
   usort ($arr, function ($x , $y) {
  return $x &gt; $y;
   });
   foreach ($arr as $x){
  echo $x . "\n";
   }
?>

It will produce the following output −

3
10
21
54
70

Example

The following example uses an anonymous function to calculate the cumulative sum after successive numbers in an array. Here, we use the array_walk() function. This function applies a user defined function to each element in the array.

Open Compiler

<?php
   $arr=array(1,2,3,4,5);
   array_walk($arr, function($n){
  $s=0;
  for($i=1;$i&lt;=$n;$i++){
     $s+=$i;
  }
  echo "Number: $n Sum: $s". PHP_EOL;
   });
?>

It will produce the following output −

Number: 1 Sum: 1
Number: 2 Sum: 3
Number: 3 Sum: 6
Number: 4 Sum: 10
Number: 5 Sum: 15

Explore our latest online courses and learn new skills at your own pace. Enroll and become a certified expert to boost your career.

Anonymous Function as Closure

Closure is also an anonymous function that can access the variables outside its scope with the help of the “use” keyword.

Example

Take a look a the following example −

Open Compiler

<?php
   $maxmarks=300;
   $percent=function ($marks) use ($maxmarks) {
  return $marks*100/$maxmarks;
   };
   $m = 250;
   echo "Marks = $m Percentage = ". $percent($m);
?>

It will produce the following output −

Marks = 250 Percentage = 83.333333333333