PHP Quick Reference
This reference condenses the syntax and standard-library patterns used most often in day-to-day PHP work, organized so you can scan for a shape you half-remember rather than re-reading full explanations. It leans on modern PHP 8.x idioms throughout, since that is what production codebases should be targeting today; older syntax (like the long-form array() or the removed create_function()) is intentionally omitted.
Cricket analogy: This reference is like a quick-reference batting cheat sheet a coach keeps pitchside — scannable shot names rather than full biomechanics lectures — built entirely around today's modern technique (front-foot press, not the old back-and-across style), deliberately leaving out retired approaches like the discontinued timeless-Test scheduling.
Variables, types, and control flow
Variables are prefixed with $ and are dynamically typed unless a type declaration is added to a property, parameter, or return type, in which case PHP enforces it (strictly, if declare(strict_types=1) is set at the top of the file). Control flow covers the familiar if/elseif/else, switch, and the PHP 8 match expression, which is stricter (uses === internally) and returns a value directly instead of relying on fallthrough case blocks.
Cricket analogy: A PHP variable is like a player who can bat anywhere in the order by default (dynamically typed), but once a captain locks them into 'opener' (a type declaration), they must bat there strictly if strict_types is set; decision-making covers the familiar single-appeal review, the multi-outcome DRS menu (switch), and the newer stricter ball-tracking call (match).
Functions and arrays
Functions support default values, variadic parameters (...$args), named arguments, and arrow functions (fn($x) => $x * 2) that automatically capture the enclosing scope by value. Arrays are ordered maps that serve as both lists and dictionaries; the standard library's array functions (array_map, array_filter, array_reduce, array_merge, usort) cover the majority of transformation needs without hand-written loops.
Cricket analogy: A bowler's over is like a function with a default field placement, a variadic number of slip fielders (...$slips) you can add as needed, and named calls like setField(point: true) for clarity; a batting lineup is an array serving as both a batting order (list) and a stats sheet keyed by name (dict), and array_map/filter/reduce are like transforming a scorecard into strike rates, filtering out ducks, and totaling the innings.
OOP and modern PHP 8.x syntax
Classes support typed properties, readonly properties (write-once, set only from inside the declaring class, usually the constructor), constructor property promotion, interfaces, abstract classes, traits, and enums (both pure and backed). The nullsafe operator (?->) and named arguments reduce boilerplate for optional chaining and self-documenting calls respectively.
Cricket analogy: A readonly property is like a player's date of birth on a scorecard — set once at registration (constructor) and never changed again; traits are like a shared fielding-drill routine multiple teams borrow without a formal coaching lineage, enums are like a fixed list of dismissal types (bowled, caught, LBW), and the nullsafe operator (?->) safely checks $team?->captain?->name without crashing if the team has no captain yet.
declare(strict_types=1);
enum Status: string
{
case Draft = 'draft';
case Published = 'published';
}
final class Post
{
public function __construct(
public readonly string $title,
public readonly Status $status = Status::Draft,
) {}
}
$posts = [new Post('A'), new Post('B', Status::Published)];
$published = array_filter(
$posts,
fn (Post $p): bool => $p->status === Status::Published,
);
$labels = array_map(
fn (Post $p): string => match ($p->status) {
Status::Draft => "{$p->title} (draft)",
Status::Published => "{$p->title} (live)",
},
$posts,
);Keep declare(strict_types=1) at the very top of files you author — it's a per-file opt-in, and it turns silent type coercion at function boundaries into loud TypeError exceptions, catching bugs far earlier than loose-mode PHP would.
matchis strict (===) and returns a value;switchis loose and relies on fallthrough control flow.- Arrow functions (
fn) auto-capture enclosing scope by value; closures (function() use (...)) require explicit capture. readonlyproperties can be set once, typically in the constructor, and never modified afterward.- Constructor property promotion (
public readonly string $titlein the constructor signature) eliminates boilerplate assignment. - Core array functions to know cold: array_map, array_filter, array_reduce, array_merge, usort.
declare(strict_types=1)converts silent type coercion into thrown TypeErrors, catching bugs earlier.
Practice what you learned
1. How does `match` differ from `switch` in comparison semantics?
2. What does constructor property promotion allow you to do?
3. What is the effect of declaring a property `readonly`?
4. What is the key behavioral difference between an arrow function (`fn`) and a traditional closure (`function() use (...)`)?
5. What does `declare(strict_types=1)` do?
Was this page helpful?
You May Also Like
Match Expressions
Introduces PHP 8's match expression, its strict comparison semantics, and why it is often a safer, more concise replacement for switch.
Type Declarations and Strict Types
PHP supports optional scalar and object type declarations on parameters, return values, and properties, with strict_types controlling how aggressively the engine coerces mismatched values.
Enums in PHP
PHP 8.1 enums provide a first-class way to define a fixed set of named values, with optional scalar backing, methods, interfaces, and constants attached.
Common PHP Pitfalls
A field guide to PHP's most persistent gotchas — loose comparison surprises, array reference bugs, and mutable state traps — and how to avoid them.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics