Чтение файла в PHP. Выбираем оптимальный вариант

Автор: | 03.01.2018

parser-fajla-phpПриветствую вас, друзья! 🙂

Думаю, что, если не все, то, уж точно большинство из вас сталкивались на практике с необходимостью чтения информации из txt файлов на уровне серверных скриптов. У меня, по крайней мере, таких случаев было несколько, о последнем из которых я вам сегодня и расскажу.

Ничего в этом сложного нет, но иногда глаза разбегаются от обилия вариантов, предоставляемых средствами серверных языков. Если говорить конкретно о PHP, на котором я сейчас программирую, то с помощью его функций можно считывать содержимое файлов и построчно, и целиком в строку, и в массив, причём для последнего варианта существует ещё несколько способов… Вот такие пироги 🙂

К сожалению только, данные методы работают с различной скоростью для файлов разной структуры, и о скорости их работы нет ни единого слова в официальной документации; об этом можно судить лишь на практике, перебирая все возможные варианты.

Поэтому, сегодня я продемонстрирую вам работу различных функций PHP для чтения файлов, чтобы, когда вам нужно будет создать PHP парсер файла для решения реальных задач, вы знали, из чего выбирать. А также подскажу, как именно в «боевых условиях» сделать правильный выбор.

Поехали! 🙂

Создаём PHP парсер файла — начальные условия

Перед тем, как мы начнём, пару слов о задаче, для которой я создавал парсер файла на PHP, а затем выбирал из реализованных вариантов оптимальный.

Однажды у меня на работе возникла проблема, которая заключалась в том, что в БД хранились телефоны пользователей в неверном формате. Сам баг я, естественно, без проблем пофиксил.

Но, что делать с неверной информацией, которая на тот момент уже хранились в базе данных? Естественно, её нужно было заменить на корректную.

Для этого мне был предоставлен текстовый файл с идентификаторами пользователей и их телефонами, которые нужно было перенести в БД.

Должен сказать, он получился весьма увесистым: 352 Кбайта и 8223 строки текста, в каждой из которых содержался идентификатор пользователя и его телефон в формате id_пользователя:номер_телефона.

Словом, вся задача заключалась в построчном чтении файла PHP средствами, выделения из строки идентификатора и телефона с последующим обновлением значения телефона у пользователя в БД, найденного по айдишнику.

Мой проект был реализован на PHP фреймворке Yii, следовательно в дальнейших примерах кода вы встретите элементы его API для работы с БД, в частности, поэтому не пугайтесь 🙂

После анализа имеющихся в языке конструкций, а также опыта других разработчиков, по крупицам собранного в Интернете, мне удалось выделить 4 способа, которые я далее вам и продемонстрирую.

Ну, а после я расскажу, по каким критериям и как именно я выбирал среди них оптимальный вариант. И, естественно, поделюсь результатами 🙂

Так что данная статья — отличная тренировка терпеливости 🙂 Суть её будет заключаться в подробном изучении следующего материала вплоть до результатов, которые будут ждать вас в конце. По ходу, кстати, можете поработать ещё и над фантазией, предполагая, как именно будет выбираться идеальный вариант.

Чтение файла в PHP построчно с помощью fgets()

Для того, чтобы прочитать файл построчно, в PHP есть специальная функция fgets(). Чтобы с её помощью считать содержимое всего файла, её нужно вызывать в цикле, проходясь по всем строкам.

В итоге, PHP парсер файла, реализующий данный алгоритм, у меня принял следующий вид:

<?php

$filename = "users.txt";

if (file_exists($filename) && is_readable($filename)) {
    $fh = @fopen($filename, "r");

    if ($fh) {
        while (($line = fgets($fh, 4096)) !== false) {
            if (!empty($line)) {
                $params = explode(':', $line);
                if (!empty($params[0]) && !empty($params[1]) && $params[1] != 'Fake') {
                    $client = Clients::model()->find('unique_id IN (:id1, :id2)', array(':id1' => strtolower($params[0]), ':id2' => strtoupper($params[0])));
                    if ($client) {
                        $client->phone = str_replace(array("\r", "\n"), "", $params[1]);
                        $client->save();
                    }
                }
            }
        }

        if (!feof($fh)) {
            echo 'Error: unexpected fgets() fail\n';
        }

        fclose($fh);
    }
    else echo "Check the filename, file doesn't exists!";
}

Немного расшифрую свою писанину, если у кого-то возникнут сложности в понимании.

В самом начале, переменной $filename присваивается значение имени файла, который будет парситься, с полным путём к нему. Далее следуют PHP проверка существования файла и читаем ли он с помощью функций file_exists() и is_readable() соответственно.

Если всё ОК, то открываем файл с помощью функции fopen(), которая вызывается с PHP оператором управления ошибками для того, чтобы отключить вывод ошибок, генерируемых данной функцией. Использовать я его решил, чтобы сгенерировать своё сообщение об ошибке вместо стандартного.

Если файл открыть получилось, то мы проходимся по всем его строкам в цикле, пока файл не закончится, и, если строка не пустая, разделяем её по символу двоеточия функцией explode().

Затем проверяем, что id пользователя и его телефон не пустые, ищем пользователя в БД по айдишнику и, если таковой существует, то обновляем ему номер телефона, убрав из значения номера предварительно символы переноса и начала новой строки.

Ну, и ещё я использовал PHP функции strtolower() и strtoupper() для проверки существования в БД пользователя с идентификаторами, которые могли быть прописаны в различных регистрах, т.к. они в моём случае состояли из символов и цифр.

Далее по коду следуют различные сообщения об ошибках, которые могут возникнуть на разных этапах, а также функция закрытия файла — fclose().

PHP парсинг файла в массив с помощью file()

Данный метод чтения файла в PHP предполагает использование функции file(), которая открывает файл и помещает его содержимое в массив. При этом элементами массива будут являться, как раз, строки считываемого файла, что в моей ситуации отлично подходит.

Код данного варианта PHP парсера файла получился следующий:

<?php

$filename = "users.txt";

if (file_exists($filename) && is_readable($filename)) {
    $lines = @file($filename);

    if (!empty($lines)) {
        foreach ($lines as $line) {
            if (!empty($line)) {
                $params = explode(':', $line);

                if (!empty($params[0]) && !empty($params[1]) && $params[1] != 'Fake') {
                    $client = Clients::model()->find('unique_id IN (:id, :id2)', array(':id' => strtolower($params[0]), ':id2' => strtoupper($params[0])));
                    if ($client) {
                        $client->phone = str_replace(array("\r", "\n"), "", $params[1]);
                        $client->save();
                    }
                }
            }
        }
    }
    else echo "Check the filename, file doesn't exists!";
}

Как видите, от предыдущего способа чтения файла в PHP данный отличается только своим началом, где файл открывается и сразу же считывается функцией file() вместо связки fopen() + fgets(), как ранее.

Далее код такой же.

PHP чтение файла в переменную с помощью fread()

Ещё одной функцией PHP для разбора файла является fread(), с помощью которой можно читать различные фрагменты файла указанной длины. Чтобы прочитать файл в PHP целиком, в качестве размера фрагмента я указал размер файла, полученный с помощью функции filesize():

<?php

$filename = "users.txt";

if (file_exists($filename) && is_readable ($filename)) {
    $fp = @fopen($filename, 'r');
    
    if ($fp) {
        $lines = explode("\n", fread($fp, filesize($filename)));
    }

    if (!empty($lines)) {
        foreach ($lines as $line) {
            if (!empty($line)) {
                $params = explode(':', $line);

                if (!empty($params[0]) && !empty($params[1]) && $params[1] != 'Fake') {
                    $client = Clients::model()->find('unique_id IN (:id1, :id2)', array(':id1' => strtolower($params[0]), ':id2' => strtoupper($params[0])));
                    if ($client) {
                        $client->phone = str_replace(array("\r", "\n"), "", $params[1]);
                        $client->save();
                    }
                }
            }
        }
    }
    else echo "Check the filename, file doesn't exists!";
}

Данный способ чтения файла PHP средствами, на самом деле, очень похож на предыдущий, т.к., несмотря на то, что с помощью PHP данные из файла изначально считываются не в массив, а в строковую переменную, далее она всё равно преобразуется в массив, т.к. с ним проще работать, чем со строкой.

Преобразование строки в массив на PHP проще всего сделать с помощью уже применявшейся сегодня функции explode(), в качестве разделителя в которую был передан символ начала строки.

А дальше всё идёт по накатанной 🙂

Создаём PHP парсер файла на базе file_get_contents()

Ну, и напоследок, я решил реализовать PHP парсинг файла с помощью функции file_get_contents(), которая, как раз и предназначена для чтения файла целиком в строку, т.е. работает, практически, как fread($fp, filesize($filename)).

