Ich habe gerade herausgefunden, dass mein Skript einen schwerwiegenden Fehler verursacht:

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

Diese Zeile lautet:

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

Ich denke, es ist schwierig, die Datei in den Speicher zu laden und die Anzahl der Zeilen zu zählen. Gibt es eine effizientere Möglichkeit, dies ohne Speicherprobleme zu tun?

Die Textdateien, für die ich die Anzahl der Zeilen zählen muss, reichen von 2 MB bis 500 MB. Vielleicht manchmal ein Gig.

Vielen Dank für jede Hilfe.

Dies verbraucht weniger Speicher, da nicht die gesamte Datei in den Speicher geladen wird:

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

fclose($handle);

echo $linecount;

fgetsLädt eine einzelne Zeile in den Speicher (wenn das zweite Argument $lengthweggelassen wird, liest es weiter aus dem Stream, bis es das Ende der Zeile erreicht, was wir wollen). Es ist immer noch unwahrscheinlich, dass dies so schnell geht wie die Verwendung von etwas anderem als PHP, wenn Sie sowohl die Wandzeit als auch die Speichernutzung berücksichtigen.

Die einzige Gefahr besteht darin, dass Zeilen besonders lang sind (was ist, wenn Sie auf eine 2-GB-Datei ohne Zeilenumbrüche stoßen?). In diesem Fall ist es besser, wenn Sie es in Stücken schlürfen und die Zeilenendezeichen zählen:

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

Die Verwendung einer Anrufschleife fgets()ist eine gute Lösung und am einfachsten zu schreiben:

1. Obwohl die Datei intern mit einem Puffer von 8192 Bytes gelesen wird, muss Ihr Code diese Funktion für jede Zeile aufrufen.

2. Es ist technisch möglich, dass eine einzelne Zeile größer ist als der verfügbare Speicher, wenn Sie eine Binärdatei lesen.

Dieser Code liest eine Datei in Blöcken von jeweils 8 KB und zählt dann die Anzahl der Zeilenumbrüche in diesem Block.

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

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

    fclose($f);

    return $lines;
}

Wenn die durchschnittliche Länge jeder Zeile höchstens 4 KB beträgt, sparen Sie bereits bei Funktionsaufrufen. Diese können sich bei der Verarbeitung großer Dateien summieren.

Benchmark

Ich habe einen Test mit einer 1-GB-Datei durchgeführt. Hier sind die Ergebnisse:

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

Die Zeit wird in Sekunden in Echtzeit gemessen. Sehen Sie hier, was Real bedeutet

Einfache orientierte Objektlösung

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

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

var_dump($file->key());

Aktualisieren

Ein anderer Weg , dies zu machen , ist mit PHP_INT_MAXin - SplFileObject::seekVerfahren.

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

echo $file->key() + 1; 

Wenn Sie dies auf einem Linux / Unix-Host exec()ausführen , ist es am einfachsten , den Befehl zu verwenden oder ähnlich wc -l $path. Stellen Sie $patheinfach sicher, dass Sie zuerst bereinigt haben , um sicherzustellen, dass es sich nicht um "/ path / to / file; rm -rf /" handelt.

Ich habe einen schnelleren Weg gefunden, bei dem nicht die gesamte Datei durchlaufen werden muss

Nur auf * nix-Systemen kann es unter Windows einen ähnlichen Weg geben ...

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

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

Wenn Sie PHP 5.5 verwenden, können Sie einen Generator verwenden . Dies wird nicht in jeder Version von PHP arbeiten , bevor 5.5 though. Von php.net:

"Generatoren bieten eine einfache Möglichkeit, einfache Iteratoren zu implementieren, ohne den Aufwand oder die Komplexität der Implementierung einer Klasse, die die Iterator-Schnittstelle implementiert."

// 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

Dies ist eine Ergänzung zu Wallace de Souzas Lösung

Außerdem werden beim Zählen leere Zeilen übersprungen:

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

Wenn Sie unter Linux sind, können Sie einfach Folgendes tun:

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

Sie müssen nur den richtigen Befehl finden, wenn Sie ein anderes Betriebssystem verwenden

Grüße

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

Ich wollte der obigen Funktion eine kleine Korrektur hinzufügen ...

In einem speziellen Beispiel, in dem ich eine Datei hatte, die das Wort 'Testen' enthielt, gab die Funktion als Ergebnis 2 zurück. Also musste ich eine Überprüfung hinzufügen, ob Fgets falsch zurückgegeben wurden oder nicht :)

habe Spaß :)

Das Zählen der Anzahl der Zeilen kann mit folgenden Codes erfolgen:

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

Sie haben mehrere Möglichkeiten. Die erste besteht darin, den verfügbaren verfügbaren Speicher zu erhöhen. Dies ist wahrscheinlich nicht der beste Weg, um Dinge zu tun, da Sie angeben, dass die Datei sehr groß werden kann. Die andere Möglichkeit besteht darin, fgets zu verwenden, um die Datei Zeile für Zeile zu lesen und einen Zähler zu erhöhen , was überhaupt keine Speicherprobleme verursachen sollte, da sich jeweils nur die aktuelle Zeile im Speicher befindet.

Es gibt noch eine andere Antwort, von der ich dachte, dass sie eine gute Ergänzung zu dieser Liste sein könnte.

Wenn Sie perlin PHP Dinge von der Shell installiert haben und ausführen können:

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

Dies sollte die meisten Zeilenumbrüche behandeln, unabhängig davon, ob es sich um von Unix oder Windows erstellte Dateien handelt.

ZWEI Nachteile (mindestens):

1) Es ist keine gute Idee, Ihr Skript so abhängig von dem System zu machen, auf dem es ausgeführt wird (es ist möglicherweise nicht sicher anzunehmen, dass Perl und wc verfügbar sind).

2) Nur ein kleiner Fehler beim Entkommen und Sie haben den Zugriff auf eine Shell auf Ihrer Maschine übergeben.

Wie bei den meisten Dingen, die ich über Codierung weiß (oder zu wissen glaube), habe ich diese Informationen von einem anderen Ort erhalten:

John Reeve Artikel

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

Basierend auf der Lösung von Dominic Rodger verwende ich Folgendes (es verwendet wc, falls verfügbar, andernfalls greift es auf die Lösung von Dominic Rodger zurück).

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

Ich benutze diese Methode, um nur zu zählen, wie viele Zeilen in einer Datei enthalten sind. Was ist der Nachteil dieses Verses gegenüber den anderen Antworten? Ich sehe viele Zeilen im Gegensatz zu meiner zweizeiligen Lösung. Ich vermute, es gibt einen Grund, warum niemand dies tut.

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

Die prägnanteste plattformübergreifende Lösung, die jeweils nur eine Zeile puffert.

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

Leider müssen wir das READ_AHEADFlag setzen, sonst iterator_countblockiert es auf unbestimmte Zeit. Andernfalls wäre dies ein Einzeiler.

Um nur die Zeilen zu zählen, verwenden Sie:

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