Laravel

Seni yang Terlupakan: LazyCollection dan Stream Processing di Laravel

Kholil · 23 Apr 2026 · 5 min read · 1 views
Seni yang Terlupakan: LazyCollection dan Stream Processing di Laravel

Temukan kekuatan tersembunyi LazyCollection dan generator di Laravel untuk memproses dataset besar dengan efisiensi memori maksimal.

Pengenalan LazyCollection: Gem yang Sering Diabaikan

Sebagian besar developer Laravel menghabiskan waktu mereka dengan menyempurnakan Eloquent relationships, middleware, dan routing. Namun, ada satu fitur yang sangat powerful namun jarang digunakan: LazyCollection dengan generator. Fitur ini bukan hanya sekadar "nice-to-have", melainkan solusi elegans untuk menangani dataset besar dengan efisiensi memori yang luar biasa.

LazyCollection diperkenalkan di Laravel 5.8 sebagai cara modern untuk memproses data secara lazy (malas), artinya data hanya diproses saat benar-benar dibutuhkan. Ini sangat berbeda dengan koleksi tradisional yang memuat seluruh data ke memori sekaligus.

Apa Bedanya dengan Koleksi Biasa?

Mari kita lihat perbedaan fundamental antara koleksi biasa dan LazyCollection:

// Koleksi Biasa - Memuat SEMUA data ke memori
$users = collect(range(1, 1000000))->map(function($id) {
    return User::find($id);
})->filter(function($user) {
    return $user->is_active;
});

// LazyCollection - Memproses data ON-DEMAND
$users = LazyCollection::make(function() {
    foreach(range(1, 1000000) as $id) {
        yield User::find($id);
    }
})->filter(function($user) {
    return $user->is_active;
});

Perbedaan di atas menunjukkan sesuatu yang kritis: koleksi biasa akan mencoba memuat 1 juta record ke memori, sementara LazyCollection hanya memproses record saat diiterasi. Bayangkan perbedaan ini dalam aplikasi production dengan jutaan pengguna!

Generator: Jantung dari LazyCollection

Untuk memahami LazyCollection sepenuhnya, kita harus memahami PHP generators. Generator adalah fungsi yang dapat di-pause dan di-resume, menghasilkan nilai satu per satu menggunakan yield.

// Generator sederhana
function getUserGenerator() {
    for ($i = 1; $i <= 5; $i++) {
        yield User::find($i);
    }
}

// Menggunakan generator
foreach(getUserGenerator() as $user) {
    echo $user->name;
}

Generator tidak menyimpan semua nilai di memori. Setiap kali yield dijalankan, nilai dikirim keluar, dan eksekusi fungsi di-pause. Ini menghasilkan efisiensi memori yang sangat baik untuk dataset besar.

Implementasi Praktis LazyCollection

Mari kita lihat use case nyata yang akan mengubah cara Anda memproses data di Laravel:

1. Memproses File CSV Besar

LazyCollection::make(function() {
    $file = fopen('users.csv', 'r');
    while ($row = fgetcsv($file)) {
        yield [
            'name' => $row[0],
            'email' => $row[1],
            'phone' => $row[2]
        ];
    }
    fclose($file);
})
->chunk(100)
->each(function($chunk) {
    User::insert($chunk);
});

Dalam contoh di atas, kita memproses file CSV besar tanpa pernah memuat seluruh file ke memori. Data diproses dalam chunk 100 baris, yang jauh lebih efisien dibanding memuat seluruh file.

2. Query Database dengan Memory Efficiency

// Tanpa LazyCollection - Memory hog
$users = User::all(); // Memuat semua user!
$activeUsers = $users->filter(fn($u) => $u->is_active);

// Dengan LazyCollection - Memory efficient
$activeUsers = User::cursor()
    ->filter(fn($u) => $u->is_active)
    ->map(fn($u) => [
        'id' => $u->id,
        'name' => $u->name,
        'email' => $u->email
    ]);

Method cursor() dari Eloquent mengembalikan LazyCollection, memungkinkan iterasi melalui dataset besar dengan footprint memori yang minimal.

3. Stream Processing Real-Time

