PHP (Stack) rules

Do not use global variables to share data across your program. Prefer passing values as function parameters or using configuration objects. Limiting variable scope makes code more predictable and less prone to side effects.

Do not use the error‐suppression operator '@' before function calls or expressions. Instead, handle potential errors properly using return checks or exceptions (try/catch).

Cache frequently used, rarely changing query results in memory or an external cache with appropriate TTL/invalidations.

Define configuration values in one place (env/config file/const class) and reference them; avoid scattering magic strings.

Extract reusable SQL fragments/builders for commonly repeated WHERE/ORDER clauses.

Always specify access levels (public, private, protected) when declaring class properties and methods. Don’t use the old `var` keyword for properties. Explicit visibility clarifies intent and prevents unintended access.

Avoid empty catch blocks. When you catch an exception, implement meaningful handling: log the error, perform a fallback action, or rethrow after processing. Do not catch exceptions generically just to suppress them.

Avoid functions or extensions deprecated in recent PHP versions (e.g., mysql_* or preg_replace without proper delimiters). Use modern supported alternatives like PDO/MySQLi for DB or PCRE functions (preg_match, preg_replace with correct syntax).

Avoid using the `goto` statement for flow control. Instead, refactor code using loops (for, while) and conditional structures (if/else, switch) for clear and maintainable logic.

At the top of your PHP files (before any code), declare `declare(strict_types=1)`. This forces PHP to enforce the declared parameter and return types strictly, avoiding automatic type coercion.

Move repeated domain calculations/transformations into named functions or service classes; keep controllers/scripts thin.

Use ?? and the nullsafe operator (?->) to provide defaults and avoid notices when values may be null.

Write functions and methods so each does one well-defined task. If a function handles distinct steps (validation, processing, saving, notifying), refactor into smaller focused functions.

Use strict comparison operators (=== and !==) instead of loose (== and !=) in most cases. Strict comparisons check both type and value, avoiding PHP’s implicit type coercion pitfalls.

After using external resources (DB connections, open files, sockets), release them properly. Use fclose(), close database connections or finally blocks to ensure cleanup even if errors occur.

Deduplicate identical queries within a request; reuse previously fetched data or preload in a single query.

Eliminate debug helpers (var_dump, die, print_r) and commented-out blocks before merging.

Do not use echo/var_dump for diagnostics in application code; use a PSR-3 logger or error_log with levels.

Prefer set-based SQL (DELETE/UPDATE with WHERE IN/JOIN) or chunked batches over per-row statements.

Always specify ORDER BY when the processing logic relies on a particular order.

Stream results (cursor/generator) or paginate instead of loading entire result sets into memory.

Add scalar/union/nullable type hints and return types to functions, methods, and properties; prefer interfaces over mixed.