> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Collection Deep Dive

> Erläutert die Implementierung der Laravel Collection aus Sicht der Historie, Klassenstruktur, PHPDoc-Generics und einer Anleitung zum Lesen des Quellcodes.

## Ziel dieser Seite

Diese Seite erklärt nicht die Verwendung von `collect()`, sondern liefert eine Karte, mit der Sie den Implementierungs-Code von Laravel selbst lesen können.

Zielgruppe sind Personen, die die Methodenliste von `Collection` bereits kennen und als Nächstes verstehen möchten, „warum es so entworfen ist".

## Historische Entwicklung

Die Struktur der Collection wurde bei der Einführung von `LazyCollection` grundlegend neu geordnet.

### Bis Laravel 5.8

* `Illuminate\Support\Collection`
* `Illuminate\Database\Eloquent\Collection` (erbt von `Collection`)

Zu diesem Zeitpunkt gab es `LazyCollection`, `Enumerable` und `EnumeratesValues` noch nicht.

* [Collection.php in 5.8](https://github.com/laravel/framework/blob/5.8/src/Illuminate/Support/Collection.php)
* [Eloquent Collection.php in 5.8](https://github.com/laravel/framework/blob/5.8/src/Illuminate/Database/Eloquent/Collection.php)

### Änderungen in Laravel 6.0

Passend zum neuen `LazyCollection` wurde die gemeinsame API in das Interface `Enumerable` und den Trait `EnumeratesValues` extrahiert.

* [LazyCollection.php in 6.x](https://github.com/laravel/framework/blob/6.x/src/Illuminate/Support/LazyCollection.php)
* [Enumerable.php in 6.x](https://github.com/laravel/framework/blob/6.x/src/Illuminate/Support/Enumerable.php)
* [EnumeratesValues.php in 6.x](https://github.com/laravel/framework/blob/6.x/src/Illuminate/Support/Traits/EnumeratesValues.php)

## Aktueller Gesamtaufbau (Laravel 13)

> Referenz: [laravel/framework v13.x](https://github.com/laravel/framework/tree/13.x/src/Illuminate)

```mermaid theme={null}
classDiagram
    class Enumerable {
      <<interface>>
    }
    class EnumeratesValues {
      <<trait>>
    }
    class Collection
    class LazyCollection
    class EloquentCollection

    Collection ..|> Enumerable : implements
    LazyCollection ..|> Enumerable : implements
    Collection ..> EnumeratesValues : use
    LazyCollection ..> EnumeratesValues : use
    EloquentCollection --|> Collection : extends

    note for Enumerable "Vertrag der<br>gemeinsamen API"
    note for EnumeratesValues "Implementierungskern<br>der gemeinsamen Methoden"
    note for Collection "In-Memory<br>eager evaluation"
    note for LazyCollection "Generator-basiert<br>lazy evaluation"
    note for EloquentCollection "Erweiterung für<br>Eloquent-Modelle"
```

* [Collection.php](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Collections/Collection.php)
* [LazyCollection.php](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Collections/LazyCollection.php)
* [EnumeratesValues.php](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Collections/Traits/EnumeratesValues.php)
* [Enumerable.php](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Collections/Enumerable.php)
* [Eloquent Collection.php](https://github.com/laravel/framework/blob/13.x/src/Illuminate/Database/Eloquent/Collection.php)

<Info>
  Der tatsächliche Dateipfad lautet inzwischen `src/Illuminate/Collections/*`, aber der Namensraum bleibt weiterhin `Illuminate\\Support`. Beim Lesen des Codes sollten Sie „Pfad" und „Namespace" getrennt betrachten.
</Info>

## PHPDoc und Generics im PHPStan-Stil

PHP selbst kennt keine Generics.
Rund um die Collection werden dennoch mit PHPDoc präzise Typinformationen ausgedrückt.

Die beiden Hauptziele sind:

* die IDE-Vervollständigung genau zu machen
* die Präzision statischer Analyse (PHPStan / Larastan usw.) zu erhöhen

### Häufig genutzte Notationen

```php theme={null}
/**
 * @template TKey of array-key
 * @template-covariant TValue
 * @implements \Illuminate\Support\Enumerable<TKey, TValue>
 */
class Collection implements Enumerable
{
    /**
     * @use \Illuminate\Support\Traits\EnumeratesValues<TKey, TValue>
     */
    use EnumeratesValues;
}
```

| Notation                        | Bedeutung                                                                                    |
| ------------------------------- | -------------------------------------------------------------------------------------------- |
| `@template TKey of array-key`   | Schränkt den Schlüsseltyp auf `int\|string` ein                                              |
| `@template-covariant TValue`    | Behandelt den Werttyp kovariant (leichter sicher durch einen spezifischeren Typ zu ersetzen) |
| `@implements ...<TKey, TValue>` | Übergibt Typargumente an das implementierte Interface                                        |
| `@extends ...<TKey, TModel>`    | Deklariert Typargumente beim Erben von einer Elternklasse                                    |
| `@use ...<TKey, TValue>`        | Deklariert Typargumente bei der Verwendung eines Traits                                      |

### Auftreten in der Eloquent Collection

```php theme={null}
/**
 * @template TKey of array-key
 * @template TModel of \Illuminate\Database\Eloquent\Model
 * @extends \Illuminate\Support\Collection<TKey, TModel>
 */
class Collection extends BaseCollection
{
}
```

Da `TValue` zu `TModel` konkretisiert wird, verbessert sich die Typinferenz von `map()`, `filter()` usw. speziell für Eloquent-Modelle.

## Reihenfolge beim Lesen der Implementierung

### 1. Als Einstieg `Enumerable` lesen

Verstehen Sie zunächst, „was der Vertrag verspricht".
Wenn Sie hier die Methodenliste erfassen, lesen sich die folgenden Implementierungen schneller.

### 2. Die gemeinsamen Methoden in `EnumeratesValues` verfolgen

Der Großteil der gemeinsamen Logik wie `map`, `filter`, `reduce` befindet sich hier.
Wenn Sie später nur die Unterschiede zwischen `Collection` und `LazyCollection` betrachten, überspringen Sie weniger.

### 3. Die Unterschiede zwischen `Collection` und `LazyCollection` betrachten

* `Collection`: hält ein Array und wertet sofort aus
* `LazyCollection`: verwendet einen `Generator` und wertet verzögert aus

Auch bei gleichnamigen Methoden unterscheiden sich Auswertungszeitpunkt und Speicherverhalten.

### 4. Zum Schluss `Eloquent\Collection` lesen

Konzentrieren Sie sich auf die Erweiterungen für Modell-Sammlungen wie `find`, `load` oder `modelKeys`.
Nach dem Verständnis der Basis-`Collection` erkennen Sie die Absicht leichter.

<Tip>
  Wenn Sie eine Methode im Detail nachverfolgen, gehen Sie in der Reihenfolge Deklaration in `Enumerable` → Kern in `EnumeratesValues` → gegebenenfalls Override in `Collection` / `LazyCollection` vor — so verlieren Sie den Faden nicht.
</Tip>

## Verwandte Seiten

* [Collections](/de/collections)
* [Higher-Order Messages in Collections](/de/advanced/higher-order-messages)
* [Macroable-Trait](/de/advanced/macroable)


## Related topics

- [Collections](/de/collections.md)
- [Eloquent-Collections](/de/eloquent-collections.md)
- [Higher-Order Messages in Collections](/de/advanced/higher-order-messages.md)
- [Laravel Bluesky](/de/packages/laravel-bluesky/index.md)
- [Laravel Console Starter](/de/packages/laravel-console-starter/index.md)