php value output buffering

Буфер вывода в PHP

В этой статье я хочу рассказать о том, как реализован слой «буферизации вывода» в PHP, как работает и как с ним взаимодействовать из PHP. В этом слое нет ничего сложного, но многие разработчики либо совсем не понимают, как с ним обращаться, либо не имеют полной ясности. Всё, о чём я буду писать, относится к PHP версии 5.4 и выше. Именно начиная с неё изменились многие вещи, связанные с буфером вывода (БВ). По сути, этот функционал был полностью переписан, поэтому совместимость с версией 5.3 сохранилась лишь частично.

Что такое буфер вывода?

Поток вывода в PHP содержит байты, обычно в виде текста, которые разработчику надо вывести на экран. Чаще всего для этого используется конструкция echo или printf(). Во-первых, нужно понимать, что любая функция, которая что-то выводит, будет использовать БВ из области PHP. Если говорить о расширениях для PHP, то можно получить доступ к функциям, пишущим в SAPI напрямую, в обход любого вышерасположенного БВ. API C задокументировано в lxr.php.net/xref/PHP_5_5/main/php_output.h, отсюда можно почерпнуть немало информации, например, о размере буфера по умолчанию.

Второй важный момент: слой БВ является не единственным слоем, в котором буферизуются выводимые данные.

И третье: в зависимости от SAPI, который вы используете (веб или cli), слой БВ может вести себя по-разному.

Ниже представлена схема, которая поможет понять всё вышесказанное:

Здесь мы видим, что для управления выводимыми данными в PHP используется три логических слоя буферизации. Два из них принадлежат тому самому «буферу вывода», а третий — SAPI. Когда поток вывода покидает область PHP, чтобы попасть на нижний уровень архитектуры, «по пути» могут возникнуть новые буферы: буфер терминала, буфер FastCGI, буфер веб-сервера, буфер операционной системы, буферы стеков TCP/IP. Не забывайте об этом. Хотя в рамках данной статьи мы будем говорить только о PHP, в стеке на пути данных к нижнему слою и пользователю встретится ещё немало программных средств.

Важное замечание относительно CLI SAPI: он отключает в PHP любой буфер вывода по умолчанию, присвоив в ini параметру output_buffering значение 0. Так что, пока вы в CLI не пропишете вручную функции ob_(), по умолчанию все выводимые данные будут напрямую попадать в слой SAPI. Более того, в CLI для параметра implicit_flush жёстко указано значение 1. Суть этого параметра разработчики вечно понимают неправильно, хотя код говорит совершенно недвусмысленно: когда implicit_flush имеет значение 1, буфер слоя SAPI сбрасывается при каждой записи. То есть каждый раз, когда вы записываете данные для вывода с помощью CLI SAPI, они немедленно отправляются на нижний уровень, где записываются в виде stdout, а потом сбрасываются.

Стандартный PHP-слой буферизации вывода

По умолчанию в php.ini, идущем в составе поставки PHP, output_buffering присвоено значение «4096» (байт). Если вы не используете php.ini (или запускаете PHP с ключом –n), то значением по умолчанию будет «0», то есть отключено. Если захардкодить значение «On», то будет назначен стандартный размер буфера вывода (16 КБ).

Как вы уже, наверное, догадались, использование буфера для вывода в веб-окружении благотворно влияет на производительность. Начальных 4 КБ вполне достаточно, ведь это означает, что вы можете записать до 4096 ASCII-символов, пока PHP не начнёт взаимодействовать с нижерасположенным слоем SAPI. В условиях веба отправка данных побайтно, напротив, производительность не улучшает. Гораздо лучше, если сервер отправляет весь контент скопом или большими частями. Чем реже уровни обмениваются данными, тем лучше с точки зрения производительности. Поэтому обязательно используйте буфер вывода. PHP отправит его содержимое в конце запроса и вам для этого ничего не придётся делать.

