Чтобы сделать программный код более удобочитаемым, вы можете к примеру поместить определения функций и/или классов в отдельный файл. Возможность подключения файлов в 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 говорит, что выполнение страницы или файла зависит от требуемого файла.

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

Как вы знаете, в PHP имеется 4 функции для подключения других файлов. Это include , include_once , require и require_once . Чем же они различаются и как правильно их использовать?

Для начала разберём разницу между include и require . Эти две функции различаются только реакцией на отсутствие подключаемого файла. Функция include («включить») при отсутствии указанного файла выдаст сообщение об ошибке типа E_WARNING, но выполнение программы продолжится. В отличие от неё, require («требовать») при отсутствии подключаемого файла выдаёт фатальную ошибку (E_ERROR), которая приводит к немедленной остановке выполняемого скрипта.

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

Теперь рассмотрим конструкции include_once и require_once . От простых include и require они отличаются окончанием «_once», которое предотвращает повторное подключение тех же самых файлов.

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

В своей практике я использую два вида файлов. Первый вид — это файлы, содержащие один или несколько классов и не содержащие кода, исполняемого «напрямую». Такие файлы всегда подключаю с помощью require_once . Второй вид — это шаблоны или куски шаблонов, содержащие HTML и немного PHP-кода. Такие файлы подключаю с помощью require , поскольку иногда один и тот же кусок шаблона может быть использован на странице несколько раз.

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

Существует ещё одна фишка при использовании include. Несмотря на то, что на самом деле это не функция, а языковая конструкция, внутри подключаемого файла работает оператор return . И, стало быть, include возвращает это значение вызываемому коду. Это выглядит вот так

$ret = include ‘file.php’;

На сегодня это всё, программируйте правильно!

Одна из самых занимательных и полезных возможностей php - подключение другого файла. Например, на сайте есть верхнее меню, нижнее и между ними само содержание страницы. И, например, на 10 страницах сайта используется нижнее меню. В какой-то момент в него потребовалось внести изменения. В html Вы бы вручную в каждом отдельном файле вносили изменения, но php позволяет существенно упростить работу с сайтом! Код нижнего меню может содержаться в отдельном файле, а на каждой из 10-ти страниц можно просто подключать этот отдельный файл! То есть все изменения нужно теперь вносить только в файл с меню, а на 10-ти других оно будет отображаться уже с изменениями.

Смысл подключения в php простым русским языком:

Файл 1.php
Верхнее меню

Файл 2.php
Нижнее меню

Файл example.php
Подкючаем Файл 1.php
Содержание страницы
Подкючаем Файл 2.php

В результате проработки файла example.php будет отображено
Верхнее меню
Содержание страницы
Нижнее меню
Соответственно, чтобы что-либо изменить в нижнем меню, нужно внести изменения только в файле 2.php

Путь к файлу

Подключение файла происходит согласно указанному к файлу пути. Есть два варианта пути: относительный и абсолютный. Относительный - это указание пути к подлючаемому файлу относительно файла с инструкцией подключения. Абсолютный - указание полного пути к подключаемому файла.

Код PHP

// пример относительного пути
include "include/ваш_файл.php"; // файл лежит в папке include, которая находится в той же директории, что и файл с подключением

// пример абсолютного пути
include $_SERVER["DOCUMENT_ROOT"]."/include/ваш_файл.php"; // $_SERVER["DOCUMENT_ROOT"] - указывает корневую директорию сайта

include и include_once

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

Рассмотрим работу include на примере двух файлов: index.php и text.php . Для простоты работы допустим, что они лежат в одной директории.

Код PHP (файл index.php )

Echo "Обычный текст, содержащийся в основном файле";
include "text.php"; // подключаем содержимое файла text.php

?>
Код PHP (файл text.php )

Echo "Текст, содержащийся в подключаемом файле";

?>
В результате работы файла index.php отобразится:

Обычный текст, содержащийся в основном файле
Текст, содержащийся в подключаемом файле
Правда удобно? Теперь, поменяв содержимое в файле text.php будет совершенно другой результат работы index.php!

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

Код PHP

Include_once "text.php"; // файл text.php будет подключен только один раз

