# Composer — Abhängigkeitsverwaltung für PHP

> Praxis-Guide zu Composer — Abhängigkeitsmanager für PHP: Pakete installieren, Versionen verwalten und das Autoloading optimieren.

Source: https://www.jpkc.com/db/cheatsheets/build-languages/composer/

<!-- PROSE:intro -->
Composer ist das zentrale Werkzeug zur Abhängigkeitsverwaltung in der PHP-Welt – es installiert Bibliotheken, hält ihre Versionen sauber im Griff und erzeugt das Autoloading, damit du Klassen ohne manuelle `require`-Zeilen nutzen kannst. Über das zentrale Paket-Verzeichnis Packagist ziehst du mit wenigen Befehlen alles von Guzzle bis zum kompletten Laravel-Framework in dein Projekt. Dieser Guide führt dich durch den Alltag: Projekt aufsetzen, Pakete einbinden und aktualisieren, Versionen mit Constraints steuern und den Autoloader für die Produktion optimieren.
<!-- PROSE:intro:end -->

## Projekt aufsetzen

`composer init` — Erstellt interaktiv eine neue composer.json im aktuellen Verzeichnis.

```bash
composer init
```

`composer init --name=<vendor>/<package>` — Erstellt eine neue composer.json mit vorgegebenem Paketnamen.

```bash
composer init --name=acme/my-project
```

`composer create-project <package> <directory>` — Erstellt ein neues Projekt aus einem bestehenden Paket (wie Klonen + Installieren).

```bash
composer create-project laravel/laravel my-app
```

`composer create-project <package> <directory> <version>` — Erstellt ein neues Projekt aus einer bestimmten Version eines Pakets.

```bash
composer create-project laravel/laravel my-app "11.*"
```

## Pakete installieren

`composer install` — Installiert alle in composer.lock definierten Abhängigkeiten (oder aus composer.json, falls keine Lock-Datei existiert).

```bash
composer install
```

`composer install --no-dev` — Installiert nur Produktions-Abhängigkeiten und überspringt require-dev-Pakete.

```bash
composer install --no-dev
```

`composer install --optimize-autoloader` — Installiert die Abhängigkeiten und erzeugt eine optimierte Class-Map fürs Autoloading.

```bash
composer install --optimize-autoloader
```

`composer install --no-scripts` — Installiert die Abhängigkeiten, ohne in composer.json definierte Skripte auszuführen.

```bash
composer install --no-scripts
```

`composer install --dry-run` — Simuliert die Installation, ohne tatsächlich etwas zu verändern.

```bash
composer install --dry-run
```

## Pakete einbinden (require)

`composer require <package>` — Fügt ein Paket zu require hinzu und installiert es.

```bash
composer require guzzlehttp/guzzle
```

`composer require <package>:<version>` — Bindet eine bestimmte Version oder ein Versions-Constraint eines Pakets ein.

```bash
composer require guzzlehttp/guzzle:^7.0
```

`composer require --dev <package>` — Fügt ein Paket als Entwicklungs-Abhängigkeit hinzu (require-dev).

```bash
composer require --dev phpunit/phpunit
```

`composer require <package> --with-all-dependencies` — Erlaubt beim Einbinden, alle Abhängigkeiten (auch bereits installierte) zu aktualisieren.

```bash
composer require symfony/console --with-all-dependencies
```

`composer require <package> -W` — Kurzform von --with-all-dependencies.

```bash
composer require laravel/framework -W
```

## Pakete aktualisieren

`composer update` — Aktualisiert alle Abhängigkeiten auf die neuesten Versionen im Rahmen der composer.json-Constraints.

```bash
composer update
```

`composer update <package>` — Aktualisiert ein einzelnes Paket auf seine neueste erlaubte Version.

```bash
composer update guzzlehttp/guzzle
```

`composer update <package1> <package2>` — Aktualisiert mehrere bestimmte Pakete auf einmal.

```bash
composer update symfony/console symfony/http-foundation
```

`composer update --with-all-dependencies` — Aktualisiert zusätzlich die Abhängigkeiten der aktualisierten Pakete.

```bash
composer update --with-all-dependencies
```

`composer update --no-dev` — Aktualisiert nur Produktions-Abhängigkeiten.

```bash
composer update --no-dev
```

`composer update --dry-run` — Zeigt eine Vorschau der Aktualisierungen, ohne tatsächlich etwas zu ändern.