В предыдущей главе я упоминал об implicit_flush в контексте CLI. В случае с любым другим SAPI implicit_flush изначально отключён. Это хорошо, поскольку вряд ли вы будете приветствовать сброс SAPI сразу же после записи в него. Для протокола FastCGI сброс можно сравнить с завершением и отправкой пакета после каждой записи. Однако лучше сначала полностью заполнить буфер FastCGI, а уже потом слать пакеты. Если вам нужно вручную сбросить буфер SAPI, используйте для этого PHP-функцию flush(). Для сброса после каждой записи, как уже говорилось выше, можно использовать параметр implicit_flush в php.ini. Как вариант — однократный вызов PHP-функции ob_implicit_flush().

Вы можете использовать только один callback, который получит содержимое буфера и сделает полезные преобразования для вывода, что не может не радовать. Для анализа данных, которые PHP отправляет веб-серверу, а тот отсылает пользователю, полезно использовать callback-и буфера вывода. Кстати, под «выводом» я подразумеваю как заголовок, так и тело. HTTP-заголовки тоже являются частью слоя буферизации вывода.

Тело и заголовки

Когда вы используете буфер вывода (неважно, пользовательский или один из стандартных), то можете отправлять HTTP-заголовки и содержимое как угодно. Любой протокол требует сначала отсылать заголовок, а уже потом тело, но за вас это сделает сам PHP, если вы используете слой БВ. Любая PHP-функция, работающая с заголовками (header(), setcookie(), session_start()), фактически использует внутреннюю функцию sapi_header_op(), которая просто заполняет буфер заголовков. Если после этого записать выводимые данные, например, с помощью printf(), то они запишутся в один из соответствующих буферов вывода. И во время отправки буфера PHP сначала

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

Пользовательские буферы вывода

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

Ниже приведён пример работы со стандартным PHP-слоем с помощью внутреннего веб-сервера SAPI:

Мы запустили PHP со стандартным буфером вывода на 32 байта, после чего сразу же записали в него 31 байт, пока не включилась задержка исполнения. Экран чёрный, пока ничего не отправлено. Затем действие sleep() заканчивается, и мы записываем ещё один байт, тем самым полностью заполняя буфер. После этого он сразу же сбрасывает себя в буфер слоя SAPI, а тот сбрасывает себя в вывод, поскольку implicit_flush имеет значение 1. На экране появляется строка aaaaaaaaaa<31 раз>b, после чего опять начинает действовать sleep(). По его завершении пустой 31-байтный буфер заполняется одним-единственным байтом, после чего PHP завершается и сбрасывает буфер. На экране появляется с.

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

Теперь с помощью ob_start() можно запускать пользовательские буферы, причем столько, сколько нужно, пока память не закончится. Каждый буфер будет помещаться за предыдущим и немедленно сбрасываться в следующий, что постепенно приведёт к переполнению.

Устройство буферизации вывода

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

Пожалуй, одним из самых приятных нововведений стало то, что расширения теперь могут объявлять свои callback-и буфера вывода, конфликтующие с callback-ами других расширений. Ранее было невозможно полностью управлять ситуациями, когда другие расширения тоже могли декларировать свои callback-и.

Вот небольшой пример на скорую руку, демонстрирующий, как можно зарегистрировать callback, преобразующий данные в верхний регистр:

Подводные камни

По большей части они задокументированы, некоторые из них вполне очевидны, а некоторые не слишком. К очевидным можно отнести, например, то, что не следует вызывать какие-либо функции буфера изнутри callback-а БВ, также как и записывать выводимые оттуда данные.

К неочевидным подводным камням можно отнести то, что некоторые функции PHP используют внутренний БВ для самих себя, заполняя его, а затем сбрасывая или возвращая. При этом следующий буфер ставится в стек. К подобным функциям относятся print_r(), highlight_file() и SoapServer::handle(). Не следует использовать их изнутри callback-а БВ – это может привести к непредсказуемым последствиям.

Заключение

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

