How To Read A Large File Line By Line in PHP?

Using the fgets() Function

The fgets() function in PHP reads files line by line. This function reads a single line from a file pointer, making it useful for processing large files without loading the entire content into memory.

Benefits of using fgets() for large files:

• Low memory usage: Only one line is stored in memory at a time.
• Fast processing: You can handle each line as it's read.
• Works with large files: It can process files of any size, even those larger than available memory.

How to Implement

Here's how to read files line by line using fgets():

1. Open the file with fopen(): Use fopen() to create a file handle. Specify the file path and open it in read mode ('r').

   $handle = fopen("largefile.txt", "r");

2. Set up a loop to read lines: Use a while loop to read lines until the end of the file.

   while (($line = fgets($handle)) !== false) {
      // Process each line here
   }

3. Process each line: Inside the loop, perform operations on the current line.

   while (($line = fgets($handle)) !== false) {
      // Example: Print each line
      echo $line;
   }

4. Close the file handle: After processing all lines, close the file handle to free up resources.

   fclose($handle);

This method helps you process large files without memory issues. It's useful for tasks like parsing log files, processing CSV data, or handling large text files line by line.

$handle = fopen("largefile.txt", "r");
if ($handle === false) {
    die("Unable to open the file.");
}
// Continue with file processing

Using file() Function with FILE_IGNORE_NEW_LINES Flag

The file() function in PHP reads a file into an array. When used with the FILE_IGNORE_NEW_LINES flag, it removes newline characters at the end of each line.

$lines = file('largefile.txt', FILE_IGNORE_NEW_LINES);

Advantages:

• Easy to use
• Returns an array of lines for processing

Potential drawbacks:

• Loads the entire file into memory, which may not work for very large files
• Can cause memory issues with large files

$lines = file('largefile.txt', FILE_IGNORE_NEW_LINES);
$chunks = array_chunk($lines, 1000);

foreach ($chunks as $chunk) {
    foreach ($chunk as $line) {
        // Process each line
    }
    // Clear memory after processing each chunk
    unset($chunk);
}

Using SplFileObject for File Handling

SplFileObject is a PHP class that provides an object-oriented interface for file handling. It offers methods for reading, writing, and seeking within files.

$file = new SplFileObject('largefile.txt', 'r');
while (!$file->eof()) {
    $line = $file->fgets();
    // Process the line
}

Benefits for reading large files:

• Provides methods like fgets(), fgetcsv(), and seek() for file handling
• Allows iteration over file lines using foreach loops
• Supports reading files in chunks, useful for large file processing
• Offers error handling and file locking mechanisms

SplFileObject is useful when you need more control over file operations or when working with structured file formats like CSV.

$file = new SplFileObject('data.csv', 'r');
$file->setFlags(SplFileObject::READ_CSV);

foreach ($file as $row) {
    if ($row !== [null]) {
        // Process each CSV row
        print_r($row);
    }
}