В чем разница между require, include, require_once и include_once?

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

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

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

Ответ на 1 описан здесь.

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

Ответ на 2 можно найти здесь.

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

Использовать

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

• require_once
  когда файл содержит контент, который может вызвать ошибку последующее включение, например function important() { /* important code */} определенно необходим в вашем приложении, но, поскольку функции не могут быть повторно объявлены, не следует включать их снова.

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

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

Но в основном вам решать, когда использовать.

Я предлагаю просто использовать require_once 99,9% времени.

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

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

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

В качестве альтернативы, в современном ООП просто автозагрузите свои классы при использовании.

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

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

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

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

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

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

• включить
• требуется
• 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 дважды, но файл будет включать test1 один раз, а для вызова во второй раз это будет проигнорировано. И без остановки выводит на экран только один раз.

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

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

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

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

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

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

Ответ через 7 лет на 2018 год

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

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

 <?php
// arr.php
return ['x'=>'y'];

 <?php
//main.php
$arr= require 'arry.php'

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

На самом деле, практического использования include и include_once не существует.

Используйте "include" для многоразовых шаблонов PHP. Используйте "require" для необходимых библиотек.

"* _once" хорош, потому что он проверяет, загружен ли файл уже или нет, но для меня это имеет смысл только в "require_once".

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

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

include генерирует ошибку E_WARNING только в случае отказа, что более или менее тихо.

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

Для *_once():

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

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

Ссылка: require(), _ 12_

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

Требовать критически важных частей, таких как авторизация, и включать все остальные.

Множественные включения - это просто очень плохой дизайн, и их следует вообще избегать. Итак, * _once на самом деле не имеет значения.

Включить / Требовать вы также можете включить один и тот же файл более одного раза:

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

require_once / include_once < / а>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   Из руководства:

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

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

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

Другое дело, если файл включен раньше. Тогда require_once() не будет включать его снова.

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

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

1. Используйте функцию include, если хотите загрузить файл в стиле шаблона.

2. Если вы все еще не уверены, всегда используйте require_once.

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

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

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

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

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

Примеры:

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

Require 'filename'
Require_once 'filename'
Include 'filename'

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

Include_once 'filename'

Одна вещь, которую я заметил, при использовании include я могу получить доступ к функциям включенных файлов только из файла, который их включил. С помощью require_once я могу запустить эту функцию во втором файле required_once.

также: рекомендую добавить

Потому что, когда require_once убивает страницу, он иногда может отображать каталог файлов вашего веб-сайта.

if(file_exists($RequiredFile)){
    require_once($RequiredFile);
}else{
  die('Error: File Does Not Exist');
}

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

пример использования:

function addFile($file, $type = 'php', $important=false){
    //site-content is a directory where I store all the files that I plan to require_once
    //the site-content directory has "deny from all" in its .htaccess file to block direct connections
    if($type && file_exists('site-content/'.$file.'.'.$type) && !is_dir('site-content/'.$file.'.'.$type)){
        //!is_dir checks that the file is not a folder
        require_once('site-content/'.$file.'.'.$type);
        return 'site-content/'.$file.'.'.$type;
    }else if(!$type && file_exists('site-content/'.$file) && !is_dir('site-content/'.$file)){
        //if you set "$type=false" you can add the file type (.php, .ect) to the end of the "$file" (useful for requiring files named after changing vars)
        require_once('site-content/'.$file);
        return 'site-content/'.$file;
    }else if($important){
        //if you set $important to true, the function will kill the page (which also prevents accidentally echoing the main directory path of the server)
        die('Server Error: Files Missing');
        return false;
    }else{
        //the function returns false if the file does not exist, so you can check if your functions were successfully added
        return false;
    }
}

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

$success = addFile('functions/common');

if($success){
    commonFunction();
}else{
    fallbackFunction();
}

Вот конкретный пример; уточняя то, что сказал pcj.

Скажем, у вас есть файл конфигурации, в котором хранятся имя пользователя и пароль вашей базы данных (conf.php):

И класс со статической функцией, использующей базу данных:

<?php
//my site configuration file

//For Database
$location='localhost';
$dbuser='yourname';
$userpw='yourpassword';
$database='nameofdatabase';
?>

И эта статическая функция используется внутри другой функции, которая вызывается итеративно внутри цикла:

<?php
class UsedInLoop {
    public static function databaseQuery(){
        require(/path/to/conf.php);                //require_once will not work here
        $db = new mysqli($location, $dbuser, $userpw, $database);
        //yada yada yada
    }
}
?>

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

<?php
require_once('path/to/arbitraryObject.php');  //either will likely be OK at this level
$obj = new arbitraryObject();
foreach($array as $element){
    $obj->myFunction();
}
?>

Конечно, перемещение его за пределы функции могло бы быть решением этой проблемы:

<?php
class arbitraryObject {
    public function myFunction(){
        require_once(/path/to/UsedInLoop.php);   //This must be require_once. require() will not work
        UsedInLoop::databaseQuery();
    }
}
?>

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

<?php
require(/path/to/UsedInLoop.php);   //now require() is fine   
class arbitraryObject {
    public function myFunction(){
        UsedInLoop::databaseQuery();
    }
}
?>

У

<?php
//my site configuration file

//For Database
$location='localhost';
$dbuser='yourname';
$userpw='yourpassword';
$database='nameofdatabase';
?>

<?php
class UsedInLoop {
    public static function databaseQuery(){
        require(/path/to/conf.php);                //require_once will not work here
        $db = new mysqli($location, $dbuser, $userpw, $database);
        //yada yada yada
    }
}
?>

<?php
require_once('path/to/arbitraryObject.php');  //either will likely be OK at this level
$obj = new arbitraryObject();
foreach($array as $element){
    $obj->myFunction();
}
?>

<?php
class arbitraryObject {
    public function myFunction(){
        require_once(/path/to/UsedInLoop.php);   //This must be require_once. require() will not work
        UsedInLoop::databaseQuery();
    }
}
?>

Просто используйте require и include.

Потому что подумайте, как работать с include_once или require_once. Это ищет данные журнала, которые сохраняют включенные или необходимые файлы PHP. Так что это медленнее, чем включить и потребовать.

Просто используя вот так ...

if (!defined(php)) {
    include 'php';
    define(php, 1);
}

PHP CodeSniffer говорит, что если файл включается условно, используйте include_once (вместо require_once).