Який найкращий спосіб прочитати останні файли (тобто “хвіст”) із файлу за допомогою PHP?

Question 1

У моїй програмі PHP мені потрібно прочитати кілька рядків, починаючи з кінця багатьох файлів (переважно журналів). Іноді мені потрібен лише останній, іноді мені потрібні десятки чи сотні. В основному, я хочу щось таке гнучке, як команда Unix tail .

Тут є запитання про те, як отримати один останній рядок із файлу (але мені потрібні N рядків), і були надані різні рішення. Я не впевнений, який з них найкращий, а який кращий.

Question 2

Огляд методів

Шукаючи в Інтернеті, я натрапив на різні рішення. Я можу згрупувати їх за трьома підходами:

наївні , що використовують file()функцію PHP;
обман тих, хто запускає tailкоманду в системі;
могутні , які із задоволенням стрибають навколо відкритого файлу за допомогою fseek().

Врешті-решт я вибрав (або написав) п’ять рішень, наївне , шахрайське та три могутні .

Найкоротше наївне рішення з використанням вбудованих функцій масиву.
Можливо тільки рішення , засноване наtail команду , яка має трохи більшу проблему: вона не запускається , якщоtail немає, то є на НЕ-Unix (Windows) або на обмежених умовах , які не дозволяють системні функції.
Рішення, в якому одиночні байти зчитуються з кінця файлу, шукаючи (та підраховуючи) символи нового рядка, знайдено тут .
Багатобайтові буферний розчин , оптимізований для великих файлів, знайшов тут .
Трохи модифікована версія рішення №4, в якій довжина буфера є динамічною, визначається відповідно до кількості рядків для отримання.

Всі рішення працюють . У тому сенсі, що вони повертають очікуваний результат з будь-якого файлу та для будь-якої кількості рядків, про які ми просимо (за винятком рішення №1, яке може порушити обмеження пам’яті PHP у разі великих файлів, нічого не повертаючи). Але який з них краще?

Тести продуктивності

Щоб відповісти на запитання, я запускаю тести. Ось як це робиться, чи не так?

Я підготував зразок файлу розміром 100 КБ, що поєднує різні файли, знайдені в моєму /var/logкаталозі. Потім я написав PHP-скрипт, який використовує кожне з п’яти рішень для отримання 1, 2, .., 10, 20, ... 100, 200, ..., 1000 рядків з кінця файлу. Кожен окремий тест повторюється десять разів (це приблизно 5 × 28 × 10 = 1400 тестів), вимірюючи середній час, що минув у мікросекундах.

