ฉันเพิ่งพบว่าสคริปต์ของฉันทำให้ฉันมีข้อผิดพลาดร้ายแรง:

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

บรรทัดนั้นคือ:

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

ฉันคิดว่ามันมีปัญหาในการโหลดไฟล์ลงใน memeory และการนับจำนวนบรรทัดมีวิธีที่มีประสิทธิภาพมากกว่านี้ไหมที่ฉันสามารถทำได้โดยไม่ต้องมีปัญหาเรื่องหน่วยความจำ

ไฟล์ข้อความที่ฉันต้องนับจำนวนบรรทัดสำหรับช่วงตั้งแต่ 2MB ถึง 500MB บางทีกิ๊ก

ขอบคุณสำหรับความช่วยเหลือใด ๆ

สิ่งนี้จะใช้หน่วยความจำน้อยลงเนื่องจากไม่ได้โหลดทั้งไฟล์ลงในหน่วยความจำ:

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

fclose($handle);

echo $linecount;

fgetsโหลดบรรทัดเดียวลงในหน่วยความจำ (ถ้าอาร์กิวเมนต์ที่สอง$lengthถูกละไว้มันจะอ่านต่อจากสตรีมจนกว่าจะถึงจุดสิ้นสุดของบรรทัดซึ่งเป็นสิ่งที่เราต้องการ) การดำเนินการนี้ยังไม่น่าจะรวดเร็วเท่ากับการใช้งานอย่างอื่นนอกเหนือจาก PHP หากคุณสนใจเรื่องเวลาติดผนังและการใช้หน่วยความจำ

อันตรายเพียงอย่างเดียวคือหากบรรทัดใด ๆ ยาวเป็นพิเศษ (จะเกิดอะไรขึ้นถ้าคุณพบไฟล์ 2GB โดยไม่มีการแบ่งบรรทัด?) ในกรณีนี้คุณจะดีกว่าในการทำ slurping เป็นชิ้น ๆ และการนับอักขระท้ายบรรทัด:

$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()โทรแบบวนซ้ำเป็นวิธีแก้ปัญหาที่ดีและตรงไปตรงมาที่สุดในการเขียนอย่างไรก็ตาม:

1. แม้ว่าภายในไฟล์จะถูกอ่านโดยใช้บัฟเฟอร์ 8192 ไบต์ แต่โค้ดของคุณยังคงต้องเรียกใช้ฟังก์ชันนั้นสำหรับแต่ละบรรทัด

2. ในทางเทคนิคเป็นไปได้ว่าบรรทัดเดียวอาจใหญ่กว่าหน่วยความจำที่มีอยู่หากคุณกำลังอ่านไฟล์ไบนารี

รหัสนี้อ่านไฟล์เป็นชิ้นละ 8kB จากนั้นนับจำนวนขึ้นบรรทัดใหม่ภายในกลุ่มนั้น

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

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

    fclose($f);

    return $lines;
}

หากความยาวเฉลี่ยของแต่ละบรรทัดไม่เกิน 4kB คุณจะเริ่มบันทึกการเรียกใช้ฟังก์ชันแล้วและสิ่งเหล่านี้สามารถรวมกันได้เมื่อคุณประมวลผลไฟล์ขนาดใหญ่

เกณฑ์มาตรฐาน

ฉันทำการทดสอบด้วยไฟล์ 1GB นี่คือผลลัพธ์:

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

เวลาวัดเป็นวินาทีแบบเรียลไทม์ดูความหมายที่แท้จริงที่นี่

โซลูชันเชิงวัตถุอย่างง่าย

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

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

var_dump($file->key());

อัปเดต

วิธีที่จะทำให้นี้ก็คือด้วยPHP_INT_MAXในSplFileObject::seekวิธีการ

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

echo $file->key() + 1; 

หากคุณกำลังเรียกใช้สิ่งนี้บนโฮสต์ Linux / Unix วิธีแก้ปัญหาที่ง่ายที่สุดคือใช้exec()หรือคล้ายกับการรันคำสั่งwc -l $pathหรือคล้ายกันที่จะเรียกใช้คำสั่งเพียงตรวจสอบให้แน่ใจว่าคุณได้รับการฆ่าเชื้อ$pathก่อนเพื่อให้แน่ใจว่าไม่ใช่ "/ path / to / file; rm -rf /"

มีวิธีที่เร็วกว่าที่ฉันพบโดยไม่ต้องวนซ้ำทั้งไฟล์

เฉพาะในระบบ * nixอาจมีวิธีที่คล้ายกันบน windows ...

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

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

