PHP.

PHP stands for PHP: Hypertext Preprocessor. It is a recursive acronym, because the first word of the name is the name itself. PHP is an open source server-side scripting language designed for web development.

The code runs on the server, and PHP sends the result to the browser, usually as HTML. The visitor receives only that output, never the PHP source. PHP can be embedded directly in HTML between <?php and ?> tags, or fill whole files.

PHP is also platform-independent, so the same code runs on Linux, Windows and macOS.

Both output data, but echo can take several comma-separated arguments and returns nothing, while print takes exactly one argument and always returns 1. Because it returns a value, print can sit inside an expression, such as an if condition.

echo "Hello", " World"; // Works
print "Hello World";     // Works
// print "Hello", " World"; // Error - multiple parameters not allowed

Neither is a real function. Both are language constructs, so parentheses are optional for both. echo("hello") works only because the parentheses belong to the expression being printed, which is also why echo("a", "b") is a parse error. As constructs, neither works as a variable function, where PHP calls the function whose name a variable holds.

echo is marginally faster because it returns no value, but the gap is too small to matter. The <?= tag is shorthand for <?php echo.

include and require both load and run another file, but a missing file triggers a warning with include and stops the script with require. The _once versions behave the same way, except they skip a file already loaded.

• include emits an E_WARNING for a missing file, and the script keeps running.
• require throws an Error for a missing file, which ends the script unless caught. Before PHP 8.0 it raised a fatal E_COMPILE_ERROR.
• include_once and require_once load a file only once. A later call for the same file returns true without loading it.

The _once variants prevent redeclaration errors when the same file might be included more than once, such as a shared helpers file. Use require_once for files the code cannot run without, and plain include for optional parts, such as a template fragment.

PHP tags mark where PHP code starts and stops, which is how PHP is embedded in HTML. The parser runs the code inside the tags and outputs everything else unchanged.

• Standard tags <?php ... ?> always work and are the recommended choice.
• Short echo tags <?= ... ?> print a value. They have always been available since PHP 5.4.
• Short tags <? ... ?> need the short_open_tag setting, so avoid them.
• ASP tags <% ... %> were removed in PHP 7.0.

In a file that contains only PHP, leave out the closing ?>, so no stray newline gets sent as output.

PHP's data types fall into three groups: scalar types that hold one value, compound types that hold several, and special types.

• Scalar: bool for true or false, int and float for numbers, and string for text. A float is also called a double.
• Compound: array, object and callable. iterable is a type alias for an array or a Traversable object.
• Special: null for no value, and resource for a handle such as a file.

PHP is dynamically typed. A variable takes its type from its value and can change type while the script runs. Type declarations add checks where you want them.

== checks loose equality, comparing values after type juggling, so PHP may convert one side first. === checks strict equality and is true only when the value and the type both match, with no conversion.

$a = "5";  // string
$b = 5;    // integer
var_dump($a == $b);  // true (values equal after conversion)
var_dump($a === $b); // false (different types)

Loose comparison causes surprises. Before PHP 8, 0 == "foo" was true, because PHP turned the string into the number 0. Since PHP 8, a number compared with a non-numeric string is compared as strings, so the result is false. Numeric strings still compare as numbers, so "1" == "01" is true.

Use === and !== by default, especially where 0, "" and null can appear. Reach for == only when the conversion is what you want.

Type juggling is PHP converting a value to another type automatically, based on the context it is used in. An arithmetic operator needs numbers, so a numeric string becomes a number.

$str = "10";
$num = 5;
echo $str + $num; // 15 (string converted to integer)

It is convenient, but it can give unexpected results. Since PHP 8, a string that is not numeric at all, such as "abc", throws a TypeError in arithmetic. A string with a numeric start, such as "10 apples", still works but raises a warning.

To avoid surprises, use strict comparison with === and add type declarations to parameters and return values.

Superglobals are built-in variables that are available in every scope, so a function can read them without the global keyword.

• $_GET: query string parameters from the URL
• $_POST: form data from a POST request body
• $_COOKIE: cookies sent by the browser
• $_FILES: uploaded files
• $_SESSION: data in the current session
• $_SERVER: headers, paths and server details
• $_ENV: environment variables
• $_REQUEST: $_GET, $_POST and $_COOKIE combined by default
• $GLOBALS: every global variable

Values in $_GET, $_POST and $_COOKIE come from the client, so treat them as untrusted. Prefer them over $_REQUEST, so you know where each value came from.

Declare a constant with the const keyword or the define() function. The main difference is timing. const is defined at compile time, so it must sit at the top level of a file or inside a class. define() runs at runtime like any function call, so it works anywhere, including inside an if.

define('MAX_SIZE', 100);
const MIN_SIZE = 10;

// define() can be conditional
if ($condition) {
    define('DYNAMIC', 'value');
}
// const cannot be used conditionally

Because of that, const cannot appear inside functions, loops or if and try blocks. define() can also build the constant's name at runtime and accepts any expression as the value. Only const can declare class constants.

Prefer const for fixed values, and keep define() for constants that are conditional or have computed names.

The null coalescing operator ?? returns its left operand if it exists and is not null, and otherwise returns the right operand. PHP 7.0 added it as a short form of a ternary with isset(). It is handy for default values.

$username = $_GET['user'] ?? 'guest';
// Equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'guest';

Like isset(), it raises no warning when the key or variable is missing. It can be chained, so $_GET['user'] ?? $_POST['user'] ?? 'guest' returns the first value that is set.

PHP 7.4 added the null coalescing assignment operator ??=. It assigns only when the left side is missing or null, as in $config['timeout'] ??= 30.

The spaceship operator <=> is a three-way comparison operator. It returns -1 when the left side is smaller, 0 when both sides are equal, and 1 when the left side is greater. PHP 7.0 introduced it.

echo 1 <=> 2;  // -1
echo 2 <=> 2;  // 0
echo 3 <=> 2;  // 1

It follows PHP's usual comparison rules, so it works on numbers, strings and arrays. Its main use is sorting callbacks, because usort() expects exactly this kind of result. For example, usort($users, fn($a, $b) => $a->age <=> $b->age) sorts users by age.

It also compares several values at once. Comparing arrays, as in [$a->last, $a->first] <=> [$b->last, $b->first], sorts by last name and then by first name. Swap $a and $b to sort in descending order.