Usando un bucle de fgets() calls es una buena solución y la más sencilla de escribir, sin embargo:

1. A pesar de que internamente el archivo se lee utilizando un búfer de 8192 bytes, su código todavía tiene que llamar a esa función para cada línea.

2. Es técnicamente posible que una sola línea sea más grande que la memoria disponible si estás leyendo un archivo binario.

Este código lee un archivo en trozos de 8kB cada uno y luego cuenta el número de nuevas líneas dentro de ese trozo.

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

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

    fclose($f);

    return $lines;
}

Si la longitud media de cada línea es como máximo de 4 Kb, ya comenzará a guardar las llamadas a funciones, y esas pueden acumularse cuando procese archivos grandes.

Punto de referencia

Hice una prueba con un archivo de 1GB; aquí están los resultados:

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

El tiempo se mide en segundos en tiempo real, ver aquí lo que significa real

Solución de Objeto Orientado simple

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

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

var_dump($file->key());

Actualizar

Otra forma de hacer esto es con PHP_INT_MAX en el método SplFileObject::seek.

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

echo $file->key() + 1; 

Si está ejecutando esto en un host Linux/Unix, la solución más fácil sería usar exec() o similar para ejecutar el comando wc -l $path. Solo asegúrese de haber desinfectado $path primero para asegurarse de que no es algo como "/path/to/file ; rm-rf /".

Hay una forma más rápida que encontré que no requiere bucear a través de todo el archivo

Solo en * nix systems , podría haber una forma similar en Windows ...

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

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

Si estás usando PHP 5.5 puedes usar un generador . Esto NO funcionará en ninguna versión de PHP anterior a la 5.5. Desde php.net:

"Los generadores proporcionan una manera fácil de implementar iteradores simples sin la sobrecarga o complejidad de implementar una clase que implementa la interfaz del Iterador."

// 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 es una adición a solución de Wallace de Souza

También salta líneas vacías mientras cuenta:

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

Si estás bajo Linux simplemente puedes hacer:

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

Solo tienes que encontrar el comando correcto si estás usando otro sistema operativo

Saludos

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

Quería añadir una pequeña corrección a la función anterior...

En un ejemplo específico donde tenía un archivo que contenía la palabra 'testing' la función devolvió 2 como resultado. así que necesité agregar una comprobación si fgets devolvió false o no:)

Diviértete:)

Contando el número de líneas se puede hacer mediante los siguientes 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);
?>

Tiene varias opciones. La primera es aumentar la memoria disponible permitida, que probablemente no es la mejor manera de hacer las cosas dado que afirma que el archivo puede ser muy grande. La otra forma es usar fgets para leer el archivo línea por línea e incrementar un contador, lo que no debería causar ningún problema de memoria ya que solo la línea actual está en memoria en un momento dado.

Hay otra respuesta que pensé que podría ser una buena adición a esta lista.

Si tiene perl instalado y es capaz de ejecutar cosas desde el shell en PHP:

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

Esto debería manejar la mayoría de los saltos de línea, ya sea desde archivos creados en Unix o Windows.

DOS desventajas (al menos):

1) No es una gran idea tener su script tan dependiente del sistema en el que se ejecuta (puede que no sea seguro asumir que Perl y wc están disponibles )

2) Solo un pequeño error en escapar y que han entregado el acceso a un shell en su máquina.

Al igual que con la mayoría de las cosas que sé (o creo que sé) sobre codificación, obtuve esta información de otro lugar:

Artículo 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>";
}

Basado en la solución de dominic Rodger, esto es lo que uso (usa wc si está disponible, de lo contrario, recurre a la solución 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

Para simplemente contar las líneas use:

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

Utilizo este método para contar puramente cuántas líneas hay en un archivo. ¿Cuál es la desventaja de hacer este versículo las otras respuestas. Estoy viendo muchas líneas en lugar de mi solución de dos líneas. Supongo que hay una razón por la que nadie hace esto.

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