require、include、require_once 和 include_once 之间的区别？

Question

在 PHP 中：

• 我应该什么时候使用require与include ？
• 我什么时候应该使用require_once与include_once ？

Answer 1

还有require和include_once 。

所以你的问题应该是...

1. 我应该什么时候使用require与include ？
2. 我什么时候应该使用require_once与require

此处描述了 1 的答案。

require() 函数与 include() 相同，只是它处理错误的方式不同。 如果发生错误，include() 函数会生成警告，但脚本会继续执行。 require() 生成一个致命错误，脚本将停止。

2的答案可以在这里找到。

require_once() 语句与 require() 相同，除了 PHP 将检查文件是否已被包含，如果是，则不再包含（要求）它。

Answer 2

利用

• 要求
  当您的应用程序需要该文件时，例如重要的消息模板或包含配置变量的文件，否则应用程序将中断。

• 要求一次
  当文件包含在后续包含时会产生错误的内容时，例如function important() { /* important code */}在您的应用程序中肯定是必需的，但由于无法重新声明函数，因此不应再次包含。

• 不需要文件时包含，未找到时应继续应用程序流程，例如
  非常适合从当前范围内引用变量的模板或其他东西

• 包含一次
  可选依赖项，这些依赖项会在后续加载时产生错误，或者可能会因为 HTTP 开销而导致您不希望发生两次的远程文件包含

但基本上，何时使用哪个取决于您。

Answer 3

我的建议是 99.9% 的时间只使用require_once 。

使用require或include意味着您的代码不能在其他地方重用，即您引入的脚本实际上执行代码，而不是提供类或某些函数库。

如果你需要/包含当场执行的代码，那就是程序代码，你需要了解一个新的范例。 像面向对象的编程、基于函数的编程或函数式编程。

如果您已经在进行 OO 或函数式编程，则使用include_once主要会延迟您在堆栈中发现错误/错误的位置。 您是否想知道函数do_cool_stuff()在您稍后调用它时不可用，或者您希望它通过请求库可用的那一刻？ 一般来说，如果您需要和期望的东西不可用，最好立即知道，所以只需使用require_once 。

或者，在现代 OOP 中，只需在使用时自动加载您的类。

Answer 4

_once 函数和没有 _once 函数的区别：没有 _once 的代码将被再次包含，而带有 _once 函数的 PHP 会跟踪包含的文件并且只会包含一次。

require 和 include 之间的区别：如果找不到所需的文件，PHP 将发出致命错误，而对于 include 只会发出警告。

Answer 5

如果include()不能包含该文件，它将引发警告，但脚本的其余部分将运行。

require()将抛出E_COMPILE_ERROR并停止脚本，如果它不能包含文件。

如果该文件已被包含，则include_once()和require_once()函数将不会再次包含该文件。

请参阅以下文档页面：

• 包括
• 要求
• 包含一次
• 要求一次

Answer 6

您应该将类​​和函数定义组织在文件中。

使用require_once()加载依赖项（类、函数、常量）。

使用require()加载类似模板的文件。

使用include_once()加载可选的依赖项（类、函数、常量）。

使用include()加载可选的类似模板的文件。

Answer 7

2018年7年后的答案

这个问题是七年前提出的，没有一个答案能为这个问题提供实际帮助。 在现代 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没有实际用例。

Answer 8

每当您使用require_once()时，当您在当前文件中只需要一次调用文件时，可以在文件中使用以包含另一个文件。 在示例中，我有一个 test1.php。

<?php  
echo "today is:".date("Y-m-d");  
?>  

在另一个我命名为 test2.php 的文件中

<?php  
require_once('test1.php');  
require_once('test1.php');  
?>

因为您正在观看两次需要 test1 文件的 m，但该文件将包含 test1 一次，并且在第二次调用时，这将被忽略。 并且不停止将显示一次输出。

每当您在当前文件中多次需要调用的文件时，可以在文件中使用“include_once()”来包含另一个文件。 在示例中，我有一个名为 test3.php 的文件。

<?php  
echo "today is:".date("Y-m-d");  
?> 

在另一个我命名为 test4.php 的文件中

<?php  
include_once('test3.php');  
include_once('test3.php');  
?>

当您正在观看包含 test3 文件的 m 时，将包含该文件一次，但会停止进一步执行。

Answer 9

对可重用的PHP模板使用“包含”。 对所需的库使用“require”。

"*_once" 很好，因为它会检查文件是否已经加载，但它只在 "require_once" 中对我有意义。

Answer 10

不同之处在于命令生成的错误。 使用require ，您要使用的文件确实是必需的，因此如果找不到它会生成E_ERROR 。

require()与include()相同，但失败时也会产生致命的E_ERROR级别错误。

include只有在失败时才会生成E_WARNING错误，这或多或少是沉默的。

因此，如果需要该文件以使其余代码工作并且您希望脚本失败，则使用它，该文件不可用。

---

对于*_once() ：

include_once()可用于在特定脚本执行期间可能多次包含和评估同一文件的情况，因此在这种情况下，它可能有助于避免诸如函数重新定义、变量值重新分配等问题。

当然，这同样适用于require_once() 。

---

参考： require() ， include_once()

Answer 11

