Come risparmiare memoria durante la lettura di un file in Php?

Question

Ho un file 200kb, quello che uso in più pagine, ma su ogni pagina ho bisogno solo di 1-2 righe di quel file, quindi come posso leggere solo queste righe di cosa ho bisogno se conosco il numero di riga?

Ad esempio se ho bisogno solo della decima riga, non voglio caricare in memoria tutte le linee, solo la decima riga.

Ci scusiamo per il mio pessimo inglese!

Answer 1

A meno che non si conosca l'offset della linea, sarà necessario leggere ogni riga fino a quel punto. Puoi semplicemente buttare via le vecchie linee (che non vuoi) scorrendo il file con qualcosa come fgets(). (EDIT: Piuttosto che fgets(), vorrei suggerire @Gordon s' solution)

Forse una soluzione migliore potrebbe essere quella di utilizzare un database, come il motore di database farà il lavoro sporco di memorizzare le stringhe e consentono di (molto efficiente) ottieni una certa "linea" (non sarebbe una riga ma un record con un ID numerico, comunque equivale alla stessa cosa) senza dover leggere i record prima di esso.

Answer 2

Passare semplicemente attraverso di essi senza memorizzare, ad es.

$i = 1; 
$file = fopen('file.txt', 'r'); 
while (!feof($file)) { 
    $line = fgets($file); // this gets whole line from the file; 
    if ($i == 10) { 
     break; // break on tenth line 
    } 
    $i ++; 
} 

L'esempio riportato sopra dovrebbe tenere memoria solo l'ultima riga ha ottenuto dal file, quindi questo è il modo più efficiente della memoria per farlo.

Answer 3

utilizzare fgets(). 10 volte :-) in questo caso non memorizzare tutte le 10 righe nella memoria

Answer 4

<?php 
    $lines = array(1, 2, 10); 

    $handle = @fopen("/tmp/inputfile.txt", "r"); 
    if ($handle) { 
     $i = 0; 
     while (!feof($handle)) { 
      $line = stream_get_line($handle, 1000000, "\n"); 

      if (in_array($i, $lines)) { 
       echo $line; 
          $line = ''; // Don't forget to clean the buffer! 
      } 

      if ($i > end($lines)) { 
       break; 
      } 

      $i++; 
     } 
     fclose($handle); 
    } 
?> 

Answer 5

Prova SplFileObject

echo memory_get_usage(), PHP_EOL;  // 333200 

$file = new SplFileObject('bible.txt'); // 996kb 
$file->seek(5000);      // jump to line 5000 (zero-based) 
echo $file->current(), PHP_EOL;   // output current line 

echo memory_get_usage(), PHP_EOL;  // 342984 vs 3319864 when using file() 

per emettere la riga corrente, è possibile utilizzare current() o semplicemente echo $file. Trovo più chiaro usare il metodo però. Puoi anche usare fgets(), ma quello otterrebbe la riga successiva.

Naturalmente, sono necessarie solo le tre linee centrali. Ho aggiunto le chiamate memory_get_usage solo per dimostrare che questo approccio non ha quasi memoria.

Answer 6

Perché stai provando solo a caricare le prime dieci righe? Sai che caricare tutte quelle righe è di fatto un problema?

Se non hai misurato, non sai che è un problema. Non sprecare il tuo tempo per ottimizzare i non problemi. È probabile che qualsiasi modifica delle prestazioni che avrai nel non caricare l'intero file 200K sarà impercettibile, a meno che tu non sappia che il caricamento di quel file è davvero un collo di bottiglia.

Answer 7

Il contenuto del file cambia? Se è statico o relativamente statico, è possibile creare un elenco di offset in cui si desidera leggere i dati. Per esempio, se i cambiamenti dei file una volta all'anno, ma si leggono centinaia di volte al giorno, quindi è possibile pre-calcolare gli offset delle linee che si desidera e saltare direttamente in questo modo:

$offsets = array(); 
while ($line = fread($filehandle)) { .... find line 10 .... } 
$offsets[10] = ftell($filehandle); // store line 10's location 
.... find next line 
$offsets[20] = ftell($filehandle); 

e presto. Successivamente, è possibile saltare banalmente alla posizione di quella linea in questo modo:

$fh = fopen('file.txt', 'rb'); 
fseek($fh, $offsets[20]); // jump to line 20 

Ma questo potrebbe essere completamente eccessivo.Prova il benchmarking delle operazioni: confronta il tempo necessario per eseguire una "lettura di 20 righe" vecchio stile rispetto a precompute/salta.