The three variable scopes in PHP are global, local, and static: 1. Use global to access variables from outside a function, but prefer passing parameters to improve testability; 2. Local variables are default inside functions, exist only during function execution, and prevent side effects; 3. Use static to preserve a local variable’s value between function calls, ideal for counting or caching, but avoid for shared state or large data. Always favor local scope, limit global use, and document static usage clearly to write clean, maintainable code.

Understanding variable scope is essential for writing clean, predictable, and bug-free code—especially in languages like PHP, where global, local, and static keywords directly influence how variables behave across different contexts. Let’s break down each of these scopes in practical terms, so you can master when and why to use them.

What Is Variable Scope?

Scope determines where in the code a variable can be accessed. A variable might be available everywhere, only inside a function, or persist between function calls. The three key players here are:

• global — access variables from the global scope inside functions
• local — variables defined inside a function (default behavior)
• static — preserve a local variable’s value between function calls

Let’s explore each.

1. global: Accessing Variables Outside the Function

By default, functions cannot access variables declared outside of them—even if those variables are defined in the global scope.

$color = "blue";

function showColor() {
    echo $color; // This won't work!
}

showColor(); // Output: (nothing, and a warning)

To fix this, use the global keyword:

$color = "blue";

function showColor() {
    global $color;
    echo $color; // Now it works!
}

showColor(); // Output: blue

? How it works: global $color tells PHP to link the local $color inside the function to the $color in the global scope.

You can also use $GLOBALS, an associative array that holds all global variables:

function showColor() {
    echo $GLOBALS['color'];
}

This avoids global and is often preferred for clarity and testability.

? Use global when: You need to read or modify a global variable inside a function.
?? But be cautious: Overusing global variables makes code harder to debug and test. Try to pass values as parameters instead.

2. local: The Default Function Scope

Any variable declared inside a function is local by default—it only exists within that function.

function setCounter() {
    $count = 1;
    echo $count;
}

setCounter(); // Output: 1
echo $count; // Error! $count doesn't exist here.

Local variables are created when the function starts and destroyed when it ends.

? Use local variables for: Temporary data, calculations, or inputs that don’t need to persist or be shared.

They’re safe, isolated, and prevent unintended side effects.

3. static: Remember Values Between Calls

Sometimes you want a local variable to remember its value the next time the function runs. That’s where static comes in.

function increment() {
    static $count = 0;
    $count  ;
    echo $count . "\n";
}

increment(); // Output: 1
increment(); // Output: 2
increment(); // Output: 3

Without static, $count would reset to 0 every time.

? Key point: static $count = 0; runs only once, the first time the function is called. On subsequent calls, the assignment is skipped, but the value is retained.

? Use static when:

• You’re counting how many times a function was called
• Caching a computed value within a helper function
• Building simple generators or stateful utilities without objects

? Don’t use static for:

• Shared state across unrelated functions (use classes instead)
• Large data—you’re keeping memory alive longer than necessary

Quick Comparison Table

Best Practices & Common Pitfalls

• Avoid global when possible
  Instead of relying on global state, pass variables as parameters:

  function showColor($color) {
      echo $color;
  }

• Initialize static variables carefully
  The initial value is set only once. Don’t use expressions with side effects.

• Don’t confuse static with class static properties
  They’re related but different. Function static is about persistence, not class-level data.

• Document static usage clearly
  Since the behavior isn’t obvious, comment why the variable needs to persist.

---

Basically, mastering scope comes down to understanding where your variables live and how long they last. Use local by default, reach for global sparingly, and apply static when you need memory without full object state.

The above is the detailed content of Mastering Variable Scope: `global`, `local`, and `static` Explained. For more information, please follow other related articles on the PHP Chinese website!