PHP global Keyword - Access Global Variables

The global keyword in PHP plays a crucial role when working with variable scopes. It allows you to access and manipulate variables declared outside the current function scope (global scope) from within functions. Understanding how the global keyword works helps you write cleaner, more maintainable PHP code and better manage your application's state.

Prerequisites

Basic knowledge of PHP syntax
Understanding of variable scopes in PHP
PHP version 5.x or higher installed
Text editor or IDE for PHP code editing
Basic terminal/command prompt usage for running PHP scripts

Setup

To follow along, ensure you have a working PHP environment. You can use XAMPP, MAMP, or a local PHP installation:

Verify PHP installation by running php -v in the terminal.
Create a new PHP file (e.g., global_example.php).
Open the file in your editor for coding.

Understanding PHP Variable Scope

Before diving into the global keyword, it's crucial to understand PHP variable scopes:

Global Scope: Variables declared outside any function or class method.
Local Scope: Variables declared within functions or methods; not accessible outside.

By default, PHP functions do not have access to global variables unless explicitly stated.

Using `global` Keyword in PHP

Basic Example

<?php
$counter = 10; // Global variable

function incrementCounter() {
    global $counter; // Gain access to global $counter
    $counter++;
}

incrementCounter();
echo $counter; // Outputs: 11
?>

Explanation:

The variable $counter is defined in the global scope.
Inside incrementCounter(), the keyword global $counter; tells PHP to use the global variable $counter instead of creating a new local variable.
Incrementing $counter inside the function affects the global variable.

Multiple Global Variables

<?php
$name = "John";
$age = 30;

function displayUserInfo() {
    global $name, $age; // Access multiple global variables
    echo "Name: $name, Age: $age";
}

displayUserInfo();
// Output: Name: John, Age: 30
?>

Accessing Global Variables Without Using `global`

Alternatively, you can use the $GLOBALS array. This is a superglobal associative array containing all global variables:

<?php
$score = 50;

function increaseScore() {
    $GLOBALS['score'] += 10;
}

increaseScore();
echo $score; // Outputs: 60
?>

However, using global improves readability in many cases.

Best Practices

Minimize use of global variables: Excessive use of globals can lead to code that is hard to debug and maintain.
Prefer passing variables as function parameters: This makes your functions more reusable and testable.
Use global keyword sparingly: Limit to cases where it makes sense, such as configuration settings or constants that need to be accessed across different scopes.
Use $GLOBALS for dynamic key access: When variable names are determined at runtime.
Comment your usage: When you use global, add comments to clarify intent.

Common Mistakes

Failing to declare a variable as global inside a function, which results in the function using or creating a local variable instead.
Confusing local and global variable values due to the same variable name in different scopes.
Using too many global variables, causing tightly-coupled code that is hard to maintain.
Trying to access a variable outside the function without declaring it as global or using $GLOBALS.
Assuming global variables are automatically available inside functions without explicit declaration.

Interview Questions

Junior Level

Q1: What does the global keyword do in PHP?
A1: It allows a function to access variables declared in the global scope.
Q2: What will happen if you try to change a global variable inside a function without using the global keyword?
A2: A local variable with the same name will be changed, leaving the global variable unchanged.
Q3: How can you access a global variable inside a function without using the global keyword?
A3: By using the $GLOBALS superglobal array.
Q4: Can you declare multiple variables as global inside a function?
A4: Yes, by listing them separated by commas, e.g., global $var1, $var2;.
Q5: Why is using too many global variables discouraged?
A5: It makes code harder to maintain and debug because of tight coupling.

Mid Level

Q1: Explain variable scope in PHP and how global changes that.
A1: Variables declared outside functions have global scope; functions have local scope. Using global inside a function allows access to the global variable instead of creating a local one.
Q2: What is the difference between using global $var; and $GLOBALS['var']?
A2: global imports the variable into local scope, while $GLOBALS lets you access it directly as a global variable array element.
Q3: Can you use the global keyword inside class methods? How?
A3: Yes, you can declare variables as global inside methods using global $var;, but it's better to use class properties.
Q4: What are the potential risks of modifying global variables inside functions?
A4: It can lead to unintended side effects and bugs because changes affect variables globally.
Q5: How do you decide between using function parameters and global variables?
A5: Use function parameters to keep functions self-contained; use globals only when necessary for shared state.

Senior Level

Q1: Discuss alternatives to using global that improve code maintainability.
A1: Use dependency injection, passing variables explicitly, or encapsulate state in classes to reduce global state dependence.
Q2: How does the use of global affect unit testing in PHP?
A2: It makes testing harder because tests must manage or mock global state, reducing test isolation.
Q3: Is the $GLOBALS array mutable and what are implications?
A3: Yes, modifying $GLOBALS changes global variables at runtime, which can cause side effects and bugs.
Q4: Describe a scenario where using global is justifiable in modern PHP applications.
A4: Accessing configuration or environment variables globally in a legacy procedural codebase might justify global.
Q5: How do namespaces and global variables interact when using the global keyword?
A5: The global keyword accesses variables from the global space, so careful naming is needed to avoid conflicts in namespaced code.

Frequently Asked Questions (FAQ)

What is the purpose of the `global` keyword in PHP?

It declares variables inside a function as references to the global variables, enabling access to variables defined outside the function.

Can global variables be modified inside functions?

Yes, but only if the variable is declared with the global keyword or accessed via $GLOBALS.

Is it better to use `global` or `$GLOBALS`?

Using global makes code more readable, especially when accessing known variables, while $GLOBALS is useful for dynamic keys.

What happens if I omit the `global` keyword when trying to access a global variable inside a function?

A new local variable with the same name will be created, and the global variable will not be affected.

Are there alternatives to using `global` to share data across functions?

Yes. Passing variables as function parameters, using static variables, or encapsulating shared data in classes are preferred.

Conclusion

The PHP global keyword is a fundamental feature for accessing and modifying global variables inside functions. While powerful, it should be used carefully to maintain clear and manageable code. By combining knowledge of variable scopes and the global keyword, PHP developers can share data effectively across function boundaries while avoiding common pitfalls.

PHP global Keyword