PHP Variables Scope, Global and Static Keywords

PHP Variables Scope

Introduction:

Learn about PHP variable scope and the use of global and static keywords. This lesson covers the concepts of local and global scope, understanding the global keyword, and utilizing the static keyword for persistent variables.

In PHP, variable scope refers to the context in which a variable can be accessed or modified. PHP supports several types of variable scope, including global scope, local scope, and static scope. Here’s an overview of each:

PHP Variable Global Scope:

Variables declared outside of any function or class have global scope.
Global variables can be accessed from anywhere in the script, both inside and outside functions or classes.

php

$globalVar = "I am global";

function exampleFunction() {
echo $GLOBALS['globalVar']; // Accessing global variable
}

exampleFunction(); // Output: I am global

PHP Variable Local Scope:

Variables declared inside a function have local scope.
Local variables can only be accessed within the function where they are declared.

php

function exampleFunction() {
$localVar = "I am local";
echo $localVar;
}

exampleFunction(); // Output: I am local

// Uncommenting the line below would result in an error
// echo $localVar;

PHP Variable Static Scope:

When a variable is declared as static within a function, its value is preserved between function calls.
Static variables have local scope but persist their values across multiple calls to the same function.

php

function exampleFunction() {
static $staticVar = 0;
echo $staticVar;
$staticVar++;
}

exampleFunction(); // Output: 0
exampleFunction(); // Output: 1

PHP Variable Superglobals:

Superglobals are predefined variables in PHP that are always accessible, regardless of the scope.

Examples of superglobals include : $GLOBALS, $_POST, $_GET, $_SESSION, $_COOKIE, $_SERVER, and $_REQUEST.

php

echo $_SERVER['SERVER_NAME']; // Accessing a superglobal

Understanding variable scope is crucial for writing clean and maintainable code.

It helps prevent naming conflicts and ensures that variables are used in the appropriate context.

complete example embedded in html with explanation

Let’s create a simple PHP script embedded in HTML to demonstrate variable scope.

In this example, we’ll use global, local, and static variables.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PHP Variable Scope Example</title>
</head>
<body>

<?php
// Global Scope
$globalVar = "I am global";

function exampleFunction() {
// Local Scope
$localVar = "I am local";
echo "<p>Inside function: $localVar</p>";

// Accessing the global variable
global $globalVar;
echo "<p>Inside function: $globalVar</p>";

// Static Scope
static $staticVar = 0;
echo "<p>Static variable: $staticVar</p>";
$staticVar++;
}

// Calling the function
exampleFunction();

// Attempting to access local variable outside the function would result in an error
// Uncommenting the line below would result in an error
// echo "<p>Outside function: $localVar</p>";

// Global variable can be accessed outside the function
echo "<p>Outside function: $globalVar</p>";
?>

</body>
</html>

Explanation:

We start with the HTML structure and embed PHP code within the body of the HTML document.
A global variable $globalVar is declared outside the function and is accessible both inside and outside the function.
The exampleFunction function demonstrates local scope with the variable $localVar, which can only be accessed within the function.
The function also accesses the global variable using the global keyword.
A static variable $staticVar is declared with static scope inside the function. Its value persists across multiple calls to the function.
The function is called, and the output is displayed within HTML paragraphs (<p> tags).
Attempting to access the local variable outside the function would result in an error, illustrating the concept of local scope.
Finally, the global variable is accessed outside the function to show global scope.

Local Scope:complete code embedded in html with explanation

Let’s create a simple PHP script embedded in HTML to specifically demonstrate local variable scope.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PHP Local Variable Scope Example</title>
</head>
<body>

<?php
// Global variable for demonstration purposes
$globalVar = "I am global";

function exampleFunction() {
// Local Scope: Declaring and using a local variable
$localVar = "I am local";
echo "<p>Inside function: $localVar</p>";

// Attempting to access the global variable within the function
// Uncommenting the line below would result in an error
// echo "<p>Inside function: $globalVar</p>";
}

// Calling the function
exampleFunction();

// Attempting to access the local variable outside the function would result in an error
// Uncommenting the line below would result in an error
// echo "<p>Outside function: $localVar</p>";

// Global variable can be accessed outside the function
echo "<p>Outside function: $globalVar</p>";
?>

</body>
</html>

Explanation:

This HTML document contains embedded PHP code to illustrate local variable scope.
There’s a global variable $globalVar declared outside the function, which is accessible both inside and outside the function for demonstration purposes.
The exampleFunction function demonstrates local scope with the variable $localVar.
It is declared inside the function and can only be accessed within that function.
The function is called, and the output is displayed within HTML paragraphs (<p> tags).
Attempting to access the local variable $localVar outside the function would result in an error, illustrating the concept of local scope.
Finally, the global variable $globalVar is accessed outside the function to show that global variables are accessible from any part of the script.

Static Scope:complete example embedded in html with explanation

Let’s create a simple PHP script embedded in HTML to specifically demonstrate static variable scope.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PHP Static Variable Scope Example</title>
</head>
<body>

