.PHP File Format – Types

null

null is the only value of its type. A variable has it when it has been assigned null, has not been assigned anything, or has been unset(). Reading an undefined variable gives a warning (a notice before PHP 8.0) and the value null.

bool

Values that convert to false: the boolean false, the integer 0, the floats 0.0 and -0.0, the empty string and the string "0", an empty array, and null. Every other value is true, including "0.0", "00", [0], any object and NAN.

int

Limits are given by PHP_INT_SIZE, PHP_INT_MIN and PHP_INT_MAX. Integer overflow does not wrap: if a literal or a calculation goes outside the range, the result becomes a float. / gives a float unless both operands are integers and the result is exact; use intdiv() for integer division. See Integer literals.

float

A float is usually a 64-bit IEEE 754 number. PHP_FLOAT_MAX, PHP_FLOAT_MIN (the smallest positive normal value), PHP_FLOAT_DIG and PHP_FLOAT_EPSILON describe the format. INF and NAN are constants. Do not compare with NAN: ==, ===, < and > are false against any number, and != and !== are true. Comparing with a boolean converts NAN to true. Use is_nan() instead.

string

A string is a run of bytes. It is indexed from 0 with $s[0], and negative offsets count from the end (PHP 7.1). Reading or writing an offset is by byte, not by character. The older $s{0} syntax was removed in PHP 8.0. See Strings.

array

An array is an ordered map, used as a list, a dictionary, a stack and a queue alike. Its syntax and key rules are on the Expressions page.

callable

A callable is a value that can be called. It may be a Closure, the name of a function as a string, an array of an object or a class name and a method name, 'Class::method', or an object with __invoke(). Language constructs such as echo and isset are not callables. See Callables.

resource

A resource is a special value holding a reference to something external, such as a file handle. is_resource() and get_resource_type() inspect one. Many extensions have replaced their resources with opaque objects in PHP 8. A resource cannot be used as a type in a declaration.

Numeric strings

WHITESPACES       \s*
LNUM              [0-9]+
DNUM              ([0-9]*[.]{LNUM}) | ({LNUM}[.][0-9]*)
EXPONENT_DNUM     (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
INT_NUM_STRING    {WHITESPACES} [+-]? {LNUM} {WHITESPACES}
FLOAT_NUM_STRING  {WHITESPACES} [+-]? ({DNUM} | {EXPONENT_DNUM}) {WHITESPACES}
NUM_STRING        ({INT_NUM_STRING} | {FLOAT_NUM_STRING})

A string matching NUM_STRING is numeric. A string that begins with a numeric string and continues with other characters is leading-numeric. In a numeric context, since PHP 8.0:

Before 8.0 trailing white space made a string only leading-numeric, a non-numeric string counted as 0 with a warning, and a leading-numeric string gave only a notice.

Conversions

Since PHP 8.1 an implicit conversion of a float with a fractional part to an integer is deprecated, and since 8.5 converting NAN to any other type warns.

Casts

A cast is a type name in parentheses before a value. White space inside the parentheses is ignored.

settype() changes a variable’s type in place. intval(), floatval(), strval() and boolval() do the same conversions as function calls.

Numbers and strings since PHP 8.0

Comparing a number with a string compares numerically only if the string is numeric. Otherwise the number is converted to a string and they are compared as text.

Two numeric strings still compare as numbers, so "1e3" == "1000" is true. Compare hashes and other digit strings with ===.

empty, isset and bool

Loose comparison with ==

PHP 8 results. T is true, F is false.

With === a value is equal only to itself of the same type. Two arrays are === only if they have the same key and value pairs in the same order with the same types, and two objects only if they are the same instance.

Nullable types

?T means T or null (PHP 7.1) and is the same as the union T|null. Writing T $x = null used to make a parameter implicitly nullable. That is deprecated since PHP 8.4; write ?T $x = null instead.

Union types

A union (PHP 8.0) is written int|string. The compiler rejects redundant forms:

• Each name-resolved type may appear only once, so int|string|INT is an error. A class in a union and its alias through use count as the same name.
• bool cannot be combined with false or true, false and true cannot be combined, and iterable cannot be combined with array or Traversable.
• object cannot be combined with a class type.
• mixed and never cannot appear in a union.
• Before 8.2 null and false could not stand alone, and false|null and ?false were not allowed.

Only redundancy that can be seen without loading classes is an error, so A|B is legal even when B extends A.

Intersection types

An intersection (PHP 8.1) is written Countable&Traversable and requires a value to be an instance of all the listed types. Members must be class-like types: scalars, object, mixed and static are errors, and each name may appear only once.

DNF types

Disjunctive normal form (PHP 8.2) is a union of intersections, with each intersection in parentheses:

function save((Countable&Traversable)|array|null $items): void {}

An intersection written without parentheses inside a union is a parse error. A type already covered by a more general member, such as A|(A&B), is an error, and so is the same intersection listed twice.

Coercive typing

By default a scalar value of the wrong type is converted to the declared scalar type, if the conversion is defined:

For an int or float parameter a string must be fully numeric, with white space allowed on either side: "5" and " 5 " are accepted, and "5 apples" is a TypeError. Passing null to a scalar parameter of an internal function is deprecated since PHP 8.1. A user-defined function rejects it with a TypeError unless its type allows null.

For a union, if the exact type is present it is used. Otherwise conversions are tried in the order int, float, string, bool, taking the first that works. A numeric string with both int and float available goes by its own numeric type: "42" becomes an integer and "42.0" a float. A string that fits neither falls back to bool if the union has it.

Strict typing

declare(strict_types=1); (PHP 7.0) turns off coercion for calls made from that file. The check is made at the call, so it is the caller’s file that decides. The only conversion left is int to float.

<?php
declare(strict_types=1);

function half(int $n): float { return $n / 2; }

half(4);       // 2.0
half("4");     // TypeError: argument must be of type int, string given
half(1.5);     // TypeError: argument must be of type int, float given

• Internal callback calls are not affected, because they are not made from the file.
• Strict mode applies only to scalar types. A class type is always checked exactly.
• A file with declare(strict_types=1) calling a function defined in a non-strict file is still checked strictly.

Return types and variance

A return type goes after the parameter list with a colon. It is checked against the value actually returned, under the file’s typing mode. Function, method and property types follow the variance rules when overriding:

• Return types are covariant: a child may return a narrower type.
• Parameter types are contravariant: a child may accept a wider type.
• Property types are invariant: a child must declare the same type.