Я запускаю сценарій на своїй локальній машині розробки (Xubuntu 12.04, PHP 5.3.10, двоядерний процесор 2,70 ГГц, 2 ГБ оперативної пам'яті) за допомогою інтерпретатора командного рядка PHP. Ось результати:

Час виконання на зразку файлу журналу розміром 100 КБ

Рішення №1 та №2 здаються гіршими. Рішення No3 добре лише тоді, коли нам потрібно прочитати кілька рядків. Рішення №4 та №5 здаються найкращими. Зверніть увагу, як динамічний розмір буфера може оптимізувати алгоритм: час виконання трохи менший для кількох рядків через зменшений буфер.

Давайте спробуємо з більшим файлом. Що робити, якщо нам доведеться прочитати файл журналу 10 МБ ?

Час виконання на зразку 10 Мб файлу журналу

Зараз рішення №1 набагато гірше: насправді завантаження всього 10-МБ файлу в пам’ять - це не чудова ідея. Я запускаю тести також на файлах розміром 1 МБ і 100 МБ, і це практично та ж ситуація.

А для крихітних файлів журналів? Ось графік файлу 10 КБ :

Час виконання на зразку файлу журналу 10 КБ

Рішення No1 зараз найкраще! Завантаження 10 Кб в пам’ять для PHP не є великою проблемою. Також №4 та №5 мають хороші результати. Однак це крайній випадок: журнал 10 КБ означає щось на зразок 150/200 рядків ...

Ви можете завантажити всі мої тестові файли, джерела та результати тут .

Заключні думки

Рішення №5 настійно рекомендується для загального використання: чудово працює з будь-яким розміром файлу і особливо добре працює при читанні кількох рядків.

Уникайте рішення №1, якщо вам слід прочитати файли розміром більше 10 КБ.

Рішення №2 та №3 - не найкращі для кожного тесту, який я виконую: №2 ніколи не виконується менше ніж за 2 мс, а на №3 сильно впливає кількість запитаних рядків (працює цілком добре лише з 1 або 2 рядками ).

Question 3

Це модифікована версія, яка також може пропускати останні рядки:

/**
 * Modified version of http://www.geekality.net/2011/05/28/php-tail-tackling-large-files/ and of https://gist.github.com/lorenzos/1711e81a9162320fde20
 * @author Kinga the Witch (Trans-dating.com), Torleif Berger, Lorenzo Stanco
 * @link http://stackoverflow.com/a/15025877/995958
 * @license http://creativecommons.org/licenses/by/3.0/
 */    
function tailWithSkip($filepath, $lines = 1, $skip = 0, $adaptive = true)
{
  // Open file
  $f = @fopen($filepath, "rb");
  if (@flock($f, LOCK_SH) === false) return false;
  if ($f === false) return false;

  if (!$adaptive) $buffer = 4096;
  else {
    // Sets buffer size, according to the number of lines to retrieve.
    // This gives a performance boost when reading a few lines from the file.
    $max=max($lines, $skip);
    $buffer = ($max < 2 ? 64 : ($max < 10 ? 512 : 4096));
  }

  // Jump to last character
  fseek($f, -1, SEEK_END);

  // Read it and adjust line number if necessary
  // (Otherwise the result would be wrong if file doesn't end with a blank line)
  if (fread($f, 1) == "\n") {
    if ($skip > 0) { $skip++; $lines--; }
  } else {
    $lines--;
  }

  // Start reading
  $output = '';
  $chunk = '';
  // While we would like more
  while (ftell($f) > 0 && $lines >= 0) {
    // Figure out how far back we should jump
    $seek = min(ftell($f), $buffer);

    // Do the jump (backwards, relative to where we are)
    fseek($f, -$seek, SEEK_CUR);

    // Read a chunk
    $chunk = fread($f, $seek);

    // Calculate chunk parameters
    $count = substr_count($chunk, "\n");
    $strlen = mb_strlen($chunk, '8bit');

    // Move the file pointer
    fseek($f, -$strlen, SEEK_CUR);

    if ($skip > 0) { // There are some lines to skip
      if ($skip > $count) { $skip -= $count; $chunk=''; } // Chunk contains less new line symbols than
      else {
        $pos = 0;

        while ($skip > 0) {
          if ($pos > 0) $offset = $pos - $strlen - 1; // Calculate the offset - NEGATIVE position of last new line symbol
          else $offset=0; // First search (without offset)

          $pos = strrpos($chunk, "\n", $offset); // Search for last (including offset) new line symbol

          if ($pos !== false) $skip--; // Found new line symbol - skip the line
          else break; // "else break;" - Protection against infinite loop (just in case)
        }
        $chunk=substr($chunk, 0, $pos); // Truncated chunk
        $count=substr_count($chunk, "\n"); // Count new line symbols in truncated chunk
      }
    }

    if (strlen($chunk) > 0) {
      // Add chunk to the output
      $output = $chunk . $output;
      // Decrease our line counter
      $lines -= $count;
    }
  }

  // While we have too many lines
  // (Because of buffer size we might have read too many)
  while ($lines++ < 0) {
    // Find first newline and remove all text before that
    $output = substr($output, strpos($output, "\n") + 1);
  }

  // Close file and return
  @flock($f, LOCK_UN);
  fclose($f);
  return trim($output);
}

Question 4

Це також працює:

$file = new SplFileObject("/path/to/file");
$file->seek(PHP_INT_MAX); // cheap trick to seek to EoF
$total_lines = $file->key(); // last line number

// output the last twenty lines
$reader = new LimitIterator($file, $total_lines - 20);
foreach ($reader as $line) {
    echo $line; // includes newlines
}

Або без LimitIterator:

$file = new SplFileObject($filepath);
$file->seek(PHP_INT_MAX);
$total_lines = $file->key();
$file->seek($total_lines - 20);
while (!$file->eof()) {
    echo $file->current();
    $file->next();
}

На жаль, у вашому тестовому сегменті є помилки на моїй машині, тому я не можу сказати, як він працює.

Question 5

Мені подобається наступний спосіб, але він не буде працювати з файлами обсягом до 2 Гб.

<?php
    function lastLines($file, $lines) {
        $size = filesize($file);
        $fd=fopen($file, 'r+');
        $pos = $size;
        $n=0;
        while ( $n < $lines+1 && $pos > 0) {
            fseek($fd, $pos);
            $a = fread($fd, 1);
            if ($a === "\n") {
                ++$n;
            };
            $pos--;
        }
        $ret = array();
        for ($i=0; $i<$lines; $i++) {
            array_push($ret, fgets($fd));
        }
        return $ret;
    }
    print_r(lastLines('hola.php', 4));
?>

Question 6

Моє маленьке рішення для копіювання, прочитавши все це тут. tail () не закриває $ fp, тому що ви все одно повинні вбити його за допомогою Ctrl-C. usleep для економії вашого процесора, поки що протестовано лише на Windows. Вам потрібно додати цей код до класу!

/**
 * @param $pathname
 */
private function tail($pathname)
{
    $realpath = realpath($pathname);
    $fp = fopen($realpath, 'r', FALSE);
    $lastline = '';
    fseek($fp, $this->tailonce($pathname, 1, false), SEEK_END);
    do {
        $line = fread($fp, 1000);
        if ($line == $lastline) {
            usleep(50);
        } else {
            $lastline = $line;
            echo $lastline;
        }
    } while ($fp);
}

/**
 * @param $pathname
 * @param $lines
 * @param bool $echo
 * @return int
 */
private function tailonce($pathname, $lines, $echo = true)
{
    $realpath = realpath($pathname);
    $fp = fopen($realpath, 'r', FALSE);
    $flines = 0;
    $a = -1;
    while ($flines <= $lines) {
        fseek($fp, $a--, SEEK_END);
        $char = fread($fp, 1);
        if ($char == "\n") $flines++;
    }
    $out = fread($fp, 1000000);
    fclose($fp);
    if ($echo) echo $out;
    return $a+2;
}

Question 7

Ще одна функція - ви можете використовувати регулярні вирази для розділення елементів. Використання

$last_rows_array = file_get_tail('logfile.log', 100, array(
  'regex'     => true,          // use regex
  'separator' => '#\n{2,}#',   //  separator: at least two newlines
  'typical_item_size' => 200, //   line length
));

Функція:

// public domain
function file_get_tail( $file, $requested_num = 100, $args = array() ){
  // default arg values
  $regex         = true;
  $separator     = null;
  $typical_item_size = 100; // estimated size
  $more_size_mul = 1.01; // +1%
  $max_more_size = 4000;
  extract( $args );
  if( $separator === null )  $separator = $regex ? '#\n+#' : "\n";

  if( is_string( $file ))  $f = fopen( $file, 'rb');
  else if( is_resource( $file ) && in_array( get_resource_type( $file ), array('file', 'stream'), true ))
    $f = $file;
  else throw new \Exception( __METHOD__.': file must be either filename or a file or stream resource');

  // get file size
  fseek( $f, 0, SEEK_END );
  $fsize = ftell( $f );
  $fpos = $fsize;
  $bytes_read = 0;

  $all_items = array(); // array of array
  $all_item_num = 0;
  $remaining_num = $requested_num;
  $last_junk = '';

  while( true ){
    // calc size and position of next chunk to read
    $size = $remaining_num * $typical_item_size - strlen( $last_junk );
    // reading a bit more can't hurt
    $size += (int)min( $size * $more_size_mul, $max_more_size );
    if( $size < 1 )  $size = 1;

    // set and fix read position
    $fpos = $fpos - $size;
    if( $fpos < 0 ){
      $size -= -$fpos;
      $fpos = 0;
    }

    // read chunk + add junk from prev iteration
    fseek( $f, $fpos, SEEK_SET );
    $chunk = fread( $f, $size );
    if( strlen( $chunk ) !== $size )  throw new \Exception( __METHOD__.": read error?");
    $bytes_read += strlen( $chunk );
    $chunk .= $last_junk;

    // chunk -> items, with at least one element
    $items = $regex ? preg_split( $separator, $chunk ) : explode( $separator, $chunk );

    // first item is probably cut in half, use it in next iteration ("junk") instead
    // also skip very first '' item
    if( $fpos > 0 || $items[0] === ''){
      $last_junk = $items[0];
      unset( $items[0] );
    } // … else noop, because this is the last iteration

    // ignore last empty item. end( empty [] ) === false
    if( end( $items ) === '')  array_pop( $items );

    // if we got items, push them
    $num = count( $items );
    if( $num > 0 ){
      $remaining_num -= $num;
      // if we read too much, use only needed items
      if( $remaining_num < 0 )  $items = array_slice( $items, - $remaining_num );
      // don't fix $remaining_num, we will exit anyway

      $all_items[] = array_reverse( $items );
      $all_item_num += $num;
    }

    // are we ready?
    if( $fpos === 0 || $remaining_num <= 0 )  break;

    // calculate a better estimate
    if( $all_item_num > 0 )  $typical_item_size = (int)max( 1, round( $bytes_read / $all_item_num ));
  }

  fclose( $f ); 

  //tr( $all_items );
  return call_user_func_array('array_merge', $all_items );
}

Question 8

Для звичайних невеликих текстових файлів, одного вкладиша, нічого страшного:

echo join(array_slice(file("path/to/file"), -5));

Щоб визначити нові рядки, залежно від контексту, це часто простіше:

echo join("\n",array_slice(explode("\n",file_get_contents("path/to/file")), -5));

echo join("<br>",array_slice(explode(PHP_EOL,file_get_contents("path/to/file")), -5));

echo join(PHP_EOL,array_slice(explode("\n",file_get_contents("path/to/file")), -5));