Variable Scope

Introduction

Now that you can write your own functions, a natural question comes up: if I create a variable inside a function, can I use it outside that function? And if I create a variable outside a function, can the function see it? The answer to both, by default, is no — and that behavior is called variable scope.

Understanding scope is essential for writing functions that behave predictably. Without it, you will eventually run into confusing bugs where a variable seems to "disappear" or a function seems to ignore a value you set earlier in the script.

What is Variable Scope?

Scope refers to the part of a script where a variable is visible and can be used. PHP has a few different scopes, but the two you will run into constantly are local scope (inside a function) and global scope (outside every function, at the top level of the script).

By default, a function in PHP cannot see variables defined outside it, and code outside a function cannot see variables defined inside it. Each function gets its own private set of variables, completely separate from the rest of the script.

Local Scope

A variable declared inside a function has local scope: it only exists while that function is running, and it cannot be accessed from outside the function. Once the function finishes executing, the variable is destroyed.

<?php
function greet() {
    $message = "Hello from inside the function!";
    echo $message . "\n";
}

greet();

echo $message; // Error: undefined variable $message
?>

Hello from inside the function!
Warning: Undefined variable $message

The $message variable only lives inside greet(). Trying to echo it outside the function fails because, from the outside world's point of view, that variable was never created.

This isolation is a feature, not a limitation. It means you can reuse the same variable name in different functions without them interfering with each other.

<?php
function calculateTotal() {
    $result = 10 + 20;
    echo "Total: $result\n";
}

function calculateAverage() {
    $result = (10 + 20) / 2;
    echo "Average: $result\n";
}

calculateTotal();
calculateAverage();
?>

Total: 30
Average: 15

Both functions use a variable named $result, but each one is a completely separate variable that only exists within its own function.

Global Scope

A variable declared outside of any function — directly in the main body of the script — has global scope. It is visible to any regular script code at that same top level, but functions still cannot see it automatically.

<?php
$siteName = "PrograMinds";

echo "Welcome to " . $siteName . "\n"; // Works fine, top-level code

function showSiteName() {
    echo "Welcome to " . $siteName . "\n"; // Undefined - function can't see it
}

showSiteName();
?>

Welcome to PrograMinds
Warning: Undefined variable $siteName

The global Keyword

If a function genuinely needs to read or modify a variable defined in the global scope, PHP provides the global keyword. Declaring global $variableName; inside a function links that name to the global variable of the same name.

<?php
$siteName = "PrograMinds";

function showSiteName() {
    global $siteName;
    echo "Welcome to " . $siteName . "\n";
}

showSiteName();
?>

Welcome to PrograMinds

The global keyword does not copy the value — it creates a reference to the actual global variable. That means changes made inside the function affect the global variable too.

<?php
$counter = 0;

function increment() {
    global $counter;
    $counter++;
}

increment();
increment();
increment();

echo "Counter is now: " . $counter . "\n";
?>

Counter is now: 3

PHP also exposes global variables through a special array called $GLOBALS, which you can use as an alternative to the global keyword.

<?php
$siteName = "PrograMinds";

function showSiteNameAlt() {
    echo "Welcome to " . $GLOBALS["siteName"] . "\n";
}

showSiteNameAlt();
?>

Welcome to PrograMinds

Static Variables

Normally, a local variable is recreated from scratch every time its function runs, and it loses its value the moment the function ends. Sometimes, though, you want a function to remember a value between calls — for example, to count how many times it has been called. That is what the static keyword is for.

<?php
function trackCalls() {
    static $count = 0;
    $count++;
    echo "This function has been called $count time(s).\n";
}

trackCalls();
trackCalls();
trackCalls();
?>

This function has been called 1 time(s).
This function has been called 2 time(s).
This function has been called 3 time(s).

The static $count = 0; line only initializes $count to 0 the very first time the function runs. On every later call, PHP skips the initialization and reuses whatever value $count held at the end of the previous call.

Why Global State Is Discouraged

It might seem convenient to make every variable global so any function can use it. In practice, this tends to create fragile code as a project grows.

The generally preferred approach is to pass data into functions as parameters and get data back out using return values, rather than reaching into global variables. This keeps each function self-contained and predictable.

<?php
// Less ideal: relies on global state
$taxRate = 0.08;
function calculateTotalGlobal($price) {
    global $taxRate;
    return $price + ($price * $taxRate);
}

// Better: explicit parameter, no hidden dependency
function calculateTotal($price, $taxRate) {
    return $price + ($price * $taxRate);
}

echo calculateTotal(100, 0.08) . "\n";
?>

108

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Variable scope determines where in your script a variable can be seen and used. Local variables stay locked inside their function, global variables live at the top level, and static variables give a function memory across calls.

In this lesson, you learned how PHP isolates function variables by default, how to deliberately reach into global scope with the global keyword, and why leaning on global state is usually a design smell. Next, you will learn how to split your PHP code across multiple files using include and require.