```bash
composer update --dry-run
```

`composer update --prefer-lowest` — Aktualisiert auf die niedrigstmöglichen Versionen im Rahmen der Constraints. Nützlich, um die Kompatibilität zu testen.

```bash
composer update --prefer-lowest
```

## Pakete entfernen

`composer remove <package>` — Entfernt ein Paket aus require und deinstalliert es.

```bash
composer remove guzzlehttp/guzzle
```

`composer remove --dev <package>` — Entfernt ein Paket aus require-dev.

```bash
composer remove --dev phpunit/phpunit
```

`composer remove <package> --no-update` — Entfernt ein Paket aus composer.json, ohne die Lock-Datei zu aktualisieren.

```bash
composer remove monolog/monolog --no-update
```

## Informationen & Suche

`composer show` — Listet alle installierten Pakete mit ihren Versionen auf.

```bash
composer show
```

`composer show <package>` — Zeigt detaillierte Informationen zu einem bestimmten installierten Paket.

```bash
composer show guzzlehttp/guzzle
```

`composer show --tree` — Zeigt die installierten Pakete als Abhängigkeitsbaum.

```bash
composer show --tree
```

`composer show --outdated` — Listet installierte Pakete auf, für die neuere Versionen verfügbar sind.

```bash
composer show --outdated
```

`composer show --direct` — Zeigt nur direkt eingebundene Pakete (keine transitiven Abhängigkeiten).

```bash
composer show --direct
```

`composer search <keyword>` — Sucht auf Packagist anhand eines Stichworts nach Paketen.

```bash
composer search markdown parser
```

`composer depends <package>` — Zeigt, welche Pakete von einem bestimmten Paket abhängen (umgekehrte Abhängigkeitssuche).

```bash
composer depends psr/log
```

`composer why <package>` — Alias für depends. Zeigt, warum ein Paket installiert ist.

```bash
composer why symfony/polyfill-mbstring
```

`composer why-not <package> <version>` — Zeigt, warum ein Paket nicht auf eine bestimmte Version aktualisiert werden kann.

```bash
composer why-not laravel/framework 11.0
```

## Lock-Datei & Autoloader

`composer dump-autoload` — Erzeugt die Autoloader-Dateien neu, ohne Pakete zu installieren oder zu aktualisieren.

```bash
composer dump-autoload
```

`composer dump-autoload --optimize` — Erzeugt einen optimierten Autoloader mit Class-Map für bessere Performance.

```bash
composer dump-autoload --optimize
```

`composer dump-autoload --classmap-authoritative` — Nutzt ausschließlich die Class-Map fürs Autoloading. Am schnellsten, findet aber neue Klassen nicht automatisch.

```bash
composer dump-autoload --classmap-authoritative
```

`composer validate` — Prüft composer.json und composer.lock auf Fehler.

```bash
composer validate
```

`composer validate --strict` — Prüft mit strengen Checks. Liefert auch bei Warnungen einen Exit-Code ungleich null.

```bash
composer validate --strict
```

## Versions-Constraints

`composer require <package>:^<version>` — Caret-Constraint. Erlaubt Updates, die die erste Ziffer ungleich null nicht verändern (empfohlen).

```bash
composer require guzzlehttp/guzzle:^7.5
```

`composer require <package>:~<version>` — Tilde-Constraint. Erlaubt Updates nur an der letzten angegebenen Stelle.

```bash
composer require monolog/monolog:~2.0
```

`composer require <package>:<exact_version>` — Bindet eine exakte Version ein. Keine Updates erlaubt.

```bash
composer require phpunit/phpunit:10.5.3
```

`composer require <package>:">=<min> <<max>"` — Nutzt einen Versionsbereich mit Vergleichsoperatoren.

```bash
composer require monolog/monolog:">=2.0 <3.0"
```

`composer require <package>:*` — Wildcard-Constraint. Erlaubt jede Version (für Produktion nicht empfohlen).

```bash
composer require acme/internal-lib:*
```

`composer require <package>:dev-<branch>` — Bindet einen bestimmten Branch (Entwicklungsversion) eines Pakets ein.

```bash
composer require acme/lib:dev-main
```

## Skripte & Hooks

`composer run-script <script>` — Führt ein im scripts-Abschnitt der composer.json definiertes Skript aus.

```bash
composer run-script test
```

