В PHP:
require
vs. include
?require_once
vs. include_once
?Есть require
и include_once
.
Итак, ваш вопрос должен быть...
require
vs. include
?require_once
vs. require
Ответ на 1 описывается здесь.
Функция require() идентична функции include(), за исключением того, что она обрабатывает ошибки по-разному. Если возникает ошибка, функция include() генерирует предупреждение, но script продолжит выполнение. Требование() генерирует фатальную ошибку, а script останавливается.
Ответ на 2 можно найти здесь.
Оператор require_once() идентичен требованию(), за исключением того, что PHP проверяет, был ли файл уже включен, и если да, не включайте его снова.
Использование
require
когда файл требуется вашему приложению, например. важный шаблон сообщения или файл, содержащий переменные конфигурации, без которых приложение будет ломаться.
require_once
когда файл содержит контент, который приведет к ошибке при последующем включении, например.
function important() { /* important code */}
определенно необходим в вашем приложении, но поскольку функции не могут быть повторно записаны, не следует снова включать.
include
когда файл не требуется, и поток приложений должен продолжаться, если не найден, например,
отлично подходит для шаблонов, ссылающихся на переменные из текущей области или чего-то.
include_once
необязательные зависимости, которые могут приводить к ошибкам при последующей загрузке или, возможно, удаленному включению файлов, которые вы не хотите выполнять дважды из-за служебных сообщений HTTP
Но в основном, это зависит от вас, когда использовать.
include
? include_once
? require
? require_once
?
Мое предложение состоит в том, чтобы просто использовать require_once
99,9% времени.
Использование require
или include
вместо этого подразумевает, что ваш код не может быть повторно использован в другом месте, то есть сценарии, которые вы набираете на самом деле выполнить, вместо того, чтобы предоставлять класс или некоторые библиотеки функций,
Если вам требуется/включая код, который выполняется на месте, этот процедурный код, и вам нужно узнать новую парадигму. Подобно объектно-ориентированному программированию, функциональному программированию или функциональному программированию.
Если вы уже выполняете OO или функциональное программирование, использование include_once
в основном будет задерживаться, когда в стеке вы найдете ошибки/ошибки. Вы хотите знать, что функция do_cool_stuff()
недоступна, когда вы переходите к ее вызову позже, или в тот момент, когда вы ожидаете ее доступности, требуя библиотеки? Как правило, лучше знать сразу, если что-то вам нужно и чего ожидать, недоступно, поэтому просто используйте require_once
.
В качестве альтернативы, в современных OOP, autoload ваши классы при использовании.
include
как правило, является совершенно плохой идеей (поскольку довольно редко включаются файлы, которые могут вообще отсутствовать), и что из require_once
и require
вы должны использовать require_once
при включении файлов, которые определяют функции или классы, которые будут использоваться в другом месте, или создавать экземпляры синглетонов, такие как объекты соединения с базой данных, и использовать require
для включения файлов, которые немедленно делают вещи, когда их включают. В любом большом веб-приложении последний тип включения необычен.
require_once
является наиболее вероятным кандидатом для использования почти все время. Учитывая незначительные накладные различия между вариантами выбора, require
обеспечения остановки сценария, я не могу представить себе множество сценариев, в которых приложение может выжить без включения файла. И _once
защищает от _once
вопросов. Любой, кто не согласен, вероятно, знает, что он делает, и может выбрать тот, который подходит для приложения или сценария.
Разница между функциями _once и функциями _once: без кода _once будет включен снова, тогда как с функциями _once PHP отслеживает включенные файлы и будет включать его только один раз.
Разница между требованием и включением: Если требуемый файл не найден, PHP будет генерировать фатальную ошибку, тогда как для включения будет выведено только предупреждение.
include()
выдаст предупреждение, если он не может включить файл, но остальная часть script будет запущена.
require()
выкинет E_COMPILE_ERROR
и остановит script, если он не может включить файл.
Функции include_once()
и require_once()
не будут включать файл во второй раз, если он уже был включен.
См. следующие страницы документации:
Всякий раз, когда вы используете require_once()
, вы можете использовать в файле для включения другого файла, если вам нужен только что указанный файл в текущем файле.
Здесь, в примере, у меня есть test1.php.
<?php
echo "today is:".date("Y-m-d");
?>
и в другом файле, который я назвал test2.php
<?php
require_once('test1.php');
require_once('test1.php');
?>
когда вы смотрите m, требуя дважды файл test1, но файл будет включать тест1 один раз и для вызова во второй раз это будет проигнорировано. И без остановки будет отображать вывод один раз.
Всякий раз, когда вы используете 'include_once() `, можно использовать в файле для включения другого файла, если вам нужен вызывается файл более одного раза в текущем файле. Здесь, в примере, у меня есть файл с именем test3.php.
<?php
echo "today is:".date("Y-m-d");
?>
И в другом файле, который я назвал test4.php
<?php
include_once('test3.php');
include_once('test3.php');
?>
поскольку вы смотрите m, включая файл test3, будет включать файл один раз, но прекратите дальнейшее выполнение.
Используйте "include" для шаблонов PHP. Используйте "require" для требуемых библиотек.
"* _ once" хорошо, потому что он проверяет, загружен ли файл или нет, но это имеет смысл только для меня в "require_once".
Разница заключается в ошибке, которую генерируют команды. С require
действительно нужен файл, который вы хотите использовать, и таким образом генерирует E_ERROR
, если он не найден.
require()
идентиченinclude()
, за исключением отказа, он также приведет к фатальной ошибке уровняE_ERROR
.
include
генерирует ошибку E_WARNING
, если она терпит неудачу, которая более или менее тихая.
Так что используйте его, если файл необходим для работы оставшегося кода, и вы хотите, чтобы script завершился неудачей, файл недоступен.
Для *_once()
:
include_once()
может использоваться в случаях, когда один и тот же файл может быть включен и оценен более одного раза в течение конкретного выполнения script, поэтому в этом случае он может помочь избежать таких проблем, как переопределение функций, переопределение переменных значений, и т.д.
То же самое относится к require_once()
, конечно.
Ссылка: require()
, include_once()
require
дает E_COMPILE_ERROR, а не E_ERROR.
требуется приведет к фатальной ошибке (E_COMPILE_ERROR) и остановит script.
включить будет выдавать предупреждение (E_WARNING), а script будет продолжаться.
Оператор require_once может использоваться для включения файла PHP в другой, когда вам может потребоваться включить вызываемый файл более одного раза.
Если a.php является PHP script, вызывающим b.php с требованием require_once(), и не находит b.php, a.php прекращает выполнение, вызывая фатальную ошибку.
С требованием, чтобы файл существовал, если он не отображается, будет отображаться ошибка; тогда как include - если файл не существует, тогда страница будет продолжать загружаться.
Этот вопрос задавали семь лет назад, и ни один из ответов не дает практической помощи в этом вопросе. В современном PHP-программировании вы в основном используете required_once
только один раз, чтобы включить свой автозагрузчик (часто автозагрузчик композитора), и он будет загружать все ваши классы и функции (файлы функций должны быть явно добавлены в файл composer.json
чтобы быть доступным во всех другие файлы). Если по какой-либо причине ваш класс не загружается с автозагрузчика, вы используете require_once
для его загрузки.
В наши дни вам require
только разделить большой фрагмент файла PHP. Это в основном определение большого массива. В таких случаях вы используете только require
require_once
.
<?php
// arr.php
return ['x'=>'y'];
<?php
//main.php
$arr= require 'arry.php'
Если файл, который вы собираетесь использовать содержит что - то исполняемый или объявляет некоторые переменные, которые почти все время нужно использовать require
, потому что если вы используете require_once
в другом месте ваш код не будет выполняться, и/или ваши переменные не будут инициировать молча, вызывая ошибки которые абсолютно трудно определить.
Практически не используется практика include
и include_once
.
include()
, обернутый в выходной буфер для реализации вашего движка шаблонов.
require()
для разделения больших файлов.
Требовать критические части, такие как авторизация, и включать все остальные.
Несколько включений - это очень плохой дизайн, и его следует избегать вообще. Итак, * _once не имеет большого значения.
включают в себя()
Он содержит указанный файл. Он выдаст предупреждение, если не сможет найти файл и выполнить остальные скрипты
требуется()
Он содержит указанный файл. Это приведет к фатальной ошибке, если он не сможет найти файл и прекратит выполнение
include_once()
Он содержит указанный файл. файл уже включен, он больше не будет включен. Он выдает предупреждение, если он не сможет найти файл и выполнить остальные скрипты.
require_once()
Он содержит указанный файл. файл уже включен, он больше не будет включен. Это приведет к фатальной ошибке, если он не сможет найти файл и прекратит выполнение.
Вы должны сохранять описания классов и функций в файлах.
Используйте require_once для загрузки зависимостей (классы, функции, константы).
Используйте для загрузки шаблонных файлов.
Include/Require вы можете кроме того, один и тот же файл:
require() идентичен include(), за исключением отказа, он также приведет к фатальной ошибке уровня E_COMPILE_ERROR. Другими словами, он остановит script, тогда как include() только выдает предупреждение (E_WARNING), которое позволяет script продолжить.
идентичен include/require, за исключением того, что PHP проверяет, был ли файл уже включен, и если это так, не включайте его (требуется) снова.
include()
будет генерировать предупреждение, когда он не найдет файл, но require_once()
создаст фатальную ошибку.
Другое дело, если файл включен раньше. Тогда require_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()
, за исключением отказа, он также приведет к фатальной ошибке уровняE_COMPILE_ERROR
. Другими словами, он остановит script, тогда какinclude()
только выдает предупреждение (E_WARNING
), которое позволяет script продолжить.
То же самое верно для вариантов _once()
.
В эпоху автозагрузчиков PSR-0/PSR-4
может оказаться совершенно ненужным использовать какие-либо операторы, если все, что вам нужно, - это сделать некоторые функции/классы доступными для вашего кода (конечно, вам все еще нужно использовать require_once
в вашем файле начальной загрузки и include
шаблоны, если вы все еще используете 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, когда вам нужно загрузить любой класс, функцию или зависимость.
Используйте включить функцию, когда вы хотите загрузить файл в стиле шаблона
Если вы все еще запутались, просто используйте require_once на все время.
Короче:
include: включает файл и оценивает его. PHP выдаст предупреждение, если файл не найден или не может быть прочитан.
include_once: если вы укажете include_once, тогда PHP сделает так, чтобы он включал файл только один раз.
Требуется: PHP будет включать файл и оценивать его. Если файл не найден или не может быть прочитан, то будет сгенерирована фатальная ошибка.
require_once: Что касается include_once, но вместо предупреждения будет сгенерирована фатальная ошибка.
Причина, по которой все время не используются include_once() и require_once(), связана с производительностью. PHP отслеживает список файлов, которые были включены для поддержки функциональности этих функций. Это требует памяти, поэтому эти функции скорее используются, когда они необходимы, а не в пользу включения или необходимости.
На другой день меня спросили, в чем разница между include и require на PHP. Они, похоже, функционируют одинаково, но есть существенная разница.
Во-первых, ни включать, ни требовать не являются функциями, они являются конструкциями. Поэтому нет необходимости вызывать их с помощью круглых скобок, таких как include ('file.php'); вместо этого рекомендуется использовать include 'file.php'.
Разница между include и require возникает, когда файл, который был включен, не может быть найден: include будет выдавать предупреждение (E_WARNING), и сценарий будет продолжен, тогда как require будет генерировать фатальную ошибку (E_COMPILE_ERROR) и остановить скрипт. Если файл включен, критический для остальной части скрипта работает правильно, то вам нужно использовать require.
Вы должны подобрать любые фатальные ошибки, вызванные необходимостью во время процесса разработки, и иметь возможность разрешать их, прежде чем выпустить скрипт в дикую природу; однако вы можете рассмотреть возможность использования include для установки плана B, если это не так прямолинейно:
<?php
if (@include 'file.php') {
// Plan A
} else {
// Plan B - for when 'file.php' cannot be included
}
В этом примере include используется для захвата файла file.php, но если это не удается, мы сжимаем предупреждение с помощью @и выполняем альтернативный код. include вернет false, если файл не найден.
include_once и require_once ведут себя как include и требуют соответственно, за исключением того, что они будут включать только файл, если он еще не был включен. В противном случае они выдают такие же ошибки.
Это все способы включения файлов.
Требовать означает, что это нужно. Require_once означает, что это потребуется, но требуется только один раз. Включить означает, что он будет включать файл, но для продолжения он не нужен.
Примеры:
Require 'filename'
Require_once 'filename'
Include 'filename'
Существует также функция include_once, которая включает файл один раз.
Include_once 'filename'
Не используйте заглавные буквы там, где я пишу с телефона.
В принципе, если вам нужен неправильный путь, PHP выдает фатальную ошибку и вызывается функция выключения, но когда вы включаете неправильный путь, PHP продолжит выполнение, но он просто покажет предупреждение о том, что файл не существует.
Из английского слова требуется, PHP говорит, что выполнение страницы или файла зависит от требуемого файла.
По моему опыту, это норма, требующая важных файлов, таких как файлы конфигурации, классы баз данных и другие важные утилиты.
require
имеет большие накладные расходы, чем include
, так как он должен сначала проанализировать файл. Замена requires
на includes
часто является хорошей методикой оптимизации.
require
не анализирует файл больше, чем include
. _once
версия этих функций имеет свои издержки, но, как говорили другие, в большинстве приложений она практически ничтожна.
Просто используйте require и include.
Потому что думайте, как работать с include_once или require_once. Это поиск данных журнала, которые сохраняют включенные или требуемые файлы PHP. Так что это медленнее, чем включать и требовать.
if (!defined(php)) {
include 'php';
define(php, 1);
}
Просто используя вот так...
include_once
: php.net/manual/en/function.include-once.php