// Memproses log files secara real-time
LazyCollection::make(function() {
    $file = fopen('app.log', 'r');
    while ($line = fgets($file)) {
        yield json_decode($line, true);
    }
    fclose($file);
})
->filter(fn($log) => $log['level'] === 'ERROR')
->map(fn($log) => [
    'timestamp' => $log['timestamp'],
    'message' => $log['message']
])
->each(function($error) {
    Log::error('Critical Error Found', $error);
});

Advanced Techniques dan Best Practices

Chaining Multiple Operations

$result = User::cursor()
    ->filter(fn($u) => $u->created_at->isAfter(now()->subMonth()))
    ->map(fn($u) => [
        'name' => $u->name,
        'posts_count' => $u->posts()->count()
    ])
    ->filter(fn($u) => $u['posts_count'] > 5)
    ->take(100)
    ->all();

Operasi-operasi ini di-chain dengan sempurna, namun tetap memory-efficient karena LazyCollection tidak mengevaluasi sesuatu hingga diperlukan (lazy evaluation).

Membuat Custom LazyCollection Generator

class UserImporter {
    public function generate() {
        return LazyCollection::make(function() {
            foreach($this->fetchUsersFromAPI() as $userData) {
                yield new User($userData);
            }
        });
    }
    
    private function fetchUsersFromAPI() {
        // Pagination logic yang yields data
        $page = 1;
        while (true) {
            $response = Http::get('api/users', ['page' => $page]);
            if ($response->json()['data'] === []) break;
            yield from $response->json()['data'];
            $page++;
        }
    }
}

// Penggunaan
$importer = new UserImporter();
$importer->generate()
    ->filter(fn($u) => $u->is_verified)
    ->each(fn($u) => $u->save());

Performance Comparison yang Nyata

Mari kita lihat benchmark sederhana untuk memahami dampak yang sebenarnya:

// Skenario: Memproses 100,000 records

// METHOD 1: Koleksi Biasa
microtime(true);
$start = memory_get_usage();
User::all() // Load 100k records
    ->filter(fn($u) => $u->is_active)
    ->map(fn($u) => $u->name)
    ->take(100)
    ->all();
$end = memory_get_usage();
echo "Memory used: " . ($end - $start) / 1024 / 1024 . "MB"; // ±150MB

// METHOD 2: LazyCollection
microtime(true);
$start = memory_get_usage();
User::cursor()
    ->filter(fn($u) => $u->is_active)
    ->map(fn($u) => $u->name)
    ->take(100)
    ->all();
$end = memory_get_usage();
echo "Memory used: " . ($end - $start) / 1024 / 1024 . "MB"; // ±2-3MB

Perbedaan 150MB vs 3MB bukan sekadar angka—ini adalah perbedaan antara aplikasi yang responsif dan aplikasi yang crash di production!

Kapan Menggunakan LazyCollection?

  • Dataset besar (ribuan atau lebih records)
  • Memory constraints yang ketat (VPS atau shared hosting)
  • Batch processing atau bulk imports
  • Real-time data streaming
  • API pagination yang perlu diiterasi sepenuhnya
  • Processing file besar (CSV, JSON, logs)

Gotchas dan Hal yang Perlu Diperhatikan

LazyCollection powerful, namun ada beberapa hal yang perlu Anda pahami:

$lazy = User::cursor()->filter(fn($u) => $u->is_active);

// ❌ Tidak efisien - Query dijalankan multiple times
echo $lazy->count();
echo $lazy->first();

// ✅ Lebih baik - Konversi ke array jika perlu multiple operations
$users = User::cursor()->filter(fn($u) => $u->is_active)->all();
echo count($users);
echo $users[0];

Kesimpulan

LazyCollection dengan generator adalah alat yang sangat powerful namun sering terlupakan di ekosistem Laravel. Tidak peduli betapa canggihnya middleware atau relationship Anda, jika aplikasi kehabisan memori saat memproses dataset besar, semuanya tidak berguna.

Dengan memahami dan menerapkan LazyCollection dengan baik, Anda tidak hanya membuat aplikasi yang lebih efisien—Anda menunjukkan pemahaman mendalam tentang bagaimana data processing bekerja di PHP modern. Mulai hari ini, lihat apakah ada operasi koleksi di codebase Anda yang bisa dioptimalkan dengan LazyCollection, dan saksikan perbedaannya di production.

Tags: Laravel Performance Database PHP Memory Management LazyCollection Generator Stream Processing