За тем лишь исключением, что file_get_contents() самостоятельно открывает файл и считывает его, в то время как для использования fread() нужно было предварительно открыть файл через fopen() и получить его указатель для дальнейшего использования.

В целом, код PHP парсера файла на базе file_get_contents() будет практически как и в предыдущем случае:

<?php

$filename = "users.txt";

if (file_exists($filename) && is_readable ($filename)) {
    
    $lines = explode("\n", file_get_contents($filename));

    if (!empty($lines)) {
        foreach ($lines as $line) {
            if (!empty($line)) {
                $params = explode(':', $line);

                if (!empty($params[0]) && !empty($params[1]) && $params[1] != 'Fake') {
                    $client = Clients::model()->find('unique_id IN (:id1, :id2)', array(':id1' => strtolower($params[0]), ':id2' => strtoupper($params[0])));
                    if ($client) {
                        $client->phone = str_replace(array("\r", "\n"), "", $params[1]);
                        $client->save();
                    }
                }
            }
        }
    }
    else echo "Check the filename, file doesn't exists!";
}

На этом всё. Пришло время подвести итоги производительности всех перечисленных вариантов и выяснить, какой же PHP парсер файла оказался самым оптимальным для дальнейшего использования.

Какой способ обработки файлов в PHP является оптимальным?

Чтобы выбрать из найденных вариантов самый оптимальный, т.е. самый быстрый, я решил определить время выполнения скрипта PHP в каждом случае. Для этого я воспользовался методикой, описанной в статье по ссылке.

Сами по себе PHP функции чтения файлов достаточно шустрые, поэтому, чтобы добиться хоть каких-то более-менее осязаемых цифр времени их работы, я специально оставил в тестируемых фрагментах операции с базой данных, которые во всех случаях были одни и те же.

Время работы PHP скрипта я также решил для удобства округлять до третьего знака после запятой, т.е. до тысячных долей секунд (хотя, можно было ограничиться и сотыми, на самом деле).

Помню, когда я учился в школе и писал свою научную работу по физике (да, был такой опыт 🙂 ) на её защите перед университетскими преподавателями меня постоянно упрекали за недостаточное количество экспериментов (я делал по 3 опыта для каждого случая). «Светилы науки» называли цифры в 100, ну или, хотя бы, в 10 экспериментов для сравнения различных ситуаций, чтобы можно было делать какое-то их сопоставление и минимизировать вероятность случайного превосходства одного над другим.

Да, досталось мне тогда от них крепко, но их рекомендации я хорошо усвоил, что даже сейчас об этом помню, хотя прошло уже более 10 лет с тех пор. Тем более, что данные рекомендации действительно были основаны на законах математической статистики и теории вероятности.

Ну, на научность своих нынешних экспериментов я в данной статье не претендую, поэтому число в 100 экспериментов я посчитал излишне большим, а процесс их проведения — слишком утомительным занятием.

В итоге, я решил ограничиться 10 экспериментами для каждого варианта PHP парсера файла, чего, как оказалось в итоге, оказалось вполне достаточно, чтобы выделить явного лидера без всякой подтасовки фактов и зацепок за сотые и тысячные доли секунды превосходства.

Результаты вычислений времени работы разработанных мною PHP парсеров файла представлены в следующей таблице и рассортированы по PHP функциям, на базе которых они работают.

Эксперимент fgets() file() fread() file_get_contents()
1 9,147 9,722 10,539 2,008
2 8,950 9,006 9,495 1,733
3 8,821 8,845 9,207 1,642
4 8,717 8,876 8,931 1,758
5 9,010 9,091 8,703 1,635
6 9,110 8,640 9,712 1,633
7 9,074 9,626 9,13 1,645
8 8,886 9,204 9,048 1,701
9 8,667 8,918 9,438 1,713
10 8,852 9,197 9,537 1,567
Среднее 8,923 9,113 9,374 1,704

Как видите, помимо значений времени выполнения скрипта в каждом из 10 экспериментов, я решил подсчитать среднюю температуру по больнице 🙂

А именно, арифметическое среднее время работы каждого PHP парсера файла, чтобы можно было выявить лидера.

И им оказался, как видите, последний вариант, реализованный на базе функции file_get_contents(), который выполняет чтение содержимого файла в строковую переменную с дальнейшим его преобразованием в массив и обработкой в цикле.

