Tôi vừa phát hiện ra rằng tập lệnh của tôi gây ra lỗi nghiêm trọng:

Fatal error: Allowed memory size of 268435456 bytes exhausted (tried to allocate 440 bytes) in C:\process_txt.php on line 109

Dòng đó là:

$lines = count(file($path)) - 1;

Vì vậy, tôi nghĩ rằng nó đang gặp khó khăn khi tải tệp vào memeory và đếm số dòng, có cách nào hiệu quả hơn để tôi có thể làm điều này mà không gặp vấn đề về bộ nhớ không?

Các tệp văn bản mà tôi cần đếm số dòng cho phạm vi từ 2MB đến 500MB. Có thể là một Gig đôi khi.

Cảm ơn tất cả cho bất kỳ sự giúp đỡ.

Điều này sẽ sử dụng ít bộ nhớ hơn, vì nó không tải toàn bộ tệp vào bộ nhớ:

$file="largefile.txt";
$linecount = 0;
$handle = fopen($file, "r");
while(!feof($handle)){
  $line = fgets($handle);
  $linecount++;
}

fclose($handle);

echo $linecount;

fgetstải một dòng đơn vào bộ nhớ (nếu đối số thứ hai $lengthbị bỏ qua, nó sẽ tiếp tục đọc từ luồng cho đến khi nó đến cuối dòng, đó là những gì chúng ta muốn). Điều này vẫn chưa chắc sẽ nhanh bằng việc sử dụng thứ gì đó khác ngoài PHP, nếu bạn quan tâm đến thời gian tường cũng như mức sử dụng bộ nhớ.

Nguy hiểm duy nhất với điều này là nếu bất kỳ dòng nào đặc biệt dài (nếu bạn gặp phải tệp 2GB không có ngắt dòng thì sao?). Trong trường hợp đó, tốt hơn là bạn nên chia nhỏ nó thành nhiều phần và đếm các ký tự cuối dòng:

$file="largefile.txt";
$linecount = 0;
$handle = fopen($file, "r");
while(!feof($handle)){
  $line = fgets($handle, 4096);
  $linecount = $linecount + substr_count($line, PHP_EOL);
}

fclose($handle);

echo $linecount;

fgets()Tuy nhiên, sử dụng một vòng lặp các cuộc gọi là giải pháp tốt và dễ viết nhất:

1. mặc dù bên trong tệp được đọc bằng cách sử dụng bộ đệm 8192 byte, mã của bạn vẫn phải gọi hàm đó cho mỗi dòng.

2. Về mặt kỹ thuật, có thể một dòng đơn có thể lớn hơn bộ nhớ khả dụng nếu bạn đang đọc tệp nhị phân.

Mã này đọc một tệp theo từng đoạn 8kB và sau đó đếm số dòng mới trong đoạn đó.

function getLines($file)
{
    $f = fopen($file, 'rb');
    $lines = 0;

    while (!feof($f)) {
        $lines += substr_count(fread($f, 8192), "\n");
    }

    fclose($f);

    return $lines;
}

Nếu độ dài trung bình của mỗi dòng tối đa là 4kB, bạn sẽ bắt đầu lưu các lệnh gọi hàm và chúng có thể cộng dồn khi bạn xử lý các tệp lớn.

Điểm chuẩn

Tôi đã chạy thử nghiệm với tệp 1GB; đây là kết quả:

             +-------------+------------------+---------+
             | This answer | Dominic's answer | wc -l   |
+------------+-------------+------------------+---------+
| Lines      | 3550388     | 3550389          | 3550388 |
+------------+-------------+------------------+---------+
| Runtime    | 1.055       | 4.297            | 0.587   |
+------------+-------------+------------------+---------+

Thời gian được đo bằng giây thời gian thực, hãy xem ở đây nghĩa là gì

Giải pháp Đối tượng Định hướng Đơn giản

$file = new \SplFileObject('file.extension');

while($file->valid()) $file->fgets();

var_dump($file->key());

Cập nhật

Một cách khác để thực hiện điều này là với PHP_INT_MAXtrong SplFileObject::seekphương pháp.

$file = new \SplFileObject('file.extension', 'r');
$file->seek(PHP_INT_MAX);

echo $file->key() + 1; 

Nếu bạn đang chạy điều này trên máy chủ Linux / Unix, giải pháp dễ nhất là sử dụng exec()hoặc tương tự để chạy lệnh wc -l $path. Chỉ cần đảm bảo rằng bạn đã làm sạch $pathtrước để chắc chắn rằng nó không phải là một cái gì đó giống như "/ path / to / file; rm -rf /".

Có một cách nhanh hơn mà tôi đã tìm thấy mà không yêu cầu lặp lại toàn bộ tệp

chỉ trên hệ thống * nix , có thể có cách tương tự trên windows ...

$file = '/path/to/your.file';

//Get number of lines
$totalLines = intval(exec("wc -l '$file'"));

Nếu bạn đang sử dụng PHP 5.5, bạn có thể sử dụng trình tạo . Điều này sẽ KHÔNG hoạt động trong bất kỳ phiên bản PHP nào trước 5.5. Từ php.net:

"Trình tạo cung cấp một cách dễ dàng để triển khai các trình vòng lặp đơn giản mà không cần chi phí cao hoặc phức tạp khi triển khai một lớp thực hiện giao diện Iterator."

// This function implements a generator to load individual lines of a large file
function getLines($file) {
    $f = fopen($file, 'r');

    // read each line of the file without loading the whole file to memory
    while ($line = fgets($f)) {
        yield $line;
    }
}

// Since generators implement simple iterators, I can quickly count the number
// of lines using the iterator_count() function.
$file = '/path/to/file.txt';
$lineCount = iterator_count(getLines($file)); // the number of lines in the file

