PHP Variable Scope Explained: Globals, Superglobals, and Best Practices

When to Use Globals in PHP

Using globals makes the most sense for predictable states and shared values. They work best for configurations, constants, and small single-file scripts. This means variables that you set up once, whether applications require them, and rarely change. 

Avoid them for anything like requesting data, communication between cross-modules, and other business logic with hidden dependencies. Hence, avoid globals for anything that might change the way your app behaves, which makes bugs harder to find.

⚠️ A Word of Warning

Use global variables thoughtfully. Implementing many global variables makes the code much harder to follow because of the many places they can change. This leads to unexpected bugs with unpredictable behaviour, especially in shared environments. A misuse can create conflicts between plugins and impact specific segments of your operation.

We strongly encourage you to stick to the clear and limited purpose of global variables. To help you acquire a better understanding, here are a few legitimate use cases:

• Shared configuration loaded during bootstrap
• Fixed values being defined once as constants
• Small scripts where the structure stays minimal

Important: If you are unsure, avoid globals and pass values directly into functions instead. This keeps your code easier to read, test, and maintain.

PHP Variables Explained

Before we discuss the scope, you need to understand how PHP variables work. Starting with the basics, variables store pre-defined values that your code uses during execution. In some real-world projects, they can be used to hold data, configuration, query output, and other temporary values inside functions. PHP variables follow this simple set of rules:

• A PHP variable always starts with the “$” sign.
• PHP variable names begin with “_” or a letter.
• A PHP variable name can’t start with a number.
• Letters, numbers, and underscores are allowed.
• The PHP variable names are all case-sensitive.

Here are a few surface-level examples:

$color = "green";
$quantity = 44;

With that in mind, let’s continue exploring variables.

Creating Variables

In PHP, variables are created the moment you assign a value to them. There is no extra step in creating a variable, so here is a quick example:

$age = 27;
$name = "Jack";

As shown in the example, the strings must be wrapped in quotes (“Hello World”).

Outputting Variables

The most common way to output variables is through the “echo” method. You can output as many variables as you need to create your message.

Here are some examples:

$site = "ServerMania";
echo "Explore $site";

or
$x = 14;
$y = 4;
echo $x + $y;

The first output would be “Explore ServerMania,” and the second would show the result of x + y, which would be equal to 18. As we’re getting a sense of how variables work, you can imagine the number of possibilities. However, there’s more.

Variable Data Types

PHP supports a lot of different data types that can be deployed within variables and echoed in various ways. Here are the most common variable data types:

Quick Tip: You can check the variable’s type using “var_dump()”.

See Also: Python vs. PHP: Which Is The Best Choice For Your Website?

How Variable Scope Works in PHP

The scope of variables in PHP determines the availability of variables in the code. It depends on where the variables are created. This is where most bugs appear, especially when developers assume that the variables behave the same way inside functions, different runtimes, and files.

Here are the 4 main types of variable scope:

1. Local Variables
2. Function Parameters
3. Global Variables
4. Static Variables

It’s important to understand how each of them works, so let’s go through them.

Global Scope & Included Files

When a variable is defined outside of a function, it has a global scope. This makes it accessible from the primary script and for all included or required files.

Here’s an example:

$a = 1;
include 'b.inc';

In the example above, $a is accessible within b.inc, because the included files share the same global scope as the main script. However, the global scope will not extend into functions. The variable may exist globally, but will still be unavailable unless explicitly brought into the scope.

Local Scope Inside Functions

When a variable is created inside a function, it only exists within this function. It cannot be used outside the scope of the function itself, so here’s an example:

$a = 1;

function test() {
echo $a;
}

test();

In the example above, we’ll have no output. This is because $a is inside a function that calls a variable that doesn’t exist. This is because PHP won’t automatically look outside the function. It is designed this way to prevent accidental changes.

See Also: How to Build a WordPress Site

How To Declare A Variable As Global

There are two different ways to declare a variable as global. Let’s go through them:

Using the “global” Keyword

To link a global variable to a local reference inside a function, you can declare it by using the
“global” keyword. Here’s how it works:

$a = 1;
$b = 2;

function sumValues() {
global $a, $b;
$b = $a + $b;
}

sumValues();
echo $b;

Here, PHP creates a reference to the global variables. Any change inside this function updates the global version, and the value remains changed after the function is executed. It works, but overusing this approach can make code really hard to follow. That’s why it’s primarily avoided.

Using the $GLOBALS Array

