The core of modern PHP development is the three pillars of syntax, server and Composer. 1. Use modern PHP syntax: including type attributes of PHP 7.4 (such as public string $name), union type of PHP 8.0 (int|float), nullsafe operator (?->), match expressions and attributes metadata to improve code security and readability, and declare declare(strict_types=1) at the top of the file to enable strict types. 2. Choose the right local development server: Abandon simple php -S and use Laravel Sail, Symfony CLI, or Docker Compose to support HTTPS, database integration and team environment consistency. 3. Master Composer dependency management: initialize the project through composer init, use require and require-dev to distinguish production and development dependencies, configure PSR-4 automatic loading (such as "App\": "src/"), run composer dump-autoload -o to generate automatic loading files, use scripts to define test and analysis commands, and always submit composer.lock file to ensure that the dependency version is consistent. In summary, modern PHP development should adhere to type safety, containerized services and intelligent dependency management in order to efficiently build maintainable applications.

So you're diving into modern PHP—great choice. It's not the PHP of 2010 anymore. Gone are the days of spaghetti code and global state everywhere. Today's PHP is structured, fast, and developer-friendly. If you're starting fresh or brushing up after a break, here's what you need to know about syntax , servers , and Composer —the three pillars of modern PHP development.

? Modern PHP Syntax: Clean, Expressive, and Safe

PHP has evolved fast since version 7.0, and PHP 8.x brings powerful syntax improvements that make code safer and more readable.

Key Features You Should Be Using:

• Typed Properties (PHP 7.4)

  

   class User {
      public string $name;
      public int $age;
  }

  No more guessing what type a property should hold.

• Union Types (PHP 8.0)

  

   public function setScore(int|float $score): void {
      // accepts both integers and floats
  }

• Nullsafe Operator (PHP 8.0)

   $country = $user?->getAddress()?->getCountry()?->getName();

  Avoids a chain of isset() checks.

• Match Expression (PHP 8.0)

   $status = match($code) {
      200 => 'OK',
      404 => 'Not Found',
      default => 'Unknown'
  };

  Safer and more concise than switch .

• Attributes (PHP 8.0) – a native way to add metadata

   #[Route('/users', methods: ['GET'])]
  public function listUsers() { }

  Replaces docblock annotations used in older frameworks.

? Pro tip: Use strict types at the top of your files:

 declare(strict_types=1);

This enforces type declarations and prevents silent coercion.

?? Local Development Servers: Beyond php -S

You've probably used the built-in PHP server:

 php -S localhost:8000

It's fine for quick tests, but real projects need more: HTTPS, shared environments, database integration.

Better Options for Modern Dev:

• Laravel Sail (Docker-based)
  Even if you're not using Laravel, Sail gives you a full PHP/MySQL/Nginx stack with one command:

   sail up

• Symfony CLI
  Super simple for starting PHP apps:

   symfony serve

  Comes with TLS/HTTPS by default, great for testing OAuth or secure APIs.

• Docker Docker Compose
  For full control:

   # docker-compose.yml
  services:
    app:
      image: php:8.3-apache
      Ports:
        - "8000:80"
      Volumes:
        - ./:/var/www/html

  This is how teams standardize environments.

? Pick one and stick with it. Consistency across your team matters more than the tool itself.

? Composer: Dependency Management Like a Pro

Composer is PHP's answer to npm or pip. It manages libraries, autoloading, and even scripts.

Getting Started:

 composer init
composer requires guzzlehttp/guzzle

This creates composer.json and pulls in Guzzle for HTTP requests.

Key Concepts:

• Autoloading with PSR-4
  Define your namespace in composer.json :

   "autoload": {
      "psr-4": {
          "App\\": "src/"
      }
  }

  Then run:

   composer dump-autoload -o

  Now App\User loads from src/User.php automatically.

• Require vs Require-dev

  • require : libraries needed in production (eg, framework, HTTP client)
  • require-dev : tools for development (eg, PHPUnit, PHPStan)

• Scripts
  Automate tasks:

   "scripts": {
      "test": "phpunit",
      "analyze": "phpstan analyze src/"
  }

  Run with: composer test

• Lock Files Matter
  composer.lock ensures everyone uses the exact same versions. Always commit it.

? Update wisely:

 composer update

can break things. Prefer composer update vendor/package to target specific packages.

---

Modern PHP isn't just about new syntax—it's about using the whole ecosystem: clean code, reliable local servers, and smart dependency management.

Basically: type your code, containerize your server, and let Composer handle the rest. That's how PHP is done today.

The above is the detailed content of Embarking on Modern PHP: Syntax, Servers, and Composer. For more information, please follow other related articles on the PHP Chinese website!