Acabei de descobrir que meu script apresenta um erro fatal:

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

Essa linha é esta:

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

Então eu acho que está tendo dificuldade para carregar o arquivo na memória e contar o número de linhas, existe uma maneira mais eficiente de fazer isso sem ter problemas de memória?

Os arquivos de texto de que preciso para contar o número de linhas variam de 2 MB a 500 MB. Talvez um show às vezes.

Obrigado a todos por qualquer ajuda.

Isso usará menos memória, pois não carrega o arquivo inteiro na memória:

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

fclose($handle);

echo $linecount;

fgetscarrega uma única linha na memória (se o segundo argumento $lengthfor omitido, ele continuará lendo o fluxo até chegar ao final da linha, que é o que queremos). É improvável que isso seja tão rápido quanto usar algo diferente do PHP, se você se preocupa com o tempo perdido e também com o uso de memória.

O único perigo com isso é se alguma linha for particularmente longa (e se você encontrar um arquivo de 2 GB sem quebras de linha?). Nesse caso, é melhor engolir em pedaços e contar caracteres de fim de linha:

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

Usar um loop de fgets()chamadas é a solução perfeita e a mais direta de escrever, no entanto:

1. mesmo que internamente o arquivo seja lido usando um buffer de 8.192 bytes, seu código ainda precisa chamar essa função para cada linha.

2. é tecnicamente possível que uma única linha seja maior do que a memória disponível se você estiver lendo um arquivo binário.

Este código lê um arquivo em blocos de 8kB cada e conta o número de novas linhas dentro desse bloco.

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

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

    fclose($f);

    return $lines;
}

Se o comprimento médio de cada linha for no máximo 4kB, você já começará a economizar nas chamadas de função, que podem aumentar ao processar arquivos grandes.

Benchmark

Fiz um teste com um arquivo de 1 GB; aqui estão os resultados:

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

O tempo é medido em segundos em tempo real, veja aqui o que significa real

Solução de objeto orientado simples

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

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

var_dump($file->key());

Atualizar

Outra maneira de fazer isso é com PHP_INT_MAXno SplFileObject::seekmétodo.

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

echo $file->key() + 1; 

Se você estiver executando em um host Linux / Unix, a solução mais fácil seria usar exec()ou semelhante para executar o comando wc -l $path. Apenas certifique-se de limpar $pathprimeiro para ter certeza de que não é algo como "/ caminho / para / arquivo; rm -rf /".

Há uma maneira mais rápida que descobri que não requer o loop por todo o arquivo

apenas em sistemas * nix , pode haver uma maneira semelhante no Windows ...

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

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

Se estiver usando PHP 5.5, você pode usar um gerador . Porém, isso NÃO funcionará em nenhuma versão do PHP anterior à 5.5. De php.net:

"Os geradores fornecem uma maneira fácil de implementar iteradores simples sem a sobrecarga ou complexidade de implementar uma classe que implemente a interface do 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

Esta é uma adição à solução de Wallace de Souza

Ele também pula linhas vazias durante a contagem:

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 você estiver no Linux, pode simplesmente fazer:

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

Você só precisa encontrar o comando certo se estiver usando outro sistema operacional

Saudações

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

Eu queria adicionar um pequeno conserto à função acima ...

em um exemplo específico onde eu tinha um arquivo contendo a palavra 'teste', a função retornou 2 como resultado. então eu precisava adicionar uma verificação se fgets retornou falso ou não :)

diverta-se :)

A contagem do número de linhas pode ser feita pelos seguintes códigos:

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

Você tem várias opções. A primeira é aumentar a memória disponível permitida, o que provavelmente não é a melhor maneira de fazer as coisas, visto que você afirma que o arquivo pode ficar muito grande. A outra maneira é usar fgets para ler o arquivo linha por linha e incrementar um contador, o que não deve causar nenhum problema de memória, já que apenas a linha atual está na memória a qualquer momento.

Há outra resposta que achei que poderia ser uma boa adição a esta lista.

Se você perlinstalou e é capaz de executar coisas do shell em PHP:

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

Isso deve lidar com a maioria das quebras de linha, sejam de arquivos criados pelo Unix ou pelo Windows.

DOIS desvantagens (pelo menos):

1) Não é uma boa ideia ter seu script tão dependente do sistema em que está sendo executado (pode não ser seguro assumir que Perl e wc estão disponíveis)

2) Apenas um pequeno erro ao escapar e você entregou o acesso a um shell em sua máquina.

Como acontece com a maioria das coisas que sei (ou acho que sei) sobre codificação, obtive essas informações de outro lugar:

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

Com base na solução de Dominic Rodger, aqui está o que eu uso (ele usa wc se disponível, caso contrário, retorna para a solução de 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

Eu uso este método para simplesmente contar quantas linhas em um arquivo. Qual é a desvantagem de fazer estes versículos as outras respostas. Estou vendo muitas linhas em oposição à minha solução de duas linhas. Acho que há um motivo pelo qual ninguém faz isso.

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

A solução de plataforma cruzada mais sucinta que armazena apenas uma linha de cada vez.

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

Infelizmente, temos que definir o READ_AHEADsinalizador, caso contrário, iterator_countbloqueia indefinidamente. Caso contrário, isso seria uma linha única.

Para apenas contar as linhas, use:

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