PHP stands for "PHP: Hypertext Preprocessor" (a recursive acronym). It's a server-side scripting language designed for web development that executes on the server and returns HTML to the browser. PHP is open-source, platform-independent, and can be embedded directly into HTML.

Both echo and print are used to output data, but they have key differences:

• Return value: echo has no return value, while print always returns 1
• Parameters: echo can take multiple parameters, print can only take one
• Speed: echo is marginally faster since it doesn't return a value
• Usage: echo can be used with or without parentheses, print can also be used both ways

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

• include: Includes a file; produces a warning if file not found but continues execution
• require: Includes a file; produces a fatal error if file not found and stops execution
• include_once: Same as include but ensures the file is included only once
• require_once: Same as require but ensures the file is included only once

The "_once" variants prevent redeclaration errors when the same file might be included multiple times.

PHP tags are used to embed PHP code in HTML. The types are:

• Standard tags: <?php ... ?> (recommended and always available)
• Short echo tags: <?= ... ?> (for outputting, always enabled in PHP 5.4+)
• Short tags: <? ... ?> (not recommended, requires short_open_tag enabled)
• ASP tags: <% ... %> (removed in PHP 7.0)

Standard tags are recommended for maximum compatibility and clarity.

PHP supports several data types grouped into three categories:

• Scalar types: boolean, integer, float/double, string
• Compound types: array, object, callable, iterable
• Special types: resource, NULL

PHP is dynamically typed, meaning variables don't need explicit type declaration and can change types during execution.

• == (Equal): Checks if values are equal after type juggling (type coercion)
• === (Identical): Checks if values are equal AND of the same type (strict comparison)

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

Type juggling is PHP's automatic conversion of data types based on context. While convenient, it can cause unexpected results.

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

Use strict comparison (===) and type declarations to avoid issues.

Superglobals are built-in variables that are always accessible from any scope without using the global keyword. The main superglobals are:

• $_GET: Contains GET request data
• $_POST: Contains POST request data
• $_SESSION: Contains session variables
• $_COOKIE: Contains cookie values
• $_SERVER: Contains server and environment information
• $_FILES: Contains information about uploaded files
• $_ENV: Contains environment variables
• $_REQUEST: Contains combined GET, POST, and COOKIE data
• $GLOBALS: Contains all global variables

Constants can be declared using define() function or const keyword:

• define(): Can be used anywhere, supports dynamic names and conditional declaration
• const: Must be declared at top-level scope, faster at compile time, supports class constants

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

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

The null coalescing operator ?? (introduced in PHP 7.0) returns the first operand if it exists and is not null, otherwise returns the second operand. It's useful for providing default values.

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

PHP 7.4 introduced the null coalescing assignment operator ??= for even more concise code.

The spaceship operator <=> (introduced in PHP 7.0) is a three-way comparison operator that returns:

• -1 if left operand is less than right
• 0 if operands are equal
• 1 if left operand is greater than right

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

It's particularly useful for sorting callbacks and comparing multiple values.