Właśnie się dowiedziałem, że mój skrypt wyświetla fatalny błąd:

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

Ta linia jest taka:

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

Więc myślę, że ma trudności z załadowaniem pliku do pamięci i zliczeniem liczby wierszy, czy jest bardziej wydajny sposób, aby to zrobić bez problemów z pamięcią?

Pliki tekstowe, które potrzebuję, aby policzyć liczbę wierszy, mieszczą się w zakresie od 2 MB do 500 MB. Może czasem koncert.

Dziękuję wszystkim za pomoc.

Spowoduje to użycie mniej pamięci, ponieważ nie załaduje całego pliku do pamięci:

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

fclose($handle);

echo $linecount;

fgetsładuje pojedynczą linię do pamięci (jeśli drugi argument $lengthzostanie pominięty, będzie kontynuował czytanie ze strumienia, aż osiągnie koniec linii, co jest tym, czego chcemy). Jest to nadal mało prawdopodobne, aby było to tak szybkie, jak użycie czegoś innego niż PHP, jeśli zależy Ci na czasie korzystania z ekranu i wykorzystaniu pamięci.

Jedynym niebezpieczeństwem jest to, że jakieś linie są szczególnie długie (a co, jeśli napotkasz plik 2 GB bez przerw w wierszach?). W takim przypadku lepiej jest siorbać to kawałkami i liczyć znaki końca linii:

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

Używanie pętli fgets()wywołań jest dobrym rozwiązaniem i najłatwiejszym do napisania, jednak:

1. mimo że wewnętrznie plik jest odczytywany przy użyciu bufora o wielkości 8192 bajtów, kod nadal musi wywoływać tę funkcję dla każdej linii.

2. jest technicznie możliwe, że pojedyncza linia może być większa niż dostępna pamięć, jeśli czytasz plik binarny.

Ten kod odczytuje plik w fragmentach po 8kB każdy, a następnie zlicza liczbę nowych wierszy w tym fragmencie.

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

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

    fclose($f);

    return $lines;
}

Jeśli średnia długość każdej linii wynosi co najwyżej 4 kB, zaczniesz już oszczędzać na wywołaniach funkcji, a te mogą się sumować podczas przetwarzania dużych plików.

Reper

Przeprowadziłem test z plikiem 1 GB; Oto wyniki:

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

Czas mierzony jest w sekundach w czasie rzeczywistym, zobacz tutaj, co oznacza prawdziwy

Rozwiązanie Simple Oriented Object

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

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

var_dump($file->key());

Aktualizacja

Innym sposobem, aby to się PHP_INT_MAXw SplFileObject::seekmetodzie.

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

echo $file->key() + 1; 

Jeśli uruchamiasz to na hoście Linux / Unix, najłatwiejszym rozwiązaniem byłoby użycie exec()lub podobnego do uruchomienia polecenia wc -l $path. Po prostu upewnij się, że $pathnajpierw zostałeś oczyszczony, aby upewnić się, że nie jest to coś w rodzaju „/ ścieżka / do / pliku; rm -rf /”.

Znalazłem szybszy sposób, który nie wymaga przeglądania całego pliku

tylko na systemach * nix , podobnie może być na Windowsie ...

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

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

Jeśli używasz PHP 5.5, możesz użyć generatora . Będzie to nie działa w każdej wersji PHP przed 5,5 chociaż. Z php.net:

„Generatory zapewniają łatwy sposób implementacji prostych iteratorów bez narzutu i złożoności implementacji klasy, która implementuje interfejs Iteratora”.

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

Jest to dodatek do Wallace de Souza rozwiązania

Pomija również puste wiersze podczas liczenia:

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

Jeśli korzystasz z Linuksa, możesz po prostu zrobić:

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

Musisz tylko znaleźć odpowiednie polecenie, jeśli używasz innego systemu operacyjnego

pozdrowienia

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

Chciałem trochę poprawić powyższą funkcję ...

w konkretnym przykładzie, w którym miałem plik zawierający słowo „testowanie”, funkcja zwróciła jako wynik 2. więc musiałem dodać sprawdzenie, czy fgets zwróciły fałsz, czy nie :)

baw się dobrze :)

Liczenie linii można wykonać za pomocą następujących kodów:

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

Masz kilka opcji. Pierwszym jest zwiększenie dostępnej dostępnej pamięci, co prawdopodobnie nie jest najlepszym sposobem robienia rzeczy, biorąc pod uwagę, że plik może być bardzo duży. Innym sposobem jest użycie fgets do odczytywania pliku wiersz po wierszu i zwiększania licznika, co nie powinno powodować żadnych problemów z pamięcią, ponieważ w danym momencie w pamięci znajduje się tylko bieżąca linia.

Jest jeszcze jedna odpowiedź, która moim zdaniem może być dobrym dodatkiem do tej listy.

Jeśli perlzainstalowałeś i możesz uruchamiać rzeczy z powłoki w PHP:

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

Powinno to obsłużyć większość znaków końca wierszy, czy to z plików utworzonych w systemie Unix, czy w systemie Windows.

DWA wady (przynajmniej):

1) Nie jest dobrym pomysłem uzależnienie twojego skryptu od systemu, na którym działa (założenie, że Perl i wc są dostępne, może nie być bezpieczne)

2) Tylko mały błąd w ucieczce i przekazałeś dostęp do powłoki na swoim komputerze.

Podobnie jak w przypadku większości rzeczy, które wiem (lub myślę, że wiem) na temat kodowania, otrzymałem te informacje z innego miejsca:

Artykuł Johna Reeve'a

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

W oparciu o rozwiązanie Dominica Rodgera, oto czego używam (używa wc, jeśli jest dostępne, w przeciwnym razie jest to rozwiązanie zastępcze do rozwiązania Dominica Rodgera).

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

Używam tej metody do liczenia liczby wierszy w pliku. Jaka jest wada robienia tego w przypadku innych odpowiedzi. Widzę wiele linii w przeciwieństwie do mojego rozwiązania dwuwierszowego. Domyślam się, że jest powód, dla którego nikt tego nie robi.

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

Najbardziej zwięzłe rozwiązanie wieloplatformowe, które buforuje tylko jedną linię naraz.

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

Niestety, musimy ustawić READ_AHEADflagę, w przeciwnym razie iterator_countblokuje się na czas nieokreślony. W przeciwnym razie byłby to jednolinijkowy.

Do liczenia wierszy użyj:

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