PHP also offers the $GLOBALS superglobal. It has the only goal to store all variables in an associative array that can be accessed in any scope.

Here’s how it looks in action:

$a = 5;
$b = 10;

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

addValues();
echo $b;

It works the same as the global keyword, but it’s much harder to read in larger codebases.

Heads Up: $GLOBALS Changes in PHP 8.1+

Starting with PHP 8.1, $GLOBALS has stricter behavior. You cannot replace the entire array or modify it in unsupported ways. Treat it as read-only for structure and use it to access specific variables when needed. You can find more information about PHP 8.1.0 $GlOBALS array here.

See Also: How to Set Up PHP on Nginx with FastCGI PHP-FPM Configuration

Understanding PHP Superglobals

Unlike globals in PHP, superglobals are built-in variables that are always available within every scope. They don’t have to be declared inside a function. PHP will create them automatically to store request data, details about the server, cookies, and more…

PHP includes the following superglobals:

• $GLOBALS
• $_SERVER
• $_GET
• $_POST
• $_FILES
• $_COOKIE
• $_SESSION
• $_REQUEST
• $_ENV

Each of these superglobals serves a distinct purpose in how PHP handles the system data and requests. In many production applications, they are used to read from input and process query strings to successfully manage sessions and file uploads.

For instance, $_GET and $_POST handle incoming request data, while the $_SESSION stores user state, and $_SERVER provides environment information. 

Important: Superglobals often deal with external input; always validate and sanitize their values before using them.

Globals vs Superglobals

The PHP globals and superglobals both provide access to shared data, but they work differently. 

Globals must be explicitly accessed inside functions, while superglobals are always available in any scope. Therefore, knowing the difference will help you avoid mistakes and security issues.

Here’s a side-by-side comparison:

In practice, use globals only for limited internal values such as configuration. Use superglobals at the edges of your app where you handle requests, sessions, and environment data. Always validate external input and avoid mixing responsibilities between the two.

How Static Variables Work in PHP

A static variable exists only inside a function, but it keeps its value between calls. Unlike regular local variables, it does not reset each time the function runs. This makes static variables useful for tracking counts, caching results, and improving performance in repeated operations.

Static variables must be assigned a fixed value when declared. You cannot initialize them with expressions or function calls.

Here’s an example of using a static variable as a counter:

function visitCounter() {
static $count = 0;

$count++;

echo "Visits: " . $count . PHP_EOL;
}

visitCounter();
visitCounter();
visitCounter();

In this example, we’re showing how a static variable can keep its value. Hence, each time the function runs, the $count will keep its value instead of resetting.

The output will look like this:

Visits: 1
Visits: 2
Visits: 3

The static variables work best when:

• You need a counter inside your function.
• You want to store small cached values.
• You want a state without using globals.

Note: Avoid using them for shared state across your app.

FAQ – PHP Scope, Globals & Practises

Are PHP globals shared between users?
No. In standard PHP setups such as PHP-FPM, globals exist only for a single request and are reset afterward. Each user request runs in isolation with its own memory and variable state.

Is $GLOBALS a bad practice?
Not always, but it should be used carefully. Overusing it creates hidden dependencies and makes code harder to test, debug, and maintain in larger applications.

Why doesn’t echo $a work inside a function?
Functions use their own local scope in PHP. To access a global variable, you must declare global $a or reference it through $GLOBALS[‘a’].

Are superglobals available inside functions?
Yes. Superglobals are always available in any scope, including inside functions and methods. This is why they are commonly used for request handling and environment data.

Should I use $_REQUEST in production apps?
Avoid it in most cases. It mixes data from multiple sources, which creates confusion during debugging and increases risk during security reviews.

When should I use static variables instead of globals?
Use static variables when you need a small internal state that persists across function calls. Avoid them for shared application state or cross-module communication.

See Also: eCommerce Server Optimization | Performance, Configuration & Scalability

Running Production PHP? Choose a Solid Infrastructure

Running PHP at scale requires solid infrastructure built for predictable performance, consistent CPU usage with low latency, and fast NVMe storage. This matters for large-scale WordPress, WooCommerce, Laravel, and Symfony apps handling real traffic and heavy background jobs.

ServerMania supports production PHP workloads with Application Hosting, Database Hosting, and Small Business Servers built for steady performance under load. 

If you are managing larger environments or multiple apps, our Hypervisor Servers give you full control with predictable resource allocation.

To learn more about ServerMania production ready PHP infrastructure, book a free consultation or get in touch with our 24/7 customer support directly. We’re ready to discuss your project!