1. 什么时候应该使用require或include ？

   require和include函数执行相同的任务，即包含并评估指定的文件，但不同的是，当指定的文件位置无效或任何错误时require将导致致命错误，而include将生成警告并继续代码执行.

   因此，当您尝试包含的文件是系统的核心并且可能对其余代码造成巨大影响时，您可以使用require函数，并且您可以在您尝试包含的文件时使用include函数是一个包含一些不太重要的代码的简单文件。

   我个人的建议（对于不太重要的代码）是在代码处于开发阶段时在代码中的任何地方使用require函数，以便您可以调试代码，然后在将其移至生产之前通过include函数替换所有require函数，这样如果您错过任何错误，它不会影响最终用户，并且其余代码可以正常执行......

2. 什么时候应该使用require_once或require ？

   require和require_once之间的基本区别是require_once将检查文件是否已包含，如果已包含，则不会包含该文件，而require函数将包含该文件，而不管文件是否已包含。

   因此，如果您想一次又一次地包含一些代码，请使用require函数，而如果您只想在代码中包含一些代码，请使用require_once 。

Answer 12

使用 require 文件必须存在，如果不存在则会显示错误； 而包含 - 如果文件不存在，那么页面将继续加载。

Answer 13

需要关键部分，如授权，并包括所有其他部分。

多个包含只是非常糟糕的设计，必须完全避免。 所以， *_once 并不重要。

Answer 14

我正在使用如下功能：

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

在 xyz.php 中声明了常量值。

我必须从另一个 PHP 脚本文件中调用这个 doSomething() 函数。

但是我在循环中调用此函数时观察到了行为，因为第一次迭代 doSomething() 在xyz.php中获得了常量值，但后来每次迭代doSomething()都无法获得在xyz.php中声明的常量值。

我通过从require_once()切换到include()解决了我的问题，更新后的doSomething()代码如下：

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

现在对doSomething()的每次迭代调用都会获取xyz.php中定义的常量值。

Answer 15

包含/要求您也可以多次包含同一个文件：

require() 与 include() 相同，但失败时也会产生致命的 E_COMPILE_ERROR 级别错误。 换句话说，它将停止脚本，而 include() 只发出一个警告 (E_WARNING) 允许脚本继续。

require_once / include_once

与 include/require 相同，只是 PHP 将检查文件是否已被包含，如果是，则不再包含（要求）它。

Answer 16

1 - 如果文件不存在，“require”和“require_once”会抛出致命错误并停止脚本执行

2 - "include" 和 "include_once" 抛出警告并继续执行

3 - 顾名思义，“require_once”和“include_once”，如果文件已经包含在“require”、“require_once”、“include”或“include_once”中，它们将不包含该文件

Answer 17

从手册：

require()与include()相同，但失败时也会产生致命的E_COMPILE_ERROR级别错误。 换句话说，它将停止脚本，而include()只发出一个警告（ E_WARNING ），允许脚本继续。

_once()变体也是如此。

Answer 18

include()在找不到文件时会产生警告，但require_once()会产生致命错误。

另一件事是之前是否包含文件。 然后require_once()将不再包含它。

Answer 19

在PSR-0 / PSR-4自动加载器时代，如果您只需要使某些函数/类可用于您的代码（当然，您仍然需要require_once自动加载器本身），则可能完全不需要使用任何语句如果您仍然使用 PHP 作为模板引擎，请在您的引导文件中include模板）。

Answer 20

1. 当您需要加载任何类、函数或依赖项时，请使用require函数。

2. 当你想加载模板样式的文件时使用包含函数

如果您仍然感到困惑，请始终使用require_once 。

Answer 21

基本上，如果你需要一个错误的路径，PHP 会抛出一个致命错误并调用关闭函数，但是当你包含一个错误的路径时，PHP 会继续执行，但它只会显示一个文件不存在的警告。

从英文单词require中，PHP 被告知页面或文件的执行取决于所需的文件。

根据我的经验，需要重要文件（如配置文件、数据库类和其他重要实用程序）是常态。

Answer 22

它们都是包含文件的方式。

需要意味着它需要它。 Require_once 表示它将需要它，但只需要它一次。 包含意味着它将包含一个文件，但它不需要它继续。

例子：

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

还有一个 include_once 函数，它包含一个文件一次。

Include_once 'filename'

不要在我用手机打字时使用大写字母。

Answer 23

我注意到的一件事是，在使用 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();
}

Answer 24

require在未找到文件时停止下一行执行产生致命错误。

include生成警告，但在找不到文件时没有停止下一行执行。

require_once与require do 做同样的事情，但它会检查文件是否已经被加载或不被执行。

include_once与include do 执行相同的操作，但它会检查文件是否已加载或不执行。

注意： include_once或require_once可用于在特定脚本执行期间可能多次包含和评估同一文件的情况，因此在这种情况下，它可能有助于避免函数重新定义、变量值重新分配等问题。

Answer 25

这通常是您是否要有条件地加载客户端库，或者无论您是否要使用它都继续加载它的问题。

这是具体的例子； 详细说明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();
    }
}
?>

除非您担心加载可能仅在某些条件下使用并且不想在不使用时加载它的类的开销。

Answer 26

require比include有更大的开销，因为它必须首先解析文件。 用includes替换requires通常是一种很好的优化技术。

Answer 27

只需使用 require 和 include。

因为想想如何使用 include_once 或 require_once。 那就是寻找保存包含或需要的 PHP 文件的日志数据。 所以这比 include 和 require 慢。

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

就这样使用...