// повторное подключения ниже не будет учтено и отображено
// и из-за него не будет выведено сообщение об ошибке
include_once "text.php"; // ничего не произойдёт

require и require_once

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

Если не работает include или require

Чтобы понять причины того, почему не работает include, предлагаю проверить всё по шагам. Какими бы понятными и поверхностными не были указанные ниже пункты, проверьте всё с самого начала

1. Проверьте, работает ли Ваш сервер и php, работает ли вообще любой php код на сайте
2. Убедитесь, существует ли файл подключаемый файл
3. Проверьте, правильно ли введено название файла и расширение в подключении
4. Убедитесь, что подключаемый php-файл действительно находится по тому адресу, по которому указали
5. Попробуйте указать не относительный путь, а абсолютный (полный путь к файлу).

Пример Код PHP

Include "http://www.example.com/include/ваш_файл.php";

// DOCUMENT_ROOT - обозначает корневую директорию ресурса
include $_SERVER["DOCUMENT_ROOT"]."/include/ваш_файл.php";

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

Php_flag display_errors On
или в файле php , перед подключением, вставьте следующую строку

Error_reporting(E_ALL);
И та, и другая настройки будут принудительно отображать ошибки

Конструкция включений require

Конструкция require позволяет включать файлы в PHP сценарий выполнения сценария PHP. Общий синтаксис require такой:

require имя_файла;

При запуске (именно при запуске, а не при исполнении!) программы интерпретатор просто заменит инструкцию на содержимое файла имя_файла (этот файл может также содержать сценарий на PHP, обрамленный, как обычно, тэгами и ?> ). Причем сделает он это непосредственно перед запуском программы (в отличие от include , который рассматривается ниже). Это бывает довольно удобно для включения в вывод сценария различных шаблонных страниц HTML-кодом. Приведем пример:

Файл header.html:

Файл footer.html:
Home Company, 2005.

Файл script.php
require "header.htm";
// Сценарий выводит само тело документа
require "footer.htm";
?>

Таким образом, конструкция require позволяет собирать сценарии PHP из нескольких отдельных файлов, которые могут быть как html -страницами, так и php -скриптами.

Конструкция require поддерживает включения удаленных файлов (начиная с версии PHP 4.3.0). Например:

// Следующий пример на работает, поскольку пытается включить локальный файл
require "file.php?foo=1&bar=2" ;
// Следующий пример работает
require ;
?>

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

Включения удаленных файлов

PHP позволяет работать с объектами URL, как с обычными файлами. Упаковщики, доступные по умолчанию, служат для работы с удаленными файлами с использованием протокола ftp или http.

Если "URL fopen-оболочки " включены в PHP (как в конфигурации по умолчанию), вы можете специфицировать файл, подключаемый с использованием URL (через HTTP), вместо локального пути. Если целевой сервер интерпретирует целевой файл как PHP-код, переменные могут передаваться в подключаемый файл с использованием URL-строки запроса, как в HTTP GET. Строго говоря, это не то же самое, что подключение файла и наследование им области видимости переменных родительского файла; ведь скрипт работает на удалённом сервере, а результат затем подключается в локальный скрипт.

Для того, чтобы удаленное включение файлов было доступно, необходимо в конфигурационном файле (php.ini) установить allow_url_fopen=1.

Обратите внимание : Версии PHP для Windows до PHP 4.3.0 не поддерживают возможность использования удаленных файлов этой функцией даже в том случае, если опция allow_url_fopen включена.

/* Здесь предполагается, что www.example.com сконфигурирован для разбора.php
* файлов, а не.txt файлов. Также "Works" здесь означает, что переменные
* $foo и $bar доступны в подключённом файле. */

// Не будет работать, так как file.txt не обрабатывается www.example.com как PHP
require "http://www.example.com/file.txt?foo=1&bar=2" ;

// Не будет работать, поскольку ищет файл "file.php?foo=1&bar=2" в локальной
// файловой системе.
require "file.php?foo=1&bar=2" ;

// Следующий пример работает:
require "http://www.example.com/file.php?foo=1&bar=2" ;

$ foo = 1 ;
$ bar = 2 ;
require "file.txt" ; // Работает
require "file.php" ; // Работает

?>