Đây là một bổ sung cho giải pháp của Wallace de Souza

Nó cũng bỏ qua các dòng trống trong khi đếm:

function getLines($file)
{
    $file = new \SplFileObject($file, 'r');
    $file->setFlags(SplFileObject::READ_AHEAD | SplFileObject::SKIP_EMPTY | 
SplFileObject::DROP_NEW_LINE);
    $file->seek(PHP_INT_MAX);

    return $file->key() + 1; 
}

Nếu bạn đang sử dụng Linux, bạn có thể chỉ cần làm:

number_of_lines = intval(trim(shell_exec("wc -l ".$file_name." | awk '{print $1}'")));

Bạn chỉ cần tìm đúng lệnh nếu đang sử dụng hệ điều hành khác

Trân trọng

private static function lineCount($file) {
    $linecount = 0;
    $handle = fopen($file, "r");
    while(!feof($handle)){
        if (fgets($handle) !== false) {
                $linecount++;
        }
    }
    fclose($handle);
    return  $linecount;     
}

Tôi muốn thêm một chút sửa chữa cho hàm trên ...

trong một ví dụ cụ thể, nơi tôi có một tệp chứa từ 'testing', kết quả là hàm trả về 2. vì vậy tôi cần phải thêm một kiểm tra xem fgets có trả về false hay không :)

chúc vui vẻ :)

Việc đếm số dòng có thể được thực hiện bằng các mã sau:

<?php
$fp= fopen("myfile.txt", "r");
$count=0;
while($line = fgetss($fp)) // fgetss() is used to get a line from a file ignoring html tags
$count++;
echo "Total number of lines  are ".$count;
fclose($fp);
?>

Bạn có một số lựa chọn. Đầu tiên là tăng bộ nhớ khả dụng cho phép, đây có lẽ không phải là cách tốt nhất để thực hiện những việc mà bạn cho rằng tệp có thể rất lớn. Một cách khác là sử dụng fgets để đọc các dòng tập tin bằng cách dòng và tăng số đếm, mà không nên gây ra bất kỳ vấn đề bộ nhớ tại tất cả như chỉ dòng hiện tại là trong bộ nhớ cùng một lúc.

Có một câu trả lời khác mà tôi nghĩ có thể là một bổ sung tốt cho danh sách này.

Nếu bạn đã perlcài đặt và có thể chạy mọi thứ từ shell trong PHP:

$lines = exec('perl -pe \'s/\r\n|\n|\r/\n/g\' ' . escapeshellarg('largetextfile.txt') . ' | wc -l');

Điều này sẽ xử lý hầu hết các ngắt dòng cho dù từ tệp Unix hay Windows được tạo.

HAI nhược điểm (ít nhất):

1) Không phải là một ý tưởng tuyệt vời nếu tập lệnh của bạn quá phụ thuộc vào hệ thống đang chạy (có thể không an toàn nếu cho rằng có Perl và wc)

2) Chỉ cần một sai sót nhỏ trong việc thoát và bạn đã trao quyền truy cập vào một shell trên máy của mình.

Như với hầu hết những điều tôi biết (hoặc nghĩ rằng tôi biết) về mã hóa, tôi lấy thông tin này từ một nơi khác:

John Reeve Bài báo

public function quickAndDirtyLineCounter()
{
    echo "<table>";
    $folders = ['C:\wamp\www\qa\abcfolder\',
    ];
    foreach ($folders as $folder) {
        $files = scandir($folder);
        foreach ($files as $file) {
            if($file == '.' || $file == '..' || !file_exists($folder.'\\'.$file)){
                continue;
            }
                $handle = fopen($folder.'/'.$file, "r");
                $linecount = 0;
                while(!feof($handle)){
                    if(is_bool($handle)){break;}
                    $line = fgets($handle);
                    $linecount++;
                  }
                fclose($handle);
                echo "<tr><td>" . $folder . "</td><td>" . $file . "</td><td>" . $linecount . "</td></tr>";
            }
        }
        echo "</table>";
}

Dựa trên giải pháp của Rodger dominic, đây là những gì tôi sử dụng (nó sử dụng wc nếu có, nếu không sẽ là dự phòng cho giải pháp của Rodger dominic).

class FileTool
{

    public static function getNbLines($file)
    {
        $linecount = 0;

        $m = exec('which wc');
        if ('' !== $m) {
            $cmd = 'wc -l < "' . str_replace('"', '\\"', $file) . '"';
            $n = exec($cmd);
            return (int)$n + 1;
        }


        $handle = fopen($file, "r");
        while (!feof($handle)) {
            $line = fgets($handle);
            $linecount++;
        }
        fclose($handle);
        return $linecount;
    }
}

https://github.com/lingtalfi/Bat/blob/master/FileTool.php

Tôi sử dụng phương pháp này để đếm hoàn toàn có bao nhiêu dòng trong một tệp. Nhược điểm của việc làm câu này là gì câu kia trả lời. Tôi thấy nhiều dòng trái ngược với giải pháp hai dòng của tôi. Tôi đoán có một lý do không ai làm điều này.

$lines = count(file('your.file'));
echo $lines;

Giải pháp đa nền tảng ngắn gọn nhất chỉ đệm một dòng tại một thời điểm.

$file = new \SplFileObject(__FILE__);
$file->setFlags($file::READ_AHEAD);
$lines = iterator_count($file);

Thật không may, chúng tôi phải đặt READ_AHEADcờ nếu không sẽ iterator_countchặn vô thời hạn. Nếu không, đây sẽ là một lớp lót.

Để chỉ đếm các dòng, hãy sử dụng:

$handle = fopen("file","r");
static $b = 0;
while($a = fgets($handle)) {
    $b++;
}
echo $b;