.PHP File Format – Variables

Basics

• Names follow the identifier pattern and are case-sensitive: $a and $A are different variables.
• Reading a variable that was never assigned gives null and raises a warning (a notice before PHP 8.0). isset() checks for it without a warning, and ?? supplies a fallback.
• Appending to an undefined variable, $list[] = 1;, creates an array without a warning.
• unset($a) destroys a variable. After it, reading $a is the same as reading an undefined variable.
• $this is special. It is the current object in a method and cannot be assigned to.

Assignment copies the value. Arrays are copied too, but the copy is made only when one of them is modified (copy on write). An object variable holds a handle to the object, so assigning it does not copy the object. Use clone for that.

Scope

A variable belongs to the scope where it was created.

• Global scope is everything outside functions. A file included at that level shares it.
• Function scope. Each function has its own variables, and global variables are not visible inside unless asked for. Blocks such as if and for do not create a scope, so a variable set inside one remains set afterwards.
• Closures have function scope too and import outer variables with use. Arrow functions capture them automatically by value.

$count = 1;

function bump(): void {
    global $count;
    $count++;
}

bump();
echo $count;  // 2

function counter(): int {
    static $n = 0;
    return ++$n;
}

counter();  // 1
counter();  // 2

Variable variables

A variable name can come from a variable.

$name = 'greeting';
$$name = 'hello';      // sets $greeting
${'a' . 'b'} = 1;      // sets $ab
echo ${$name};         // hello

$obj = new stdClass;
$obj->$name = 2;       // sets $obj->greeting
$obj->{'a-b'} = 3;     // a property name that is not an identifier
$func = 'strlen';
echo $func('abc');     // 3

• $$a[1] is ambiguous. Since PHP 7.0, with uniform variable syntax, indirect expressions are read strictly from left to right, so it means ${$a}[1]. Use braces to mean ${$a[1]}.
• Superglobals and $this cannot be used as variable variables inside functions and methods.
• Any byte sequence can name a variable when written this way, including names that could not be typed directly: ${'invalid-name'} = 1;.

References

A reference makes two names refer to the same value. It is not a pointer. There is no address and no arithmetic. Internally both names point at a shared slot.

• unset($a) breaks only the binding of the name $a. Other names sharing the value keep it.
• After a foreach by reference, the loop variable still refers to the last element. Writing to it later changes that element. Call unset($v) after the loop.
• A value that is not a variable, such as a function result or a literal, cannot be passed to a by-reference parameter.
• A reference in an array element is copied as a reference. Assigning such an array shares that element, which is a common source of surprises.
• Objects are not references. An object variable is a handle, passed by value: reassigning it inside a function does not change the caller’s variable, but changing the object’s properties does.
• A reference to a typed property keeps the property’s type, so a write of the wrong type through the reference fails.

Superglobals

Superglobals are arrays available in every scope with no global declaration. Programs cannot define their own. Whether the request-based ones are filled depends on the variables_order setting.

Since PHP 8.1 $GLOBALS is restricted. Reading it or writing individual elements works as before, but writing to it as a whole ($GLOBALS = [], unset($GLOBALS)) is a compile error, and a copy of it is an ordinary array whose changes do not reach the globals.

Constants

A constant holds a value that cannot change once set. Its name has no $ and is case-sensitive, and it is available everywhere, unless it is in a namespace. There are two ways to define one (manual).

const LIMIT = 100;
const DOUBLE = LIMIT * 2;
define('STARTED_AT', time());

echo LIMIT;                  // 100
echo constant('LIMIT');      // the name as a string
var_dump(defined('LIMIT'));  // true

Using an undefined constant throws Error since PHP 8.0. Older versions treated it as a string of its own name, with a notice.