หากคุณกำลังใช้ PHP 5.5 คุณสามารถใช้เครื่องกำเนิดไฟฟ้า สิ่งนี้จะใช้ไม่ได้กับ PHP เวอร์ชันใด ๆ ก่อนหน้า 5.5 จาก php.net:

"Generators ให้วิธีง่ายๆในการใช้งานตัววนซ้ำแบบง่ายโดยไม่ต้องใช้ค่าใช้จ่ายหรือความซับซ้อนในการใช้คลาสที่ใช้อินเทอร์เฟซ 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

นี่เป็นส่วนเพิ่มเติมของโซลูชันของ Wallace de Souza

นอกจากนี้ยังข้ามบรรทัดว่างในขณะที่นับ:

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; 
}

หากคุณใช้ linux คุณสามารถทำได้:

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

คุณต้องหาคำสั่งที่ถูกต้องหากคุณใช้ระบบปฏิบัติการอื่น

ความนับถือ

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

ฉันต้องการเพิ่มการแก้ไขเล็กน้อยในฟังก์ชั่นด้านบน ...

ในตัวอย่างเฉพาะที่ฉันมีไฟล์ที่มีคำว่า 'การทดสอบ' ฟังก์ชันจะส่งคืน 2 เป็นผลลัพธ์ ดังนั้นฉันต้องเพิ่มการตรวจสอบว่า fgets ส่งคืนเป็นเท็จหรือไม่ :)

มีความสุข :)

จากการแก้ปัญหาของโดมินิกร็อดเจอร์นี่คือสิ่งที่ฉันใช้ (ใช้ wc ถ้ามีมิฉะนั้นจะเป็นทางเลือกในการแก้ปัญหาของโดมินิกร็อดเจอร์)

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

การนับจำนวนบรรทัดสามารถทำได้โดยใช้รหัสต่อไปนี้:

<?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);
?>

คุณมีหลายทางเลือก ประการแรกคือการเพิ่มหน่วยความจำที่อนุญาตซึ่งอาจไม่ใช่วิธีที่ดีที่สุดในการทำสิ่งต่างๆเนื่องจากคุณระบุว่าไฟล์จะมีขนาดใหญ่มาก อีกวิธีหนึ่งคือใช้fgetsเพื่ออ่านไฟล์ทีละบรรทัดและเพิ่มตัวนับซึ่งไม่ควรทำให้เกิดปัญหาหน่วยความจำใด ๆ เลยเนื่องจากมีเพียงบรรทัดปัจจุบันเท่านั้นที่อยู่ในหน่วยความจำในครั้งเดียว

มีคำตอบอื่นที่ฉันคิดว่าอาจเป็นส่วนเสริมที่ดีในรายการนี้

หากคุณperlติดตั้งและสามารถเรียกใช้สิ่งต่างๆจากเชลล์ใน PHP:

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

สิ่งนี้ควรจัดการกับการแบ่งบรรทัดส่วนใหญ่ไม่ว่าจะเป็นไฟล์ที่สร้างจาก Unix หรือ Windows

ข้อเสียสองประการ (อย่างน้อย):

1) ไม่ใช่ความคิดที่ดีที่จะให้สคริปต์ของคุณขึ้นอยู่กับระบบที่ทำงานอยู่ (อาจไม่ปลอดภัยที่จะถือว่า Perl และ wc พร้อมใช้งาน)

2) ความผิดพลาดเพียงเล็กน้อยในการหลบหนีและคุณได้ส่งมอบการเข้าถึงเชลล์บนเครื่องของคุณ

เช่นเดียวกับสิ่งต่างๆส่วนใหญ่ที่ฉันรู้ (หรือคิดว่าฉันรู้) เกี่ยวกับการเข้ารหัสฉันได้รับข้อมูลนี้จากที่อื่น:

บทความของ John Reeve

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>";
}

ฉันใช้วิธีนี้เพื่อนับจำนวนบรรทัดในไฟล์เท่านั้น ข้อเสียของการทำข้อนี้คืออะไรกับคำตอบอื่น ๆ ฉันเห็นหลายบรรทัดตรงข้ามกับโซลูชันสองบรรทัดของฉัน ฉันเดาว่ามีเหตุผลที่ไม่มีใครทำแบบนี้

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

โซลูชันข้ามแพลตฟอร์มที่รวบรัดที่สุดที่บัฟเฟอร์ทีละบรรทัดเท่านั้น

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

น่าเสียดายที่เราต้องตั้งค่าREAD_AHEADสถานะมิฉะนั้นจะiterator_countบล็อกโดยไม่มีกำหนด มิฉะนั้นนี่จะเป็นซับเดียว

สำหรับการนับเส้นให้ใช้:

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