PHP Quick Reference

Analogy categoryAnalogies

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.

php

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.

match is strict (===) and returns a value; switch is loose and relies on fallthrough control flow.
Arrow functions (fn) auto-capture enclosing scope by value; closures (function() use (...)) require explicit capture.
readonly properties can be set once, typically in the constructor, and never modified afterward.
Constructor property promotion (public readonly string $title in 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?

Common PHP Pitfalls

Related Study Notes in Programming

Browse all study notes

Programming

Apache Spark Study Notes

Programming · 30 topics

Programming

Apache Flink Study Notes

Programming · 30 topics

Programming

Hadoop Study Notes

Programming · 30 topics

Programming

Snowflake Study Notes

Programming · 30 topics

Programming

Apache Airflow Study Notes

Programming · 30 topics

Programming

dbt (Data Build Tool) Study Notes

Programming · 30 topics

Topics covered

#PHP#PHPProgrammingStudyNotes#Programming#PHPQuickReference#Quick#Reference#Variables#Types#StudyNotes#SkillVeris

PHP Quick Reference