`composer run <script>` — Kurz-Alias für run-script.

```bash
composer run lint
```

`composer run-script --list` — Listet alle in composer.json definierten Skripte auf.

```bash
composer run-script --list
```

`composer exec <binary>` — Führt ein Binary aus dem Verzeichnis vendor/bin aus.

```bash
composer exec phpunit -- --filter=MyTest
```

## Globale Pakete

`composer global require <package>` — Installiert ein Paket global (systemweit verfügbar).

```bash
composer global require laravel/installer
```

`composer global show` — Listet alle global installierten Pakete auf.

```bash
composer global show
```

`composer global update` — Aktualisiert alle global installierten Pakete.

```bash
composer global update
```

`composer global remove <package>` — Entfernt ein global installiertes Paket.

```bash
composer global remove laravel/installer
```

## Cache & Diagnose

`composer clear-cache` — Leert den internen Paket-Cache.

```bash
composer clear-cache
```

`composer diagnose` — Führt Diagnose-Checks für häufige Probleme durch (Verbindung, Berechtigungen usw.).

```bash
composer diagnose
```

`composer self-update` — Aktualisiert Composer selbst auf die neueste Version.

```bash
composer self-update
```

`composer self-update --rollback` — Setzt Composer auf die zuvor installierte Version zurück.

```bash
composer self-update --rollback
```

`composer config --list` — Listet alle aktuellen Konfigurationswerte auf.

```bash
composer config --list
```

`composer config --global home` — Zeigt den Pfad des Composer-Home-Verzeichnisses.

```bash
composer config --global home
```

## Repositories & Plattformen

`composer config repositories.<name> vcs <url>` — Fügt ein VCS-Repository (Git) als Paketquelle hinzu.

```bash
composer config repositories.my-lib vcs https://github.com/acme/my-lib.git
```

`composer config repositories.<name> path <path>` — Fügt ein lokales Pfad-Repository für die Entwicklung hinzu.

```bash
composer config repositories.local-lib path ../my-lib
```

`composer config repositories.<name> '{"type": "composer", "url": "<url>"}'` — Fügt ein privates Composer-Repository hinzu (z. B. Private Packagist, Satis).

```bash
composer config repositories.private '{"type": "composer", "url": "https://packages.example.com"}'
```

`composer config platform.php <version>` — Täuscht die PHP-Version für die Abhängigkeitsauflösung vor (nützlich, um auf ein Deployment-Ziel zu zielen).

```bash
composer config platform.php 8.2.0
```

<!-- PROSE:outro -->
## Fazit

Composer nimmt dir die mühsame Verwaltung von PHP-Abhängigkeiten ab – der Schlüssel zu reproduzierbaren Builds ist dabei die `composer.lock`. Merke dir den Unterschied: `composer update` löst Versionen neu auf und schreibt die Lock-Datei um, während `composer install` exakt die dort festgehaltenen Versionen installiert. In der Produktion solltest du deshalb fast immer nur `install` ausführen und `update` der lokalen Entwicklung überlassen. Für Deployments lohnen sich `--no-dev` und ein optimierter Autoloader (`-o` bzw. `--optimize-autoloader`), damit keine Test-Werkzeuge und kein unnötiger Overhead auf dem Server landen. Behalte im Hinterkopf, dass Composer-Skripte und -Plugins beliebigen Code ausführen – bei fremden Paketen ist `--no-scripts` ein sinnvoller Schutz, und `secure-http` (Standard) sollte aktiviert bleiben, damit Pakete ausschließlich über HTTPS geladen werden.

## Weiterführende Links

- [Composer-Dokumentation](https://getcomposer.org/doc/) – offizielle Anleitung und Befehlsreferenz (englisch)
- [Packagist](https://packagist.org/) – das zentrale Paket-Verzeichnis für PHP (englisch)
- [Versions and constraints](https://getcomposer.org/doc/articles/versions.md) – ausführliche Erklärung der Versions-Constraints (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [artisan](https://www.jpkc.com/db/cheatsheets/build-languages/artisan/) – Kommandozeilen-Tool des Laravel-Frameworks
- [cargo](https://www.jpkc.com/db/cheatsheets/build-languages/cargo/) – Paket- und Build-Manager für Rust
- [drush](https://www.jpkc.com/db/cheatsheets/build-languages/drush/) – Kommandozeilen-Shell für Drupal