Все остальные варианты PHP парсеров файлов работают примерно с одинаковой скоростью.

Почему именно он обогнал своих конкурентов я, если честно, не имею ни малейшего понятия. Могу лишь предположить, что операция чтения файла в строку с помощью file_get_contents() требует меньше ресурсов, чем формирование готового массива строк с помощью file().

А превосходство над fgets() и fread() можно списать на то, что перед их использованием требуется открытие файла с помощью fopen(), на что требуется время.

Да, на самом деле, это и не важно, т.к. цифры говорят сами за себя: благодаря использованию функции file_get_contents() PHP парсер файла на его базе работает в 5 раз быстрее остальных, что и повлияло на моё решение использовать его на практике.

Разбор файла в PHP — выводы

Как я уже и говорил в начале, мои опыты не являются безупречными и опираться исключительно на полученные в их ходе результаты не стоит, т.к., несмотря на быстродействие file_get_contents() в моей ситуации, бывают случаи, когда намного удобнее и эффективнее использовать другие приведённые мною PHP парсеры файлов.

Кроме того, не стоит забывать, что PHP сам по себе является синхронным языком программирования, т.е. все серверные операции происходят последовательно без возможности настройки их параллельного выполнения, в том числе, и на разных ядрах серверного процессора.

Следовательно, на время выполнения операций, прописанных в PHP коде, может влиять целый ряд факторов, среди которых основным является нагруженность ядра в момент работы PHP приложения.

Я это особенно ощутил во время проведения опытов, когда один и тот же PHP парсер файла отработал за 9, затем за 12, а потом снова за 9 секунд на трёх последовательных итерациях из-за банального запуска проводника Windows во время второго случая, который, естественно, тоже требует серверных ресурсов.

Учитывая данные особенности, я проводил эксперименты практически одновременно, друг за другом, при одинаковом комплекте запущенных программ, чтобы не распылять ресурсы серверного железа.

Поэтому в дальнейшем, при проведении подобных экспериментов с PHP конструкциями действуйте аналогичным образом, т.к. это, по сути, единственный способ привести эксперименты к равным условиям.