По умолчанию имеется один буфер вывода, управляемый тремя настройками в ini-файле. Он устроен так, чтобы реже осуществлять операции записи и не слишком часто обращаться к слою SAPI, а значит и к сети. Это сделано для улучшения общей производительности. Также расширения PHP могут декларировать callback-и, запускаемые в каждом буфере — например, для компрессии данных, замены строк, управления HTTP-заголовками и многих других операций.

Источник

Использование Output Buffering в PHP

Что делать? Ответ простой — читать документацию. На функции ob_*, начиная с ob_start()
Оказывается, что в PHP есть возможность не сразу выдавать результат работы скрипта браузеру, а сохранять в специальном месте, именуемом Output Buffer (буфер вывода). При этом в PHP есть функции, которые позволяют изменять его содержимое. Еще одним аргументом за ob_start() в самом начале программы является возможность установки различных HTTP-заголовков, например, cookies, в произвольном месте скрипта, а не в самом его начале.

Кстати, в PHP есть возможность «сжать» (заархивировать) результат работы вашего скрипта, дабы уменьшить количество трафика, гуляющего по сети — для этого нужно вызвать функцию ob_start с параметром «ob_gzhandler»: ob_start(«ob_gzhandler»); Естественно, если браузер не поддерживает сжатый контент — ваша страница будет передана ему без изменений.

А теперь давайте от слов перейдём к конкретным примерам:

Внимание! Здесь и далее предполагается, что в самом начале скрипта включается буферизация вывода:

Пример 1: автоматическая подсветка переменных.

Предположим, у вас на сайте есть статьи, посвященные PHP. Естественно, они должны содержать и примеры кода на PHP 😉 Однако, если весь ваш код будет набран шрифтом одного цвета, то читать этот код будет немного затруднительно. Так давайте раскрасим код! Пусть все имена переменных будут синего цвета. А комментарии — красного (будем считать, что комментарии начинаются c //). Для этого в самом конце скрипта добавляем следующий код:

Естественно, вышеприведённый пример не является идеальным — например, если в вашем тексте встретится код JavaScript, в котором нечаянно окажется комментарий, то работать он перестанет. Однако, с небольшой модификацией, именно этот пример раскрасил, хоть и не идеально, эту статью.

Пример 2: автоматическое распознавание URL и генерация ссылок.

Предположим, у вас на сайте есть гостевая книга или форум, и какой-либо посетитель решил разместить ссылку на свой ресурс. Дабы не утруждать пользователя изучением HTML, было бы удобно сделать так, чтобы все URL, указанные пользователем, автоматически обрамлялись в соответствующие ссылки на языке HTML. Например:

Так же было бы полезно преобразовывать следующие строки:

в самом конце вашего скрипта надо дописать следующий код:

Пример 3: автоматическая генерация ссылок на разделы вашего сайта

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

Естественно, приведённый выше пример нельзя считать окончательным — например, если у вас где-нибудь в синонимах встретится какой-то из символов, имеющих специальное значение в perl regular expressions, например, скобки, то результатом выполнения этого кусочка программы могут стать сообщения об ошибках на ваших страницах. Кроме того, приведённое выше регулярное выражение не учитывает, что название раздела уже может являться ссылкой либо её частью, и, соответственно, испортит её.

Но, тем не менее, эта технология, с некоторыми дополнениями, спасает автора этих строк от написания ссылок на разделы своего сайта. Кроме того, именно с использованием output buffering становится очень простым реализация достаточно сложных вещей — например, экспорт данных в excel можно реализовать, написав буквально пару операторов (подсказка: excel умеет импортировать HTML, ну а как отрезать дизайн от экспортируемой таблицы вы, наверное, уже догадались).

Источник

Все о буферизации вывода в PHP

Что вы не узнаете из документации, момент с дырой в безопасности + советы о том, как ускорить отклик сервера.

Буферизация вывода позволяет вам сохранять выходные данные PHP (в основном генерируемые echo, var_dump, print_r) в памяти (т.е. в буфере) вместо немедленной передачи в браузер или терминал. Что полезно для самых разных задач:

Предотвращение вывода «на экран»:

Захватить вывод и записать в переменную: (Таким образом можно создавать кэш)

Функции ob_get_contents() и ob_end_clean() могут быть заменены одной функцией: ob_get_clean(), в ее имени больше нет «end» хотя фактически она отключает буферизацию вывода:

В приведенных выше примерах полученный буфер не был отправлен на выход. Если вы хотите отправить его, используйте ob_end_flush() вместо ob_end_clean().

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

Буфер так же может быть очищен в любое время не выключая его, используя функцию ob_clean() (очищает буфер) или ob_flush() (отправляет буфер на выход):

В буфер также отправляются выходные данные, записанные в выход php://output, буферизацию можно избежать, записав в php://stdout (или STDOUT), который доступен только в CLI, т.е. при запуске скриптов из командной строки.

Гнездование (вложенные буферы)

Буферы могут быть вложенными, поэтому, когда один буфер активен, другой ob_start() активирует новый буфер. Таким образом, ob_end_flush() и ob_flush() на самом деле отправляют буфер не на выход, а в родительский буфер. И только при отсутствии родительского буфера содержимое отправляется в браузер или терминал.

Поэтому важно отключить буферизацию, даже если происходит исключение:

Размер буфера (chunk_size)

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

Когда размер буфера превышает 4096 байт, PHP автоматически выполняет flush, т.е. буфер очищается и отправляется. То же самое может быть достигнуто установкой директивы output_buffering, которая игнорируется в CLI.

HTTP заголовки

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

Дыра в безопасности

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

Пользовательские обработчики

Вы можете установить свой собственный обработчик, т.е. функцию, которая будет обрабатывать содержимое буфера перед отправкой:

Этапы start, final и flush (так же clean) могут происходить одновременно. Это можно различить с помощью бинарного оператора &:

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

Источник

Как выключить буферизацию вывода php на сервере

При работе с прикладным программированием на php для WEB стоит задача не просто обработать какие данные и выдать результат в браузер пользователю, но и по возможностью сделать это максимально быстро и компактно. В этой статье рассмотрим то, как отключить буферизацию вывода php на сервере, если она включена, а для работы скриптов требуется, чтобы она была отключена.

Предупреждение Joomla о включенной буферизации вывода

При установке Joomla 3 на сервер можно заметить не полное совпадение с рекомендациями разработчиков с теми настройками, которые осуществлены на сервере:

Joomla 4 устанавливается с меньшим количеством информации, но и в итоге ругается в админке после установки на то, что буферизация php включена.

Буферизация вывода php: хорошо это или плохо?

Перед тем, как отключить буферизацию вывода php хорошо бы разобраться, хорошо это или плохо, вне зависимости от рекомендаций разработчиков тех или иных CMS’ок. Эти разработчики перестраховываются, рекомендуя то, что 100% обеспечит правильное исполнение их программ, а также того, что будет навешено поверх их стандартного функционала сторонними разработчиками в виде плагинов, модулей и прочих расширений.

Что же такое буферизация вывода php, на что и как она влияет?

И тут в действие вступает ещё один механизм, используемый при передачи данных по сети — сжатие данных. Если данные не накапливаются, то и сжимать собственно нечего — что прилетело на выходной порт сервера, то и должно быть отправлено. А вот если данные сперва были накоплены в буфер вывода, то их можно предварительно сжать и только после этого отправить.

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

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

Как отключить буферизацию вывода php на сервере в настройках php.ini

Более тонкие настройки буферизации:

Вы можете разрешить буферизацию вывода для всех файлов, установив эту директиву в ‘ On ‘. Если вы хотите ограничить размер буфера до определенного размера, вы можете установить не ‘On’, а максимальное количество байт в этой директиве (например, output_buffering=4096 ). Эта директива всегда отключена в PHP-CLI.

Выводы

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

Источник

PHP для начинающих. Буфер вывода // PHP

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

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

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

Вот теперь буду рассказывать о буферизации в PHP.

Пользовательский буфер вывода

Работа с буфером вывода начинается с функции ob_start() — у данной функции есть три опциональных параметра, но о них я расскажу чуть позже, а пока запоминаем — для включения буфера вывода используем функцию ob_start() :

Практически все нужные нам функции имеют префикс «ob_», как не трудно догадаться это сокращение от «output buffer»

Функцию ob_get_contents() можно вызывать множество раз, на практике с таким не сталкивался:

Если вы стартанули буфер вывода, но по какой-то причине не закрыли его, то PHP это сделает за вас и в конце работы скрипта выполнит «сброс» буфера вывода в браузер пользователя

Если внутри блока ob_start – ob_end вы отправляете заголовок, то он не попадает в буфер, а сразу будет отправлен в браузер:

В результате выполнения данного кода в http-пакете появятся следующие заголовки:

Естественно, данный код больше ничего не выводит, будет пустая страница.

Перед вами небольшой life-hack – в PHP вы можете использовать скобочки <> для выделения некой логики в блоки, при этом никакой функциональной нагрузки они не несут, а вот читаемость кода – повышают

Чуть-чуть прояснили ситуацию — теперь в копилке наших знаний есть информация о том, как включить буфер, как получить из него данные, и как выключить. Что ещё интересное можно с ним вытворять? Да с ним практически ничего толком и не сделать — его можно отправить (сбросить) в браузер (ключевое слово flush), очистить (clean), отключить (end). Ну и скомбинировать это всё до кучи тоже можно:

Для простого запоминания вот вам наглядная табличка по данному семейству функций:

Задание
Дополните приведенный ниже код вызовом одной функции, чтобы он корректно вывел «hello world»:

Обработчик буфера

В данном примере функция обработчик вернёт строку «Length of string ‘hello world’ is 11».

Важный момент — с этими функциями нужно быть поосторожней, обработали строки и ладненько, но не пытайтесь вывести либо сохранить данные, не пытайтесь стартовать другой буфер вывода внутри функции, и да есть функции которые создают буфер вывода внутри себя, вот print_r() и highlight_file() тому пример

Из стандартных же обработчиков можете повстречать ob_gzhandler(), но лучше сжатие страничек оставлять на плечах web-сервера, и не вешать это на PHP.

We need to go deeper©

У буфера вывода есть килер-фича – внутри буфера можно стартовать ещё один буфер, а внутри нового ещё и так далее (пока памяти хватает):

В данном примере функция ob_flush() и производные от неё, будут «выбрасывать» содержимое буфера на более высокий уровень.

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

Если вы не знаете точно на какой «глубине» находитесь – то воспользуйтесь функцией ob_get_level(), а чтобы «проснуться» вам пригодится следующий код:

Задание
Внесите изменения в код с вложенными вызовами ob_start() таким образом, чтобы цифры выводились в обратном порядке, для этого надо переставить три строчки кода.

Буфер «по умолчанию»

Запомните, для CLI приложений директива output_buffering всегда 0, т.е. данный буфер отключен

Зачем это всё?

Хороший вопрос — зачем нужна работа с буфером вывода? Приведу несколько основных сценариев использования:

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

Системный буфер вывода

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

Вот так всё просто и кратко, ну а теперь о нюансах управления системным буфером вывода…

Royal flush

10 секунд вашего внимания…

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

Сразу бросается в глаза вызов функции flush() — вызвав данную функцию вы даёте указание PHP «сбросить» системный буфер, т.е. отправить всё что там есть в браузер пользователю (но учтите, если у вас стартован пользовательский буфер, то для начала надо будет «сбросить» его, и уже потом вызвать flush() ). Т.е. происходящее можно описать как:

Задание

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

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

Рекомендованная литература

В заключение

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

Источник