<?php
function exampleFunction() {
// Static Scope: Declaring and using a static variable
static $staticVar = 0;
echo "<p>Static variable: $staticVar</p>";
$staticVar++;
}

// Calling the function multiple times to observe static variable behavior
exampleFunction(); // Output: Static variable: 0
exampleFunction(); // Output: Static variable: 1
exampleFunction(); // Output: Static variable: 2
?>

</body>
</html>

Explanation:

This HTML document contains embedded PHP code to illustrate static variable scope.
The exampleFunction function demonstrates static scope with the variable $staticVar.
It is declared with the static keyword inside the function.
The static variable $staticVar persists its value across multiple calls to the same function.
In this example, the function is called three times, and the output reflects the incremental value of the static variable.
As the function is called, the static variable increments its value and retains its state between function calls.
This example doesn’t include global or local variables for simplicity since the focus is on demonstrating static variable scope.

Superglobals:complete example embedded in html with explanation

Let’s create a simple PHP script embedded in HTML to demonstrate the use of superglobals.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PHP Superglobals Example</title>
</head>
<body>

<?php
// Using $_GET superglobal to retrieve data from the URL
$name = isset($_GET['name']) ? $_GET['name'] : 'Guest';

// Using $_POST superglobal to retrieve data from a form submission
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
$message = isset($_POST['message']) ? $_POST['message'] : '';
} else {
$message = 'No message submitted';
}

// Using $_SERVER superglobal to display server information
$serverName = $_SERVER['SERVER_NAME'];
$serverIP = $_SERVER['SERVER_ADDR'];

// Displaying the retrieved information
echo "<p>Hello, $name!</p>";
echo "<p>Message: $message</p>";
echo "<p>Server Name: $serverName</p>";
echo "<p>Server IP Address: $serverIP</p>";
?>

<!-- HTML form to submit data using POST method -->
<form method="post" action="">
<label for="message">Enter a message:</label>
<input type="text" id="message" name="message">
<button type="submit">Submit</button>
</form>

<!-- HTML form with a link to submit data using GET method -->
<form method="get" action="">
<label for="name">Enter your name:</label>
<input type="text" id="name" name="name">
<button type="submit">Submit</button>
</form>

</body>
</html>

Explanation:

This HTML document contains embedded PHP code to illustrate the use of PHP superglobals.
$_GET is used to retrieve data from the URL parameters. The script checks if the ‘name’ parameter is set in the URL; if not, it defaults to ‘Guest’.
$_POST is used to retrieve data from a form submission.
The script checks if a message has been submitted using the ‘message’ field; if not, it defaults to ‘No message submitted’.
$_SERVER is used to display server information, such as the server name and IP address.
The retrieved information is then displayed within HTML paragraphs (<p> tags).
Two HTML forms are included—one using the POST method for submitting a message and another using the GET method for submitting a name.
Users can interact with the forms to see how data is submitted and retrieved using the respective superglobals.

PHP The global Keyword

In PHP, the global keyword is used to access a global variable from within a function.
When a variable is declared outside of any function or class, it has global scope.
However, if you want to use that variable within a function, you need to use the global keyword to indicate that you are referring to the global instance of that variable.

Here’s a simple example to illustrate the use of the global keyword:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PHP Global Keyword Example</title>
</head>
<body>

<?php
// Global variable
$globalVar = "I am a global variable";

function exampleFunction() {
// Using the global keyword to access the global variable inside the function
global $globalVar;

echo "<p>Inside function: $globalVar</p>";
}

// Calling the function
exampleFunction();

// Accessing the global variable outside the function
echo "<p>Outside function: $globalVar</p>";
?>

</body>
</html>

Explanation:

$globalVar is declared outside the function, making it a global variable.
Inside the exampleFunction, the global $globalVar; statement is used to indicate that the function should use the global instance of $globalVar.
The function is then called, and the output shows the value of the global variable both inside and outside the function.
Using the global keyword should be done with caution, as it can make code harder to understand and maintain. It’s generally recommended to pass variables explicitly to functions as parameters rather than relying on global variables.

PHP The static Keyword

In PHP, the static keyword is used to declare static variables within functions or methods.
A static variable is a variable that retains its value between function calls, but it has local scope, meaning it can only be accessed within the function or method where it is declared.
The static variable persists its value across multiple calls to the same function or method.

Here’s an example to illustrate the use of the static keyword:

php

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PHP Static Keyword Example</title>
</head>
<body>

<?php
function exampleFunction() {
// Using the static keyword to declare a static variable
static $staticVar = 0;

echo "<p>Static variable: $staticVar</p>";

// Incrementing the static variable
$staticVar++;
}

// Calling the function multiple times to observe static variable behavior
exampleFunction(); // Output: Static variable: 0
exampleFunction(); // Output: Static variable: 1
exampleFunction(); // Output: Static variable: 2
?>

</body>
</html>

Explanation:

Inside the exampleFunction, the static $staticVar = 0; statement declares a static variable named $staticVar and initializes it with the value 0.
The function is then called multiple times. With each call, the static variable retains its value and increments by 1.
The output shows the value of the static variable, demonstrating that it persists across multiple calls to the function.
Static variables are useful when you want to maintain state between function calls without using global variables. They are often used in scenarios where you need to count or track something across multiple invocations of a function.

