Ho appena scoperto che il mio script mi ​​dà un errore fatale:

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

Quella linea è questa:

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

Quindi penso che stia avendo difficoltà a caricare il file in memeory e contare il numero di righe, c'è un modo più efficiente per farlo senza problemi di memoria?

I file di testo di cui ho bisogno per contare il numero di righe vanno da 2 MB a 500 MB. Forse a volte un concerto.

Grazie a tutti per qualsiasi aiuto.

Ciò utilizzerà meno memoria, poiché non carica l'intero file in memoria:

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

fclose($handle);

echo $linecount;

fgetscarica una singola riga in memoria (se il secondo argomento $lengthviene omesso, continuerà a leggere dal flusso fino a raggiungere la fine della riga, che è quello che vogliamo). È ancora improbabile che sia veloce come usare qualcosa di diverso da PHP, se ti interessa il wall time e l'utilizzo della memoria.

L'unico pericolo con questo è se le righe sono particolarmente lunghe (cosa succede se si incontra un file da 2 GB senza interruzioni di riga?). In tal caso, faresti meglio a mangiarlo in pezzi e contare i caratteri di fine riga:

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

L'uso di un ciclo di fgets()chiamate è una soluzione eccellente e la più semplice da scrivere, tuttavia:

1. anche se internamente il file viene letto utilizzando un buffer di 8192 byte, il codice deve comunque chiamare quella funzione per ogni riga.

2. è tecnicamente possibile che una singola riga possa essere più grande della memoria disponibile se stai leggendo un file binario.

Questo codice legge un file in blocchi di 8 kB ciascuno e quindi conta il numero di nuove righe all'interno di quel blocco.

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

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

    fclose($f);

    return $lines;
}

Se la lunghezza media di ogni riga è al massimo 4kB, inizierai già a risparmiare sulle chiamate di funzione e queste possono sommarsi quando elabori file di grandi dimensioni.

Prova delle prestazioni

Ho eseguito un test con un file da 1 GB; ecco i risultati:

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

Il tempo è misurato in secondi in tempo reale, guarda qui cosa significa reale

Soluzione a oggetti orientati semplice

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

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

var_dump($file->key());

Aggiornare

Un altro modo per fare questo è con PHP_INT_MAXin SplFileObject::seekmetodo.

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

echo $file->key() + 1; 

Se lo stai eseguendo su un host Linux / Unix, la soluzione più semplice sarebbe usare exec()o simile per eseguire il comando wc -l $path. Assicurati solo di aver disinfettato $pathprima per essere sicuro che non sia qualcosa come "/ path / to / file; rm -rf /".

C'è un modo più veloce che ho scoperto che non richiede il ciclo attraverso l'intero file

solo su sistemi * nix , potrebbe esserci un modo simile su Windows ...

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

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

Se stai usando PHP 5.5 puoi usare un generatore . Tuttavia , NON funzionerà in nessuna versione di PHP precedente alla 5.5. Da php.net:

"I generatori forniscono un modo semplice per implementare iteratori semplici senza l'overhead o la complessità dell'implementazione di una classe che implementa l'interfaccia 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

Questa è un'aggiunta a Wallace de Souza's soluzione

Salta anche le righe vuote durante il conteggio:

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

Se sei sotto Linux puoi semplicemente fare:

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

Devi solo trovare il comando giusto se stai usando un altro sistema operativo

Saluti

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

Volevo aggiungere una piccola correzione alla funzione sopra ...

in un esempio specifico in cui avevo un file contenente la parola "test", la funzione ha restituito 2 come risultato. quindi avevo bisogno di aggiungere un controllo se fgets restituiva falso o no :)

divertiti :)

Basato sulla soluzione di Dominic Rodger, ecco cosa uso (usa wc se disponibile, altrimenti fallback alla soluzione di Dominic Rodger).

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

Il conteggio del numero di righe può essere effettuato tramite i seguenti codici:

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

Hai diverse opzioni. Il primo è aumentare la memoria disponibile consentita, che probabilmente non è il modo migliore per fare le cose dato che si afferma che il file può diventare molto grande. L'altro modo è usare fgets per leggere il file riga per riga e incrementare un contatore, il che non dovrebbe causare alcun problema di memoria poiché solo la riga corrente è in memoria in qualsiasi momento.

C'è un'altra risposta che ho pensato potrebbe essere una buona aggiunta a questa lista.

Se hai perlinstallato e sei in grado di eseguire cose dalla shell in PHP:

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

Questo dovrebbe gestire la maggior parte delle interruzioni di riga sia da file Unix che da file creati da Windows.

DUE aspetti negativi (almeno):

1) Non è una buona idea avere lo script così dipendente dal sistema su cui è in esecuzione (potrebbe non essere sicuro presumere che Perl e wc siano disponibili)

2) Solo un piccolo errore durante la fuga e hai consegnato l'accesso a un guscio sulla tua macchina.

Come con la maggior parte delle cose che so (o penso di sapere) sulla programmazione, ho ottenuto queste informazioni da qualche altra parte:

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

Uso questo metodo per contare semplicemente quante righe in un file. Qual è lo svantaggio di fare questo versi le altre risposte. Vedo molte righe rispetto alla mia soluzione a due righe. Immagino che ci sia una ragione per cui nessuno lo fa.

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

La soluzione multipiattaforma più succinta che memorizza solo una riga alla volta.

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

Sfortunatamente, dobbiamo impostare il READ_AHEADflag altrimenti si iterator_countblocca a tempo indeterminato. Altrimenti, questa sarebbe una battuta.

Solo per contare le linee usa:

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