PHP Variables: Declare, Scope, global and static

A PHP variable is a name that starts with $, and you create it by assigning a value: $name = "Ada";. There is no declaration keyword and no type to state, because the value decides the type. You can assign a value of a different type later.

<?php
$name = "Ada";
$age = 36;
$height = 1.65;
$isAdmin = true;

echo "$name is $age years old\n";

$age = $age + 1;           // update the value
$age++;                    // add one more
echo "Two birthdays later: $age\n";

$age = "thirty-eight";     // the type can change too
echo "Now a string: $age\n";

Variable naming rules

A variable name starts with $, then a letter or underscore, then any letters, digits or underscores. Non-ASCII letters count as letters, so $名前 is valid, though ASCII names are the norm. Names are case-sensitive.

So $city, $City and $CITY are three different variables. Use snake_case ($first_name) or camelCase ($firstName), and stay with one style per project. The PSR coding standards leave variable naming open on purpose; Laravel and Symfony code mostly uses camelCase.

Use variables in strings

Inside double quotes PHP replaces variables with their values; inside single quotes it does not. Wrap the variable in braces when letters follow it directly or when you access an array element by a string key:

<?php
$fruit = "apple";
$basket = ["count" => 4];

echo "I like $fruit pie\n";
echo 'I like $fruit pie' . "\n";              // single quotes: printed as written
echo "Two {$fruit}s please\n";                // braces separate the name
echo "There are {$basket['count']} left\n";   // array key inside a string
echo "Joined: " . $fruit . " and pear\n";     // concatenation with .

The strings page covers quotes, concatenation and interpolation in detail.

Undefined variables and default values

Reading a variable that was never assigned gives null, and your PHP prints a warning:

Warning: Undefined variable $discount in /home/index.php on line 3

Check first with isset, or use the null coalescing operator ?? to supply a default. Both run without a warning:

<?php
$price = 50;

$discount = $discount ?? 0;    // use 0 when $discount is not set
echo "Price: " . ($price - $discount) . "\n";

if (isset($coupon)) {
    echo "Coupon: $coupon\n";
} else {
    echo "No coupon given\n";
}

$coupon = null;
var_dump(isset($coupon));      // a variable holding null counts as not set

$x ??= 0; is the short form of $x = $x ?? 0;. Form and URL values are the usual case: $page = $_GET['page'] ?? 1;.

Variable scope in functions

Variables defined outside a function are not visible inside it, and variables created inside a function disappear when it returns. This is the most common surprise for people coming from JavaScript:

<?php
$taxRate = 0.2;

function priceWithTax($price)
{
    // $taxRate does not exist here, so ?? falls back to 0
    return $price * (1 + ($taxRate ?? 0));
}

function priceWithTaxFixed($price, $rate)
{
    return $price * (1 + $rate);   // pass what the function needs
}

echo priceWithTax(100), "\n";
echo priceWithTaxFixed(100, $taxRate), "\n";

Without the ?? 0, the first function would warn about an undefined $taxRate. Passing values as parameters keeps functions predictable and easy to test, and it is what you should reach for first. The functions page covers parameters and return values.

The global keyword and $GLOBALS

When a function really must use a global variable, declare it with global, or go through the $GLOBALS array, which holds every global variable by name:

<?php
$visits = 0;
$siteName = "Bakery";

function countVisit()
{
    global $visits;      // now $visits refers to the global variable
    $visits++;
}

function title()
{
    return "Welcome to " . $GLOBALS['siteName'];
}

countVisit();
countVisit();
echo "Visits: $visits\n";
echo title(), "\n";

Globals make code harder to follow, because any function can change them. They appear in older code and WordPress plugins (global $wpdb;); in new code, pass values in or use a class.

Static variables keep their value

A static variable inside a function is created once and keeps its value between calls. It is still local: code outside the function cannot see it.

<?php
function nextTicket(): int
{
    static $number = 100;   // runs only on the first call
    $number++;
    return $number;
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

function expensiveLookup(string $key): string
{
    static $cache = [];
    if (!isset($cache[$key])) {
        echo "(computing $key) ";
        $cache[$key] = strtoupper($key);
    }
    return $cache[$key];
}

echo expensiveLookup("php"), "\n";
echo expensiveLookup("php"), "\n";   // second call uses the cache

Variable variables ($$name)

$$name uses the value of $name as the name of another variable. It works, but arrays almost always do the same job more clearly:

<?php
$field = "color";
$$field = "blue";        // creates $color
echo $color, "\n";

// The clearer way to have names chosen at runtime:
$settings = [];
$settings[$field] = "blue";
echo $settings["color"], "\n";

Copy or reference

Assigning one variable to another copies the value, arrays included. Put & in front to make both names point at the same value instead:

<?php
$a = [1, 2, 3];
$b = $a;          // copy
$b[] = 4;
echo "a has " . count($a) . ", b has " . count($b) . "\n";

$c = &$a;         // reference: $c and $a are the same array
$c[] = 99;
echo "a has " . count($a) . " after changing c\n";

function addBonus(int &$points)
{
    $points += 10;
}
$score = 5;
addBonus($score);
echo "Score: $score\n";

unset($b);
var_dump(isset($b));

Objects behave differently: assigning an object copies a handle to the same object, so changes through either variable are visible through both. Use clone for a real copy.

Common mistake: a variable set inside an if or a loop

PHP has no block scope, so a variable created inside if, for or foreach still exists after it. That helps, but it hides a bug: when the block does not run, the variable was never created.

<?php
$orders = [];   // try [120, 80] here

$message = "No orders yet";   // set a default before the loop
foreach ($orders as $amount) {
    $message = "Last order: $amount";
}
echo $message, "\n";

foreach ([1, 2, 3] as $n) {
    $last = $n;
}
echo "Still visible after the loop: $last\n";

Without the default line, an empty $orders would leave $message undefined and print a warning. Give every variable a value before the block that might set it.