create application by using this lesson with explanation

Let’s create a simple PHP application that utilizes global and static variables to count the number of times a button is clicked.
The application will consist of an HTML form with a button, and PHP code to handle the button click and display the count.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Click Counter Application</title>
</head>
<body>

<?php
// Initialize a global variable to store the click count
$clickCount = 0;

function handleClick() {
// Use the global keyword to access the global variable
global $clickCount;

// Increment the click count
$clickCount++;

echo "<p>Button clicked $clickCount times.</p>";
}
?>

<h1>Click Counter Application</h1>

<!-- HTML form with a button to trigger the PHP function -->
<form method="post" action="">
<button type="submit" name="clickButton">Click Me!</button>
</form>

<?php
// Check if the button is clicked
if (isset($_POST['clickButton'])) {
// Call the function to handle the button click
handleClick();
}
?>

</body>
</html>

Explanation:

In this example, we have an HTML form with a button labeled “Click Me!”.
When the button is clicked, a POST request is sent to the server.
The PHP code at the top of the file initializes a global variable $clickCount to store the number of times the button is clicked.
The handleClick function is defined, which uses the global $clickCount; statement to access the global variable and increments the click count.
The form checks if the button named “clickButton” is clicked (isset($_POST[‘clickButton’])), and if so, it calls the handleClick function to process the button click.
The output displays the number of times the button has been clicked.
This simple application demonstrates the use of a global variable ($clickCount) to maintain the click count and the global keyword to access and modify this variable within a function. The global variable retains its value between different requests to the server, allowing us to keep track of the click count across multiple button clicks.

Quiz :related to the PHP variable scope, global keyword, and static keyword.

Each question is followed by multiple-choice answers. Choose the correct option for each question.

1-What is variable scope in PHP?

A. The range of values a variable can take
B. The context in which a variable can be accessed or modified
C. The visibility of a variable in HTML

2-Where do global variables have scope in PHP?

A. Only within functions
B. Only within classes
C. Throughout the entire script

3-Which keyword is used to access a global variable inside a function in PHP?

A. $this
B. global
C. super

4-In PHP, what is the default scope of a variable declared outside any function or class?

A. Local
B. Global
C. Static

5-What is the purpose of the static keyword in PHP?

A. To declare a constant variable
B. To declare a variable with dynamic scope
C. To declare a variable with static scope

6-Which type of variable retains its value between function calls in PHP?

A. Dynamic
B. Static
C. Constant

7-What is the function of the $GLOBALS array in PHP?

A. To store global variables
B. To store local variables
C. To store static variables

8-Where should the global keyword be used in PHP?

A. Inside a function to access a global variable
B. Inside a class to declare a global variable
C. Outside any function or class to declare a global variable

9-Which superglobal is used to retrieve data from the URL in PHP?

A. $_GET
B. $_POST
C. $_REQUEST

10-What is the purpose of a local variable in PHP?

A. To be accessible from any part of the script
B. To be accessible only within the function where it is declared
C. To be accessible only within a specific class

11-Which superglobal is used to retrieve data from a form submission in PHP?

A. $_POST
B. $_GET
C. $_SERVER

12-In PHP, what happens if you attempt to access a local variable outside the function where it is declared?

A. No error
B. Fatal error
C. Warning message

13-What is the purpose of using static variables in PHP functions?

A. To make variables visible globally
B. To retain variable values between function calls
C. To declare variables with constant values

14-Which keyword is used to declare a static variable in PHP?

A. $static
B. static
C. const

15-What is a potential drawback of using global variables in PHP?

A. Improved code readability
B. Risk of naming conflicts and maintainability issues
C. Easier debugging process
Answers:

1-B, 2. C, 3. B, 4. B, 5. C, 6. B, 7. A, 8. A, 9. A, 10. B, 11. A, 12. B, 13. B, 14. B, 15. B

PHP Tutorial

Curriculum

PHP Variables Scope, Global and Static Keywords

PHP Variable Global Scope:

PHP Variable Local Scope:

PHP Variable Static Scope:

PHP Variable Superglobals:

PHP The global Keyword

PHP The static Keyword

Quiz :related to the PHP variable scope, global keyword, and static keyword.

1-What is variable scope in PHP?

2-Where do global variables have scope in PHP?

3-Which keyword is used to access a global variable inside a function in PHP?

4-In PHP, what is the default scope of a variable declared outside any function or class?

6-Which type of variable retains its value between function calls in PHP?

7-What is the function of the $GLOBALS array in PHP?

9-Which superglobal is used to retrieve data from the URL in PHP?

10-What is the purpose of a local variable in PHP?

11-Which superglobal is used to retrieve data from a form submission in PHP?

12-In PHP, what happens if you attempt to access a local variable outside the function where it is declared?

13-What is the purpose of using static variables in PHP functions?

14-Which keyword is used to declare a static variable in PHP?

15-What is a potential drawback of using global variables in PHP?

Leave a Reply

Modal title