PHP resolves variables in a specific order: 1. Local scope within the current function, 2. Function parameters, 3. Variables imported via use in closures, 4. Global scope only if explicitly declared with global or accessed through $GLOBALS, 5. Superglobals like $_SESSION and $_POST which are always available, and 6. Object properties via $this in class methods, with inheritance from parent classes; visibility rules apply. Unlike languages with dynamic scope, PHP does not automatically search outer scopes, so access must be explicit, reducing bugs and improving predictability when writing functions, closures, and classes.

When you're working with PHP, understanding how variables are accessed—especially in different scopes—is key to writing predictable, bug-free code. PHP follows a clear scope resolution order when looking for variables, and knowing this order helps explain why a variable might be available in one place but not another.

Here’s how PHP resolves variable names when you reference them in your code.

1. Local Scope: First, Check the Current Function

When you're inside a function, PHP first looks for the variable in the local scope.

function test() {
    $name = "Alice";
    echo $name; // Outputs: Alice
}

In this case, $name is found immediately in the local scope. PHP doesn’t need to look further.

But if the variable isn’t declared locally, PHP doesn’t just give up—it keeps searching.

2. Global Scope: Then, Check the Global Namespace (Only If Requested)

If PHP doesn’t find the variable locally and you haven’t imported it, it won’t automatically look in the global scope. You have to explicitly bring global variables into the local scope using the global keyword.

$name = "Bob";

function sayHello() {
    global $name;
    echo $name; // Outputs: Bob
}

Without global $name;, the variable would be undefined inside the function. So the global scope is not searched by default—it only comes into play when you use global or $GLOBALS.

? Note: $GLOBALS['name'] gives direct access to the global scope without needing global.

3. Superglobals: Always Available (But Not Through Scope Inheritance)

Superglobals like $_GET, $_POST, $_SESSION, and $_SERVER are always accessible from any scope—you don’t need global to use them.

function getUser() {
    return $_SESSION['user']; // Works fine—no global needed
}

These are special built-in arrays that PHP automatically makes available everywhere. They’re not subject to the usual scope rules because they’re registered globally by the engine.

?? Important: While superglobals are always accessible, you still need to initialize or populate them (e.g., start a session for $_SESSION).

4. Closure Use Clauses: Inherited Variables from the Parent Scope

When using anonymous functions (closures), variables from the outer scope aren’t automatically inherited. You must pass them explicitly using the use keyword.

$greeting = "Hello";

$sayHi = function() use ($greeting) {
    echo $greeting; // Outputs: Hello
};

Without use ($greeting), the closure wouldn’t have access to that variable—even though it’s in the surrounding code.

You can also import by reference with use (&$var) if you need to modify the original.

5. Class Context: $this and Property Resolution

Inside methods, PHP resolves $this automatically (if the method is non-static), and property access follows its own rules:

• First, look for a property in the current object ($this->prop)
• If not found, check parent classes (via inheritance)
• Visibility (public, protected, private) controls access

class Greeter {
    private $name = "Charlie";

    public function hello() {
        echo $this->name; // Resolves to private property
    }
}

Here, $this->name is resolved within the object’s property table, not the local variable scope.

Summary of PHP’s Variable Lookup Order

In simple terms, here’s the effective order PHP uses when you write $var:

1. Local variables in the current function
2. Parameters passed to the function
3. use variables in closures (explicitly imported)
4. Global variables — only if declared with global or accessed via $GLOBALS
5. Superglobals — always available, no declaration needed
6. Object properties — when using $this->prop, resolved via class structure

? Key Insight: PHP does not automatically search up the call stack or outer scopes like some other languages (e.g., JavaScript closures). Scope access must be explicit.

Common Pitfalls & Tips

• ? Assuming globals are available in functions
  → Use global $var or $GLOBALS.

• ? Expecting closures to capture outer variables automatically
  → Always use use ($var).

• ? Use superglobals freely inside functions
  → No global needed for $_POST, $_SESSION, etc.

• ? Prefer dependency injection over global reliance
  → Pass values as parameters instead of using global—makes code more testable.

Understanding PHP’s scope resolution order isn’t about memorizing rules—it’s about writing code that behaves predictably. Once you accept that PHP doesn’t guess what variables you want, and instead requires you to be explicit, your debugging time drops significantly.

Basically: if it’s not local, passed, or explicitly imported, PHP won’t see it.

The above is the detailed content of The Scope Resolution Order: How PHP Finds Your Variables. For more information, please follow other related articles on the PHP Chinese website!