// MEMORY HOG: Loading entire table
$users = $repository->findAll(); // 1M users = OOM
foreach ($users as $user) {
    process($user);
}
 
// MEMORY HOG: Building large array
$data = [];
foreach ($hugeDataset as $item) {
    $data[] = transform($item); // Array grows unbounded
}
 
// FIXED: Use generator
function processUsers(Repository $repo): Generator {
    foreach ($repo->iterate() as $user) {
        yield transform($user);
    }
}

// MEMORY HOG: Entire file in memory
$lines = file('large-file.txt'); // 1GB file = OOM
foreach ($lines as $line) {
    process($line);
}
 
// FIXED: Generator-based reading
function readLines(string $path): Generator {
    $handle = fopen($path, 'r');
    while (($line = fgets($handle)) !== false) {
        yield $line;
    }
    fclose($handle);
}
 
// MEMORY HOG: Collect then process
function getAllProducts(): array {
    $products = [];
    foreach ($this->fetchBatch() as $batch) {
        $products = array_merge($products, $batch);
    }
    return $products; // Entire dataset
}

// MEMORY HOG: No LIMIT
$logs = $repository->findBy(['level' => 'error']);
// Could be millions of records
 
// MEMORY HOG: Pagination loading all
$page = 1;
$allItems = [];
do {
    $items = $api->fetch($page++);
    $allItems = array_merge($allItems, $items);
} while (!empty($items));
 
// FIXED: Process in batches
$page = 1;
do {
    $items = $api->fetch($page++);
    foreach ($items as $item) {
        yield $item;
    }
} while (!empty($items));

// MEMORY HOG: Deep object graph
$department = $repo->find($id);
$employees = $department->getEmployees(); // Loads all
foreach ($employees as $emp) {
    $projects = $emp->getProjects(); // Loads more
    foreach ($projects as $project) {
        $tasks = $project->getTasks(); // Even more
    }
}
// Entire object graph in memory

// MEMORY HOG: peak memory holds the ENTIRE output at once
$output = '';
foreach ($lines as $line) {
    $output .= $line . "\n"; // `.=` reallocs in place — the cost is peak
                             // memory (O(total length)), NOT a copy per pass
}
 
// NOT a fix for memory: an array of n strings costs MORE than the concatenated
// string (each element carries zval + hashtable overhead). Only use implode()
// when you need the parts anyway.
$parts = [];
foreach ($lines as $line) {
    $parts[] = $line;
}
$output = implode("\n", $parts);
 
// FIXED: stream it out — peak memory becomes O(1) per line
$handle = fopen('output.txt', 'w');
foreach ($lines as $line) {
    fwrite($handle, $line . "\n");
}
fclose($handle);

// MEMORY HOG: Entire image in memory
$image = file_get_contents('large-image.jpg');
$processed = processImage($image);
file_put_contents('output.jpg', $processed);
 
// MEMORY HOG: Multiple image resources
foreach ($images as $path) {
    $img = imagecreatefromjpeg($path);
    $resized = imagescale($img, 100, 100);
    imagejpeg($resized, $outPath);
    // Missing: imagedestroy($img); imagedestroy($resized);
}

// MEMORY LEAK: Cache grows unbounded
class Cache {
    private array $data = [];
 
    public function get(string $key): mixed {
        if (!isset($this->data[$key])) {
            $this->data[$key] = $this->load($key);
            // Never evicted
        }
        return $this->data[$key];
    }
}
 
// MEMORY LEAK: Event listeners accumulate
$dispatcher->addListener('event', function() {
    // New closure each time
});

// MEMORY HOG: Doctrine identity map
foreach ($repository->findAll() as $entity) {
    $entity->process();
    $em->flush(); // Identity map keeps all entities
}
 
// FIXED: Clear periodically
$batchSize = 100;
$i = 0;
foreach ($repository->iterate() as $entity) {
    $entity->process();
    if (++$i % $batchSize === 0) {
        $em->flush();
        $em->clear(); // Free memory
    }
}
$em->flush();

// MEMORY HOG: Large session data
$_SESSION['search_results'] = $hugeArray;
 
// MEMORY HOG: Static cache
class Service {
    private static array $cache = [];
 
    public static function process($item) {
        self::$cache[$item->getId()] = $item;
        // Never cleared
    }
}

# file() usage
Grep: "file\([^)]+\)" --glob "**/*.php"
 
# findAll without iterate
Grep: "->findAll\(\)" --glob "**/*.php"
 
# array_merge in loop
Grep: "foreach.*array_merge" --glob "**/*.php"
 
# String concatenation in loop
Grep: 'foreach.*\.=' --glob "**/*.php"
 
# Static array properties
Grep: "private static array" --glob "**/*.php"

### Memory Issue: [Description]
 
**Severity:** 🔴/🟠/🟡
**Location:** `file.php:line`
**Estimated Memory:** ~500 MB for 100K records
 
**Issue:**
[Description of the memory problem]
 
**Code:**

 
**Fix:**

 
**Memory Reduction:**
Before: ~500 MB peak
After: ~10 MB peak (streaming)