PHP Reference

Getting Started — what PHP is and can do, a short history from PHP/FI to 8.5, the PHP Foundation and the RFC process, installing PHP on Linux, macOS, Windows and Docker, the CLI, the built-in web server, and how a script runs from source to opcodes.

Configuration and Extensions — php.ini and its search order, .user.ini, ini_set() and the changeable modes, the core directives, loading extensions, PECL versus PIE, phpinfo() and the SAPIs.

Basic Syntax and Style — tags, escaping from HTML, statements and comments, reserved words, naming, PSR-1 and PER Coding Style 3, and PHPDoc.

Types and the Type System — every type, union, intersection and DNF types, nullable types, never and void, and strict_types.

Type Juggling and Comparisons — conversion rules and casts, the PHP 8 string-to-number comparison change, == versus ===, and the comparison tables.

Variables, Scope and Constants — assignment, scope, global and static, superglobals, isset()/empty()/unset(), constants and magic constants.

Operators and Expressions — every operator with precedence, including ??, ??=, <=>, ?->, the pipe operator |> (8.5) and the spread operator.

Control Structures — if, loops, foreach by reference, switch versus match, declare, and include/require.

Strings — quoting, interpolation, heredoc and nowdoc, and the string API by family.

Unicode, mbstring and intl — bytes, code points and graphemes, mbstring, and locale-aware formatting with intl.

Regular Expressions — PCRE2 syntax and modifiers, the preg_* functions, Unicode matching and ReDoS.

Arrays — the ordered-map model, key casting, destructuring, and the array API including array_find() (8.4) and array_first() (8.5).

Functions — arguments by value and by reference, defaults, variadics, named arguments, return types and recursion.

Closures and Callables — closures and use, arrow functions, the Closure class, first-class callable syntax and every callable form.

Classes and Objects — properties, constants, constructors and promotion, static members, anonymous classes and object comparison.

Visibility, Readonly and Asymmetric Visibility — public/protected/private, readonly properties and classes, and public private(set) (8.4).

Property Hooks — get and set hooks (8.4), backed and virtual properties, and hooks in interfaces.

Inheritance, Interfaces and Abstract Classes — extends, overriding and signature rules, final, abstract classes, interfaces, #[\Override] and variance.

Traits — using traits, conflict resolution, abstract and static members, and when to prefer composition.

Enumerations — pure and backed enums (8.1), methods, interfaces, constants and serialisation.

Magic Methods and Overloading — every magic method, property and method overloading, and the serialisation hooks.

Cloning, Late Static Binding and Object Lifecycle — clone and clone() with properties (8.5), static::, weak references and lazy objects (8.4).

Namespaces and Autoloading — namespaces, use and name resolution, spl_autoload_register() and PSR-4.

Attributes — syntax, custom attribute classes, reading them with Reflection, and every predefined attribute.

Reflection — the Reflection API for classes, methods, properties, types, enums and attributes.

Errors and Exceptions — the Throwable hierarchy, try/catch/finally, custom exceptions, error levels and handlers.

Iterators and Generators — the iterator interfaces, the SPL iterators, and generators with keys, send() and yield from.

Fibers and Asynchronous PHP — fibers (8.1), a minimal scheduler, the event-loop libraries built on them, and process-level concurrency.

References and Memory Management — references, zvals and copy-on-write, and the cycle garbage collector.

SPL Data Structures — stacks, queues, heaps, fixed arrays, object storage and when a plain array is better.

Date and Time — DateTimeImmutable, parsing and formatting, intervals and periods, time zones, and testable clocks.

Math, Numbers and Randomness — the maths functions, floating-point pitfalls, BCMath and GMP, and the Random extension.

Files, Streams and I/O — reading and writing files, CSV, locking, directories, stream wrappers, filters and contexts.

JSON, XML and Serialization — JSON with exceptions, serialize() safety, SimpleXML, DOM and the HTML5 parser, XMLReader/XMLWriter and XSL.

Cryptography, Hashing and Passwords — hashing, HMAC, password_hash(), sodium, OpenSSL and secure randomness.

Command-Line PHP — the CLI SAPI, arguments and options, streams and exit codes, running programs safely, signals, and Symfony Console.

Composer and Packages — composer.json, version constraints, the lock file, autoloading, scripts, auditing and PIE.

PSR Standards and Coding Style — every accepted PSR, PER Coding Style 3, PHP_CodeSniffer, PHP-CS-Fixer and Pint.

Static Analysis and Refactoring — PHPStan, PHPDoc types and generics, Psalm, and Rector.

Testing with PHPUnit and Pest — PHPUnit 13 and Pest 5, test doubles, coverage, architecture tests and mutation testing.

Debugging and Profiling — dumping values, backtraces, Xdebug 3, phpdbg and system tracing probes.

OPcache, JIT and Performance — OPcache settings, preloading, the JIT with measurements, FFI and benchmarking.

What’s New and Migration — every release from 7.0 to 8.6, the support timeline, deprecations, PHP 9, upgrading, and what older books get wrong.

Cheat Sheet — a one-page summary of the language, with a downloadable PDF.