PHP Composer Full Tutorial: A Beginner's Guide to Dependency Management

Introduction to PHP Composer

PHP Composer is like a smart shopping assistant for your PHP projects. It helps you:

1. Download and manage third-party libraries/packages
2. Keep track of exact versions used
3. Automatically load classes
4. Share your own code with others

Why use Composer?
Imagine baking a cake:

• Without Composer: You grow wheat, milk cows, make flour/butter from scratch
• With Composer: You buy pre-made ingredients and focus on baking

Table of Contents

1. Installation Guide
2. Basic Concepts
3. Starting a Project
4. Managing Dependencies
5. Autoloading Magic
6. Updating Packages
7. Version Constraints
8. Common Commands
9. Troubleshooting
10. Advanced Features

1. Installation Guide {#installation}

Windows

1. Download Composer-Setup.exe
2. Run installer (check "Add to PATH")
3. Verify in Command Prompt:

   composer --version
   

Linux/macOS

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

# Move to global location
sudo mv composer.phar /usr/local/bin/composer

Verify installation:

composer --version

2. Basic Concepts {#basic-concepts}

• Dependency: A package your project needs to work
• Packagist: Official package repository (like an app store)
• composer.json: Shopping list of required packages
• composer.lock: Exact versions used (never edit manually)
• vendor directory: Where downloaded packages live

3. Starting a Project {#starting-a-project}

Create a new folder and initialize:

mkdir my-project
cd my-project
composer init

You'll be asked:

1. Package name (vendor/name format, e.g., john/my-project)
2. Description
3. Author
4. Minimum stability (usually stable)
5. Package type (usually project)
6. License
7. Dependencies (press Enter to skip)

Example generated composer.json:

{
    "name": "john/my-project",
    "description": "My awesome project",
    "type": "project",
    "require": {}
}

4. Managing Dependencies {#managing-dependencies}

Adding a Package

To add the popular Monolog logging library:

composer require monolog/monolog

This:

1. Adds monolog to composer.json
2. Downloads it to vendor/
3. Creates composer.lock

Your composer.json now looks like:

{
    "require": {
        "monolog/monolog": "^2.0"
    }
}

Development Dependencies

Packages only needed for development (like testing tools):

composer require phpunit/phpunit --dev

5. Autoloading Magic {#autoloading}

Composer can automatically load your classes. Create this structure:

my-project/
├── composer.json
└── src/
    └── MyClass.php

src/MyClass.php:

<?php

namespace John\MyProject;

class MyClass
{
    public function hello()
    {
        return "Hello from Composer!";
    }
}

Update composer.json:

{
    "autoload": {
        "psr-4": {
            "John\\MyProject\\": "src/"
        }
    }
}

Generate autoloader:

composer dump-autoload

Now use your class:

require 'vendor/autoload.php';

$obj = new John\MyProject\MyClass();
echo $obj->hello();

6. Updating Packages {#updating-packages}

• Install from lock file (team members should do this):

  composer install
  

• Update all packages:

  composer update
  

• Update specific package:

  composer update monolog/monolog
  

7. Version Constraints {#version-constraints}

8. Common Commands {#common-commands}

9. Troubleshooting {#troubleshooting}

Common Issues

1. Memory Limit Errors

   COMPOSER_MEMORY_LIMIT=-1 composer update
   

2. Version Conflicts

   • Remove conflicting packages
   • Update version constraints
   • Use composer why [package] to find conflicts

3. Missing Extensions

   • Install required PHP extensions (e.g., mbstring, openssl)

4. Slow Downloads
   Use China mirror (if needed):

   composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/
   

10. Advanced Features {#advanced-features}

1. Scripts

Automate tasks in composer.json:

{
    "scripts": {
        "test": "phpunit",
        "deploy": [
            "composer install --no-dev",
            "php artisan migrate"
        ]
    }
}

Run with:

composer run test

2. Private Repositories

Add in composer.json:

{
    "repositories": [
        {
            "type": "vcs",
            "url": "git@github.com:yourcompany/private-package.git"
        }
    ]
}

3. Creating Your Own Package

1. Create composer.json
2. Set up PSR-4 autoloading
3. Host on GitHub/Packagist
4. Share with others!

Conclusion: Why Composer Matters

PHP Composer has revolutionized PHP development by:

1. Saving time - No manual dependency management
2. Ensuring consistency - Same versions across environments
3. Encouraging sharing - Vast ecosystem of packages
4. Modernizing PHP - Brings PHP up-to-date with other languages

Best Practices Checklist:

• ✔️ Always commit composer.lock
• ✔️ Use version constraints wisely
• ✔️ Keep vendor/ in .gitignore
• ✔️ Update dependencies regularly
• ✔️ Use meaningful package names

Now you're ready to manage PHP dependencies like a pro! Start by adding Composer to your next project and explore the vast world of PHP packages available.