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

В PHP:

• Когда я должен использовать 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_once
  необязательные зависимости, которые могут привести к ошибкам при последующей загрузке или, возможно, удаленному включению файлов, которые вы не хотите выполнять дважды из-за накладных расходов HTTP

Но в принципе, это зависит от вас, когда использовать какой.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Для *_once():

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

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

Ссылка: require(),include_once()

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

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

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

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

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

require_once / include_once

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

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

Другое дело, если файл включен ранее. Тогда require_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()исключением того, что при отказе он также приведет к фатальной E_COMPILE_ERRORошибке уровня. Другими словами, он остановит скрипт, тогда как include()только выдает предупреждение ( E_WARNING), которое позволяет скрипту продолжить.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примеры:

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

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

Include_once 'filename'

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

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

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

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

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

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

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();
}

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

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

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

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

Вот конкретный пример; уточняя, что сказал 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
    }
}
?>

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

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

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

<?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();
    }
}
?>

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

requireимеет большие издержки, чем include, так как он должен сначала проанализировать файл. Замена requiresс includesчасто техника хорошей оптимизацией.

Просто используйте требовать и включать.

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

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

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