Functions have isolated scope and require global or $GLOBALS to access global variables; 2. Closures capture outer variables explicitly via use, by value or by reference using &; 3. Methods use $this to access object properties, and closures inside methods can inherit $this in PHP 5.4 , but using use ($this) ensures clarity and safety when passing closures. Understanding these scope rules enables predictable and maintainable PHP code.

When learning PHP, one of the trickiest concepts to grasp isn't syntax—it's scope: understanding where variables and functions live, how they’re accessed, and how context changes everything. Whether you're calling a simple function, using a closure, or invoking a method on an object, the rules of scope shift subtly but significantly. Let’s walk through these three constructs—functions, closures, and methods—and see how PHP handles scope in each, building a cohesive mental model.

Function Scope: The Basics

In a regular PHP function, variables declared inside are local by default. They don’t inherit variables from the outer (global) scope unless explicitly told to.

$color = 'blue';

function paint() {
    echo $color; // Notice: Undefined variable
}

paint();

To access global variables, you need the global keyword:

function paint() {
    global $color;
    echo $color; // 'blue'
}

Alternatively, you can use $GLOBALS superglobal:

function paint() {
    echo $GLOBALS['color']; // 'blue'
}

Key point: Functions have their own isolated scope. No automatic access to outer variables.

Closures and use: Capturing Scope

Closures (anonymous functions) are more flexible. They can capture variables from the parent scope using the use keyword.

$color = 'red';

$painter = function() use ($color) {
    echo $color; // 'red'
};

$painter();

Here, $color is copied by value into the closure. Even if you change $color later, the closure keeps the original value:

$color = 'green';
$painter = function() use ($color) {
    echo $color;
};
$color = 'yellow'; // change after defining closure

$painter(); // still prints 'green'

Want to reference the variable instead? Use &:

$color = 'green';
$painter = function() use (&$color) {
    echo $color;
};
$color = 'purple';
$painter(); // 'purple'

Now the closure sees the current value because it holds a reference.

Key insight: Closures let you import outer variables explicitly, either by value or by reference—no guessing, no globals.

Methods and $this: Object Scope

When you move into classes, scope gets another layer: the object instance. Inside a method, you’re in the object’s scope, and $this gives you access to its properties and methods.

class Car {
    private $color = 'silver';

    public function drive() {
        echo "Driving the {$this->color} car.";
    }
}

Unlike functions or closures, methods don’t need use or global to access instance data—they’re naturally bound to $this.

But what if you use a closure inside a method? Does it automatically know $this?

class Car {
    private $color = 'blue';

    public function getColorFetcher() {
        return function() {
            return $this->color; // Fatal error: Using $this outside object context
        };
    }
}

Oops! Even though the closure is defined inside a method, it doesn’t automatically inherit $this. However, as of PHP 5.4, anonymous functions created in an object context do capture $this if used.

So this actually works:

$fetcher = (new Car())->getColorFetcher();
echo $fetcher(); // 'blue' — works in PHP 5.4 

But if you were to bind the closure to another object (or none), $this could change or disappear.

To be safe or explicit, you can use use:

public function getColorFetcher() {
    $self = $this;
    return function() use ($self) {
        return $self->color;
    };
}

This pattern is useful when passing closures to functions that might change context.

Scope Summary: The Big Picture

A few practical takeaways:

• Avoid global when possible—it makes code harder to test and reason about.
• Use use thoughtfully in closures—know whether you need a copy or a reference.
• Be cautious with $this in closures—especially if the closure might be passed around or called outside the original object context.
• In modern PHP, closures in methods usually work fine with $this, but explicit use ($this) can make intent clearer.

Final Thought

PHP’s scope rules might seem fragmented at first—functions isolated, closures selective, methods tied to objects—but they make sense when you see them as tools for controlling access. Each construct gives you just enough power to connect scopes when needed, without leaking them by default.

Understanding how and why scope changes between functions, closures, and methods isn’t just academic—it’s the key to writing predictable, maintainable PHP.

Basically, it’s not magic. It’s design.

The above is the detailed content of From Functions to Closures to Methods: A Holistic View of PHP Scope. For more information, please follow other related articles on the PHP Chinese website!