Use Composer for dependency management and autoloading with composer require and composer.lock. 2. Follow PSR-12 coding standards automated by PHP CS Fixer for consistent, readable code. 3. Write tests with PHPUnit to ensure code reliability and prevent regressions. 4. Use Docker or Laravel Sail for consistent, containerized local development environments. 5. Apply PHPStan or Psalm for static analysis to catch bugs and type issues early. 6. Use a smart IDE like PHPStorm or VS Code with PHP Intelephense for advanced code support and debugging. 7. Manage code with Git, meaningful branching, and a proper .gitignore that excludes vendor and environment files but includes composer.lock to ensure consistent dependencies across environments.

So you're diving into modern PHP development — great choice. Forget the PHP of the early 2000s; today’s ecosystem is robust, fast, and packed with tools that make building reliable, scalable applications not just possible, but efficient. If you're starting fresh or leveling up from legacy practices, here’s your no-fluff guide to the essential tooling every PHP developer should have in their toolkit.

1. Composer: Dependency Management Made Simple

You can’t do modern PHP without Composer. It’s the de facto standard for managing PHP packages and dependencies, much like npm for JavaScript or pip for Python.

• Why it matters: No more manually downloading libraries or worrying about autoloading. Composer handles both.
• Key features:
  • Pull in third-party packages (like Guzzle, Monolog, or Symfony components) with a single command.
  • Auto-generates PSR-4 autoloading so your classes are available without require soup.
  • Locks dependencies with composer.lock for consistent environments.

Quick start:

composer require guzzlehttp/guzzle

Also, get in the habit of using composer require --dev for tools you only need in development (like testing or linting packages).

2. PSR Standards and Code Style: PSR-12 PHP CS Fixer

Readable, consistent code isn’t optional — it’s professional. The PHP-FIG (Framework Interop Group) defines standards like PSR-12 (coding style) that most modern projects follow.

• PSR-12 covers:
  • Class and method naming
  • Indentation and line length
  • Control structure formatting
  • Namespace and use declarations

But memorizing rules is tedious. Use PHP CS Fixer to automate it:

php-cs-fixer fix src/ --rules=@PSR12

Bonus: Integrate it into your editor or Git pre-commit hook so code is cleaned automatically.

3. Testing: PHPUnit for Reliable Code

Testing isn’t just for big teams — it’s a safety net for you. PHPUnit is the most widely used testing framework in PHP.

• Write unit tests to verify individual functions or classes.
• Use assertions to check expected behavior.
• Mock dependencies to isolate logic.

Example test:

public function test_it_adds_two_numbers(): void
{
    $calc = new Calculator();
    $this->assertEquals(4, $calc->add(2, 2));
}

Run tests with:

./vendor/bin/phpunit

Start small — even one test per critical function prevents regressions down the line.

4. Local Development: Docker or Laravel Sail (Even If You’re Not Using Laravel)

Forget “it works on my machine.” Use containers to mirror production.

• Docker lets you define your PHP version, extensions, database, and web server in docker-compose.yml.
• Laravel Sail (yes, even without Laravel) is a lightweight wrapper around Docker that simplifies setup.

Benefits:

• No more XAMPP or MAMP conflicts.
• Share identical environments across your team.
• Easy switching between PHP 8.1, 8.2, 8.3 projects.

Basic docker-compose.yml snippet:

services:
  app:
    image: php:8.3-cli
    volumes:
      - .:/app
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root

5. Static Analysis: PHPStan or Psalm

These tools go beyond syntax checking. They analyze your code for bugs, type mismatches, and dead code — before you run it.

• PHPStan is beginner-friendly and catches things like:
  • Calling methods that don’t exist.
  • Passing wrong types to functions.
  • Unused variables.

Install and run:

composer require --dev phpstan/phpstan
./vendor/bin/phpstan analyse src/

Start at level 5 (in phpstan.neon) and work your way up as your code improves.

6. IDE & Editor Support: Use a Smart Editor

Ditch plain text editors. Use PHPStorm, VS Code with PHP Intelephense, or Vim with language servers.

Features you’ll love:

• Real-time error highlighting
• Auto-completion for classes and methods
• Refactoring tools (rename a class everywhere safely)
• Built-in terminal and debugger

Pair it with PHP Debug (Xdebug or PsySH) for step-through debugging.

7. Version Control: Git Meaningful Branching

This isn’t PHP-specific, but it’s non-negotiable.

• Use Git with a clear branching strategy (like Git Flow or GitHub Flow).
• Write clear commit messages.
• Use .gitignore to exclude vendor/, logs, and environment files.

Example .gitignore essentials:

/vendor
.env
composer.lock

Wait — composer.lock? Yes, commit it. It ensures everyone uses the exact same dependency versions.

Wrap-Up: Build Your Stack

Modern PHP isn’t about one framework or tool — it’s about the ecosystem. Start with this foundation:

• ? Composer for dependencies
• ? PSR-12 PHP CS Fixer for clean code
• ? PHPUnit for confidence
• ? Docker for consistent environments
• ? PHPStan for fewer bugs
• ? Smart editor for productivity
• ? Git for collaboration

Add tools as needed (Laravel, Symfony, API platforms), but nail these first. The rest becomes easier.

Basically, modern PHP feels like a real programming language now — use the tools that prove it.

The above is the detailed content of The Modern PHP Kickstart: A Developer's Guide to Essential Tooling. For more information, please follow other related articles on the PHP Chinese website!