La forma más rápida de leer el contenido de un archivo

Question

Ok, estoy buscando la manera más rápida posible de leer todos los contenidos de un archivo vía php con un archivo en el servidor, también estos archivos pueden ser enormes. Entonces, es muy importante que le LEA SOLAMENTE lo más rápido posible.

¿Lo está leyendo línea por línea más rápido que leyendo todo el contenido? Sin embargo, recuerdo haber leído algo sobre esto, que leer todo el contenido puede producir errores para archivos grandes. ¿Es esto cierto?

Answer 1

Si desea cargar el contenido completo de un archivo a una variable de PHP, el más fácil (y, probablemente, más rápido) manera sería file_get_contents.

Pero, si está trabajando con archivos grandes, cargar todo el archivo en la memoria podría no ser una buena idea: probablemente terminará con un error memory_limit, ya que PHP no permitirá que su script use más de (generalmente) un par de mega bytes de memoria.

lo tanto, incluso si no es la solución más rápida, leyendo el archivo línea por línea (fopen + fgets + fclose), y trabajar con esas líneas sobre la marcha, sin tener que cargar todo el archivo en la memoria, podría ser necesario ...

Answer 2

Usted podría utilizar file_get_contents

Ejemplo:

$homepage = file_get_contents('http://www.example.com/'); 
echo $homepage; 

Answer 3

Leer el archivo completo de una vez es más rápido.

Pero los archivos enormes pueden consumir toda su memoria y causar problemas. Entonces su apuesta más segura es leer línea por línea.

Answer 4

$file_handle = fopen("myfile", "r"); 
while (!feof($file_handle)) { 
    $line = fgets($file_handle); 
    echo $line; 
} 
fclose($file_handle); 

1. Abrir el archivo y lo almacena en $file_handle como referencia para el propio archivo.
2. Compruebe si ya se encuentra al final del archivo.
3. Siga leyendo el archivo hasta que esté al final, imprimiendo cada línea a medida que la lee.
4. Cierra el archivo.

Answer 5

file_get_contents() es la forma más optimizada para leer archivos en PHP, sin embargo - ya que estás leyendo los archivos en la memoria que siempre está limitado a la cantidad de memoria disponible.

Puede emitir un ini_set('memory_limit', -1) si tiene los permisos adecuados, pero igual estará limitado por la cantidad de memoria disponible en su sistema, esto es común en todos los lenguajes de programación.

La única solución es leer el archivo en trozos, para que pueda utilizar file_get_contents() con los argumentos cuarto y quinto ($offset y $maxlen - se especifica en bytes):

string file_get_contents(string $filename[, bool $use_include_path = false[, resource $context[, int $offset = -1[, int $maxlen = -1]]]]) 

Aquí está un ejemplo donde utilizo esta técnica para servir archivos de descarga grandes:

public function Download($path, $speed = null) 
{ 
    if (is_file($path) === true) 
    { 
     set_time_limit(0); 

     while (ob_get_level() > 0) 
     { 
      ob_end_clean(); 
     } 

     $size = sprintf('%u', filesize($path)); 
     $speed = (is_int($speed) === true) ? $size : intval($speed) * 1024; 

     header('Expires: 0'); 
     header('Pragma: public'); 
     header('Cache-Control: must-revalidate, post-check=0, pre-check=0'); 
     header('Content-Type: application/octet-stream'); 
     header('Content-Length: ' . $size); 
     header('Content-Disposition: attachment; filename="' . basename($path) . '"'); 
     header('Content-Transfer-Encoding: binary'); 

     for ($i = 0; $i <= $size; $i = $i + $speed) 
     { 
      ph()->HTTP->Flush(file_get_contents($path, false, null, $i, $speed)); 
      ph()->HTTP->Sleep(1); 
     } 

     exit(); 
    } 

    return false; 
} 

Otra opción es el uso de los archivos s optimizado fopen(), feof(), fgets() y fclose() funciones, especialmente si se preocupan por conseguir líneas enteras a la vez, aquí es another example I provided in another StackOverflow question for importing large SQL queries into the database:

function SplitSQL($file, $delimiter = ';') 
{ 
    set_time_limit(0); 

    if (is_file($file) === true) 
    { 
     $file = fopen($file, 'r'); 

     if (is_resource($file) === true) 
     { 
      $query = array(); 

      while (feof($file) === false) 
      { 
       $query[] = fgets($file); 

       if (preg_match('~' . preg_quote($delimiter, '~') . '\s*$~iS', end($query)) === 1) 
       { 
        $query = trim(implode('', $query)); 

        if (mysql_query($query) === false) 
        { 
         echo '<h3>ERROR: ' . $query . '</h3>' . "\n"; 
        } 

        else 
        { 
         echo '<h3>SUCCESS: ' . $query . '</h3>' . "\n"; 
        } 

        while (ob_get_level() > 0) 
        { 
         ob_end_flush(); 
        } 

        flush(); 
       } 

       if (is_string($query) === true) 
       { 
        $query = array(); 
       } 
      } 

      return fclose($file); 
     } 
    } 

    return false; 
} 

la técnica que utilice realmente va a depender de lo que estamos tratando de hacer (como puede ver con la función de importación de SQL y la función de descarga), pero siempre tendrá que leer los datos en los trozos.

Answer 6

Utilice fpassthru o readfile. Ambos usan memoria constante con el aumento del tamaño del archivo.

http://raditha.com/wiki/Readfile_vs_include

Answer 7

Si no está preocupado por la memoria y el tamaño del archivo,

$lines = file($path); 

$ líneas es entonces la matriz del archivo.

Answer 8

Puede probar cURL (http://php.net/manual/en/book.curl.php).

Altho Es posible que desee comprobar, tiene sus límites, así

$ch = curl_init(); 
curl_setopt($ch, CURLOPT_URL, "http://example.com/"); 
curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1); 
$data = curl_exec ($ch); // Whole Page As String 
curl_close ($ch); 

Answer 9

foreach (new SplFileObject($filepath) as $lineNumber => $lineContent) { 

    echo $lineNumber."==>".$lineContent; 
    //process your operations here 
}