Если же вы будете работать с асинхронными серверными языками (C#, Java) или технологиями (Node.js, например), то, по возможности, для экспериментов создавайте отдельный поток, который будет работать на выделенном ядре процессора.

Ну, а если найти полностью незадействованное ядро не получится (что при уровне современного ПО не удивительно), то вы хотя бы сможете найти самое слабонагруженное или, хотя бы, со статической нагрузкой, которая не меняется во времени.

Надеюсь, что мои наблюдения и рекомендации будут вам полезны, равно как и мои сегодняшние эксперименты с PHP парсерами файлов.

Подытоживая, хочу сказать, что приведённые в статье фрагменты кода могут использоваться не только для парсинга текстовых файлов в PHP, но и отлично подойдут для других форматов, например, для разбора CSV файлов дампа базы данных MySQL.

Пишите ваши отзывы, как положительные, так и отрицательные в комментариях под статьёй — мне необходимо любое ваше мнение для дальнейшего развития 🙂

Также буду благодарен, если поделитесь данной статьёй со своими друзьями в социальных сетях с помощью кнопочек ниже.

До новых встреч! 🙂

  1. 5
  2. 4
  3. 3
  4. 2
  5. 1
5 голосов, в среднем: 5 из 5

8 комментариев к статье "Чтение файла в PHP. Выбираем оптимальный вариант"

  1. Алексей

    Благодарю за статью.

    Но поверьте, 352 Кбайта и 8223 строки текста это ну ооочень мало 🙂
    Мне, на днях, довелось разобрать текстовый файл с логами клиентов, перезалитого с маршрутизатора, потребовалось перегнать его в базу (ну вот так вот нужно было). Объем файла почти полтора гига. На выбор был перл или пхп, на перле очень давно не писал, сделал на пхп с использованием file_get_contents() как Вы и посоветовали в статье. Скрипт отработал, оставил на ночь, коллеги на следующий день забрали данные и перегнали в базу. Вернусь, уточню сколько по времени заняло.

    1. Pashaster Автор

      Добрый день! Огромное Вам спасибо за Ваш комментарий.

      По поводу моего файла для экспериментов — я сам понимаю, что его размер практически ничтожен, но, как говорится «что было» 🙂

      Очень было бы интересно услышать о Вашем опыте использования моего метода парсинга на большом файле — насколько он оказался эффективен?

      1. Алексей

        Он позволил решить задачу и не отнял лишнего рабочего времени. Не это ли показатель эффективности? :))

        1. Pashaster Автор

          Вы просто обещали указать время обработки файла — меня это интересовало.

  2. Astren

    Спасибо за статью и отличный блог, вот уже давно с удовольствием читаю 🙂
    Пока читал у меня возникло два комментария:

    Первый:
    Вы задаётесь вопросом почему file_get_contents работает быстрее? Почему она быстрее последовательного чтения из файла, скажем по строкам?

    Вроде бы очевидно — нет оверхеда на вызов функций для чтения каждой строки.

    Быстрее же попытки считать файл разом в кучу она, потому, что использует https://ru.wikipedia.org/wiki/Mmap т.е. отображает файл напрямую в память постранично. Т.е. файл загружается в память не целиком, а по целым страницам памяти, когда надо.

    Альтернативой было бы выделить в куче памяти на размер файла, и считать его туда. Но, во-первых, пространства в куче может не хватить. Во-вторых, хоть выделенный буфер в виртуальной памяти и будет казаться последовательным, в физической памяти он таким, скорее всего, не будет.

    Т.е., записывая в такой буфер и считывая из него, системе придётся прыгать туда-сюда. Казалось бы, RAM на то и random access memory, чтобы это не вызывало проблем.

    Но, на самом деле, ОС используют множество уловок для кэширования данных, предполагая, что данные из памяти преимущественно читаются последовательно, и, соответственно при каждом кеш промахе система будет подгружать новые, дополнительные, и лишние в нашем случае, участки памяти.

    Довольно подробно про отображение файлов в память написано тут:
    https://ru.wikipedia.org/wiki/%D0%9E%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D1%84%D0%B0%D0%B9%D0%BB%D0%B0_%D0%B2_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C

    При чтении файла выигрыш уже заметен, но эта техника ещё полезнее при многократном изменении файла в разных местах. Сначала отображаем его в память, потом много раз меняем в разных местах, после этого отображаем память на диск обратно. Это много быстрее, чем изменять файл на диске кусочками.

    Второй:
    Если вы используете mysql, то в нём поиск по совпадению или like и так регистронезависим. Т.е. для mysql следующие запросы — это одно и то же, если вы не задали id как бинарный тип данных:

    SELECT * FROM my_table WHERE id = "A";
    SELECT * FROM my_table WHERE id = "a";
    SELECT * FROM my_table WHERE id IN ("A");
    SELECT * FROM my_table WHERE id IN ("a");
    

    Но именно в контексте id, т.е. ключа, вы, скорее всего этого делать не хотите, mysql будет заметно проще индексировать не бинарные ключи.

    В вашем же случае, вы сравниваете только со строками, написанным полностью строчными буквами или заглавными, и будь поиск регистрозависимым, ваш код не учитывал бы записи в БД, имеющие и те и те буквы.

    Чтобы сделать поиск в mysql регистрозависимым, надо mysql сказать сравнивать данные как бинарные, при помощи оператора binary:

    https://dev.mysql.com/doc/refman/5.7/en/case-sensitivity.html

    1. Pashaster Автор

      Доброго времени суток! 🙂 Огромное Вам спасибо за слова и особенная благодарность за Ваши профессиональные комментарии, которые можно смело оформлять отдельной статьёй 🙂 Уверен, что многим они будут полезны, включая меня.

      Действительно, я не ставил себе целью разбираться на низком уровне, какая из функций работает с физической памятью и прочими ресурсами ЭВМ более эффективно. Мне достаточно было «высокоуровневого» результата, благо, что он оказался положительным, и я потратил время не напрасно 🙂

      Мысли, конечно, были «залезть в дебри», но с исходниками PHP на C желания разбираться не возникло. Тем более, что я на нём не писал 🙂 Максимум, с чем имел дело, — с C++, но это было достаточно давно и на весьма примитивном уровне.

  3. Peter

    (можно не публиковать 🙂 ) else — не на той строчке!
    А за статью Спасибо!

    1. Pashaster Автор

      И Вам спасибо за отзыв 🙂 Приятно, когда твой труд ценят 🙂

      По замечанию, кстати, согласен — не PSR-2 код получился. Но я только к этому стремлюсь, всё никак от C++ codestyle за 5 лет полностью не отучусь 🙂

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *