Макеты страниц

13.22. Оператор require()

Принцип работы оператора require() подобен директиве препроцессора #include() в языке программирования C++. Если вы знакомы с этим языком, то освоить следующие операторы для вас не составит никакого труда, впрочем, даже если вы и не знакомы, мы постараемся более подробно описать принципы работы данных операторов. Оператор require() заменяет, вызывает содержимое файлов, путь и имя которого были указаны в блоке оператора:

require("path/filename.html");

Если параметры URL fopen_wrapper_SB PHP установлены как enabled (допустимо) (как правило, они - default (недостаточная), то вы можете также производить определение файла в операторе require(), используя URL (Uniform Resource Locator - унифицированный указатель ресурса) вместо того, чтобы использовать локальный путь к необходимому файлу в операторе require(). Например:

$url = http://my_new_adress/index.phtml;

Оператор require() не является функцией. Скорее всего его можно назвать конструкцией языка. Почему мы не можем считать этот оператор функцией:

Require() не подчинен к каким-либо управляющим структурам;

Require() не возвращает какое-либо значение, что в свою очередь делает функция.

Попытка вызова какого-либо значения из оператора require() приведет к ошибке и прерыванию дальнейшего выполнения программы.

В отличие от include require всегда производит чтение строки адреса файла, даже в том случае, когда он не выполняется. Если вам необходимо условно включить файл, используйте оператор include(). Просто условные выражения не считаются эффективными при работе с оператором require Однако если строка, на которой расположен оператор requre не будет выполнена, то тогда не будет выполнена ни одна строка кода в файле по этому адресу. Это логично, так как именно доступ к файлу в данном случае и осуществляется через оператор require().

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

Следовательно/вы не можете помещать оператор require() со всеми прилагающимися к нему инструкциями в блок оператора цикла и ожидать при работе того самого цикла различного выполнения данного оператора на каждой итерации. Чтобы воспользоваться этим, предлагаем вам применить оператор include().

Когда файл работает с оператором require(), содержащийся кбд наследует переменные возможности строки, на которой requre() выполняется. Любые переменные, доступные на этой строке, будут доступны в пределах вызванного файла. Если оператор require внутри функции в пределах вызывающего файла, то весь код, содержащийся в вызванном файле, будет вести себя так, гак если бы он был определен внутри этой

В том случае, если оператор require() работает с файлом, который вызван через HTTP и использует fopen wrappers, и если адрес станции интерпретирует конечный файл как PHP-код, то в этом случае переменные могут быть переданы в оператор require(), используя URL-запрос, как метод HTTP Get. Это не то же самое. что вызов файла оператора require так как скрипт практически продолжает выполнение сценария на удаленном сервере и результаты будут потом включены в локальный сценарий:

/* не будет работать, так как не был обработан сервером*/

require("http://my_domain_name/file.txt?varone=1&vartwo=2");

/* не работать, так как имя файла "file.php?varone=1&vartwo=2"

ориентировано на локальную файловую систему */

require("file.php?varone=1&vartwo=2");

/* будет работать без ошибок */

require("http://my_domain_name/test.php?varone=1Svartwo=2");

require("file.txt");

require("file.php");

Данные примеры помогут вам наглядно разобраться со способами применения оператора require(), а также не допустить ошибок при создании программ. Далее мы рассмотрим оператор include(), подобный оператору require(), и основные принципы его работы.

Операторы PHP: require(), require_once(), include_once()

Дата: 2012-10-15

Функции PHP: require(), require_once(), include(), include_once()

В прошлом уроке мы подробно разобрали работу . Напомню, что оператор include() в PHP подставляет содержание одной веб-страницы, в другую web-страницу. Но в PHP есть и другие функции, позволяющие реализовать аналогичную задачу. В частности это функции:

include_once()
require()
require_once()

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

include("file.php") или require("file.php")

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

Суффикс "_once " позволяет подключить код файла для подстановки в другой файл только один раз, сколько бы вызовов не осуществлялось. Для наглядности давайте разберем простой пример. В прошлом уроке мы разобрались, что с помощью оператора include() , можно вынести шапку сайта в отдельный файл header.php , для простоты будем считать, что в этот файл мы выносим графический логотип сайта. В нужном месте web-страницы (в данном случае на месте шапки сайта) прописываем код Листинга 1 .

Листинг 1.

То соответственно и логотип сайта тоже выведется два раза, примерно вот таким образом:

Согласитесь, смотрится не очень красиво, правда? Получается, что оператор include() два раза вытаскивает из папки blocks файл header.php и два раза подставляется его на место шапки сайта.

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

На больших сайтах очень легко запутаться, где и какой файл Вы включали и можно ли включить его повторно, а это может привести к ошибке. Поэтому придумали приставку "_once " к функциям include и require , которая включает содержание файла в другую web-страницу только один раз .

Чем функция include() отличается от require()

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

Давайте вернемся к предыдущему примеру код Листинга 1 . У нас есть следующий код:

Include ("blocks/header.php");

Давайте попробуем удалить файл header.php , который мы собственно и подключаем, например файл поврежден или случайно был удален с севера.

Обновляем тестовый файл и видим вот такую ошибку:

Как Вы видите, появилось сообщение о том, что в директории (папке) blocks не найден файл header.php , но программа дальше все равно выполняется и остальная часть web-страницы сайта отображается нормально.

А если мы напишем код (Листинг 3 ) используя функцию require() :

Листинга 3 .

Require ("blocks/header.php");

То у нас будет выведено только одно сообщение об ошибке , и программа дальше выполняться не будет , и Вы увидете только вот такое сообщение.

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

• include
• require
• include_once
• require_once

Все четыре инструкции могут принимать в качестве параметра имя локального файла. Инструкция include и require очень схожи по действию и отличаются лишь реакцией на невозможность получения запрошенного ресурса. Например, в случае недоступности ресурса include и include_once выводят предупреждение и пытаются продолжить исполнение программы. require и require_once при недоступности запрошенного ресурса останавливают обработку данной страницы.

include

Инструкция include позволяет подключать и присоединять к вашему PHP-сценарию другие сценарии. При запуске программы интерпретатор просто заменит инструкцию на содержимое подключаемого файла. Давайте посмотрим как это работает, создайте файл с именем add.php и напишите внутри:

Теперь создадим другой файл и назовем его к примеру test.php , в котором мы подключим файл add.php:

\$var2 = $var2" ?>

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

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

Подключение внутри функции

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

Теперь добавим функцию в test.php:

В глобальной области: $var1"; ?>

Так как внутри функции мы объявили переменную $var1 глобальной, она становится также доступной и в глобальной области видимости.

Путь к файлу

Файлы подключаются исходя из указанного пути к файлу, если путь не указан, будет использоваться путь, который указан в директиве include_path (в конфигурационном файле php.ini). Если файл не найден по указанному пути в include_path , инструкция include попытается проверить текущую рабочую директорию, в которой находится скрипт подключающий файл, если конструкция include не сможет найти файл, будет выдано предупреждение (warning).

Если путь указан - не важно какой: абсолютный или относительный (относительно текущей директории, где расположен включающий сценарий) - директива include_path будет проигнорирована.

include_once

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

В test.php попытаемся выполнить следующий код:

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

require и require_once

Инструкции require и require_once работают идентично include и include_once за исключением лишь одной особенности. Если подключаемый файл не будет найден, выполнение скрипта будет остановлено, в то время как include и include_once выводят предупреждение и продолжают выполнение скрипта.

Совет : постарайтесь совсем отказаться от использования include и require , применяйте их аналоги с суффиксом _once . Это упростит разбиение большой и сложной программы на относительно независимые модули.

29 ответов

Также есть require и include_once .

Так что ваш вопрос должен быть...

1. Когда мне следует использовать require и include ?
2. Когда я должен использовать require_once против require

Функция require() идентична include(), за исключением того, что обрабатывает ошибки по-разному. Если возникает ошибка, функция include() генерирует предупреждение, но скрипт продолжит выполнение. Require() генерирует фатальную ошибку, и скрипт останавливается.

Оператор require_once() идентичен require(), за исключением того, что PHP проверит, был ли файл уже включен, и, если это так, не будет включать (требовать) его снова.

Мое предложение состоит в том, чтобы просто использовать require_once 99,9% времени.

Использование require или include вместо этого подразумевает, что ваш код не может быть повторно использован в другом месте, то есть сценарии, которые вы набираете на самом деле выполнить , вместо того, чтобы предоставлять класс или некоторые библиотеки функций,

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

Если вы уже выполняете OO или функциональное программирование, использование include_once в основном будет задерживаться, когда в стеке вы найдете ошибки/ошибки. Вы хотите знать, что функция do_cool_stuff() недоступна, когда вы переходите к ее вызову позже, или в тот момент, когда вы ожидаете ее доступности , требуя библиотеки? Как правило, лучше знать сразу, если что-то вам нужно и чего ожидать, недоступно, поэтому просто используйте require_once .

В качестве альтернативы, в современных OOP, autoload ваши классы при использовании.

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

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

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

require() выкинет E_COMPILE_ERROR и остановит script, если он не может включить файл.

Функции include_once() и require_once() не будут включать файл во второй раз, если он уже был включен.

См. следующие страницы документации:

Всякий раз, когда вы используете require_once() , вы можете использовать в файле для включения другого файла, если вам нужен только что указанный файл в текущем файле. Здесь, в примере, у меня есть test1.php.

и в другом файле, который я назвал test2.php

когда вы смотрите m, требуя дважды файл test1, но файл будет включать тест1 один раз и для вызова во второй раз это будет проигнорировано. И без остановки будет отображать вывод один раз.

Всякий раз, когда вы используете "include_once() `, можно использовать в файле для включения другого файла, если вам нужен вызывается файл более одного раза в текущем файле. Здесь, в примере, у меня есть файл с именем test3.php.

И в другом файле, который я назвал test4.php

поскольку вы смотрите m, включая файл test3, будет включать файл один раз, но прекратите дальнейшее выполнение.

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

require() идентичен include() , за исключением отказа, он также приведет к фатальной ошибке уровня E_ERROR .

include генерирует ошибку E_WARNING , если она терпит неудачу, которая более или менее тихая.

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

Для *_once() :

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

То же самое относится к require_once() , конечно.

Этот вопрос задавали семь лет назад, и ни один из ответов не дает практической помощи в этом вопросе. В современном PHP-программировании вы в основном используете required_once только один раз, чтобы включить свой автозагрузчик (часто автозагрузчик композитора), и он будет загружать все ваши классы и функции (файлы функций должны быть явно добавлены в файл composer.json чтобы быть доступным во всех другие файлы). Если по какой-либо причине ваш класс не загружается с автозагрузчика, вы используете require_once для его загрузки.

В наши дни вам require только разделить большой фрагмент файла PHP. Это в основном определение большого массива. В таких случаях вы используете только require require_once .

"y"];

Если файл, который вы собираетесь использовать содержит что - то исполняемый или объявляет некоторые переменные, которые почти все время нужно использовать require , потому что если вы используете require_once в другом месте ваш код не будет выполняться, и/или ваши переменные не будут инициировать молча, вызывая ошибки которые абсолютно трудно определить.

Практически не используется практика include и include_once .

Вы должны хранить определения классов и функций в файлах.

Используйте require_once() для загрузки зависимостей

Используйте require() для загрузки шаблоноподобных файлов .

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

Используйте include() для загрузки необязательных шаблоноподобных файлов .

требуется приведет к фатальной ошибке (E_COMPILE_ERROR) и остановит script.

включить будет выдавать предупреждение (E_WARNING), а script будет продолжаться.

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

Если a.php является PHP script, вызывающим b.php с требованием require_once(), и не находит b.php, a.php прекращает выполнение, вызывая фатальную ошибку.

включают в себя()

Он содержит указанный файл. Он выдаст предупреждение, если не сможет найти файл и выполнить остальные скрипты

требуется()

Он содержит указанный файл. Это приведет к фатальной ошибке, если он не сможет найти файл и прекратит выполнение

Он содержит указанный файл. файл уже включен, он больше не будет включен. Он выдает предупреждение, если он не сможет найти файл и выполнить остальные скрипты.

Он содержит указанный файл. файл уже включен, он больше не будет включен. Это приведет к фатальной ошибке, если он не сможет найти файл и прекратит выполнение.

идентичен include/require, за исключением того, что PHP проверяет, был ли файл уже включен, и если это так, не включайте его (требуется) снова.

В эпоху автозагрузчиков PSR-0/PSR-4 может оказаться совершенно ненужным использовать какие-либо операторы, если все, что вам нужно, - это сделать некоторые функции/классы доступными для вашего кода (конечно, вам все еще нужно использовать require_once в вашем файле начальной загрузки и include шаблоны, если вы все еще используете PHP в качестве движка шаблонов).

require() идентичен include() , за исключением отказа, он также приведет к фатальной ошибке уровня E_COMPILE_ERROR . Другими словами, он остановит script, тогда как include() только выдает предупреждение (E_WARNING), которое позволяет script продолжить.

То же самое верно для вариантов _once() .

Я использовал функцию, как показано ниже:

Function doSomething() { require_once(xyz.php); .... }

В xyz.php были зафиксированы постоянные значения.

Мне нужно вызвать эту функцию doSomething() из другого файла PHP script.

Но я наблюдал поведение при вызове этой функции в цикле, для первой итерации doSomething() получал постоянные значения внутри xyz.php , но позже каждая итерация doSomething() не могла получить постоянные значения, объявленные в xyz.php .

Я решил свою проблему, переключившись с require_once() на include() , обновленный код doSomething() выглядит следующим образом:

Function doSomething() { include(xyz.php); .... }

Теперь каждый итерационный вызов doSomething() получает константы, определенные в xyz.php .

Когда следует использовать require или include ?

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

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

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

Когда следует использовать require_once или require ?

Основное различие между require и require_once равно require_once , будет проверять, включен ли файл или нет, если он уже включен, тогда он не будет включать файл, тогда как функция require будет включать в себя файл независимо от того, включен ли файл или нет.

Итак, в тех случаях, когда вы хотите снова добавить часть кода снова и снова, используйте функцию require , тогда как если вы хотите включить какой-то код только один раз в свой код, используйте require_once .

Это все способы включения файлов.

Требовать означает, что это нужно. Require_once означает, что это потребуется, но требуется только один раз. Включить означает, что он будет включать файл, но для продолжения он не нужен.

Require "filename" Require_once "filename" Include "filename"

Существует также функция include_once, которая включает файл один раз.

Include_once "filename"

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

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

Из английского слова требуется, PHP говорит, что выполнение страницы или файла зависит от требуемого файла.

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

оператор . Включение может производиться любым из перечисленных способов:

include "имя_файла"; include $file_name; include ("имя_файла");

Пример 3.9 . Пусть в файле params.inc у нас хранится набор каких-то параметров и функций. Каждый раз, когда нам нужно будет использовать эти параметры (функции), мы будем вставлять в текст нашей основной программы команду include ("params.inc") .

Params.inc include.php "; // выведет "Привет, Вася!" echo "Сегодня $today"; // выведет, например, "Сегодня 7.07.05" ?> Пример 3.9. Использование оператора включения include

Заметим, что использование оператора include эквивалентно простой вставке содержательной части файла params.inc в код программы include.php . Может быть, тогда можно было в params.inc записать простой текст без всяких тегов, указывающих на то, что это php-код? Нельзя! Дело в том, что в момент вставки файла происходит переключение из режима обработки PHP в режим HTML. Поэтому код внутри включаемого файла, который нужно обработать как PHP-скрипт , должен быть заключен в соответствующие теги.

Поиск файла для вставки происходит по следующим правилам.

1. Сначала ведется поиск файла в include_path относительно текущей рабочей директории.
2. Если файл не найден, то поиск производится в include_path относительно директории текущего скрипта.
3. Параметр include_path , определяемый в файле настроек PHP, задает имена директорий, в которых нужно искать включаемые файлы .

Например, ваш include_path это . (то есть текущая директория ), текущая рабочая директория это /www/ . В основной файл include.php вы включаете файл my_dir/a.php , который в свою очередь включает b.php . Тогда парсер первым делом ищет файл b.php в директории /www/ , и если такового нет, то в директории /www/my_dir/ .

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

Пример 3.10 . Пусть файл для вставки params.inc останется таким же, а include.php будет следующим:

"; $str .= "Страницу создал $user"; echo "$str"; } Footer(); // вызываем функцию Footer(). Получим: //Сегодня: 08.07.05 //Страницу создал Вася echo "$user, $today"; // выведет запятую, так как // эти переменные видны только // внутри функции?> Пример 3.10. Область видимости при использовани include

Кроме локальных файлов, с помощью include можно включать и внешние файлы, указывая их url-адреса. Данная возможность контролируется директивой url_fopen_wrappers в файле настроек PHP и по умолчанию, как правило, включена. Но в версиях PHP для Windows до PHP 4.3.0 эта возможность не поддерживается совсем, вне зависимости от url_fopen_wrappers .

include() – это специальная языковая конструкция, поэтому при использовании внутри условных блоков ее нужно заключать в фигурные скобки.

Пример 3.11. Использование include()

При использовании include возможны два вида ошибок – ошибка вставки (например, нельзя найти указанный файл, неверно написана сама команда вставки и т.п.) или ошибка исполнения (если ошибка содержится во вставляемом файле). В любом случае при ошибке в команде