PHP Language Basics

isset is true when the variable exists and is not null; being a language construct, it stays quiet on an undefined variable. empty is true for any falsy value — '', 0, '0', [], null. is_null is a function that tests only for null.

== is loose: it may convert the operands to a common type, so 1 == '1' and null == false are true. === is strict: it holds only when the type and the value match, so 1 === '1' is false. For objects === means the same instance.

By default PHP passes by value: the callee gets its own copy, so reassigning it leaves the caller's variable untouched. A &$x parameter binds both names to one value, so writes inside are visible outside. Objects pass a handle by value.

match is an expression: it returns a value, compares arms strictly with ===, never falls through, and throws UnhandledMatchError when nothing matches. switch is a statement: it returns nothing, compares with ==, and falls through.

They disagree exactly when the key exists but holds null: isset($a['k']) is false, array_key_exists('k', $a) is true. isset cannot tell an absent key from a stored null, and ?? follows it. The function needs the array to exist.

global $config; imports one name from the global scope as a reference, so assigning to it also rewrites $GLOBALS['config']. A parameter instead states the dependency in the signature and lets a test pass a stub. global hides that coupling.

in_array compares with == by default, so in_array(0, ['0']) is true — the numeric string compares as a number. Passing true as the third argument switches to ===, matching type and value. array_search and array_keys take the same flag.

$a ?? $b yields $a when it is set and not null, otherwise $b, and it silences the undefined-index warning. ?: uses truthiness and does warn: 0 ?? 5 is 0, 0 ?: 5 is 5. $a ??= $b assigns only when $a is missing or null.

Type juggling is PHP's implicit conversion of an operand to the type an operation expects: '5' + 3 is int 8, 5 . '3' is '53', if ($x) casts to bool, and '', '0', 0 are falsy. strict_types constrains arguments and returns, not operators.

Every function body opens its own variable scope, and there is no implicit capture of the enclosing scope as in JavaScript. Outer values must be passed in explicitly — as parameters, in a closure's use list, or via global.

Both pull another file in and execute it there. On a missing file include emits a warning and the script continues; require raises a fatal error and stops. The _once variants skip a file whose resolved path was already pulled in.

$a?->b() evaluates to null instead of throwing when $a is null, and the rest of the chain is short-circuited — the skipped call's arguments are not evaluated. It guards only against null: a missing method still raises an Error.

A double-quoted string is parsed: $name and {$obj->prop} interpolate, and escapes like \n become real characters. A single-quoted string is literal — only \' and \\ are escapes. The performance gap between the two forms is negligible.

$$name uses the value of $name as another variable's name, resolved at runtime; ${'row_' . $i} builds it from a string expression. It reaches only the current scope, not the caller's. Such a name defeats static analysis, IDE renaming and grep.

Both are multi-line literals opened with <<<. A heredoc uses a bare identifier and acts like a double-quoted string: variables interpolate, escapes are processed. A nowdoc quotes the identifier — <<<'SQL' — and acts like a single-quoted one.

PHP 8.0 first asks whether the string is numeric. If it is, both sides compare as numbers, so 100 == '1e2' stays true. If not, the number is cast to a string and they compare as strings — 0 == 'abc' is now false, where PHP 7 said true.