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

有和一样。requireinclude_once

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

1. 我应该在什么时候使用 vs. ？requireinclude
2. 我应该什么时候使用 vs.require_oncerequire

此处描述了 1 的答案。

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

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

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

请注意，现在 *_once 变体几乎没有用处。如果你正在使用它们，这可能是一种无意识的习惯，或者你的代码需要重构。

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

require 和 include 之间的区别： 如果未找到所需的文件，PHP 将发出致命错误，而 for include 将仅发出警告。

区别在于命令生成的错误。使用 ，您要使用的文件确实是必需的，因此如果未找到，则生成一个。requireE_ERROR

require()与此相同，除非发生故障，否则它还会产生致命的级别错误。include()E_ERROR

include只有在失败时才会生成错误，该错误或多或少是无声的。E_WARNING

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

---

为：*_once()

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

当然也是如此。require_once()

---

参考：require（）， include_once（）

如果要求文件必须存在，则不会显示错误;而使用 include - 如果文件不存在，则页面将继续加载。

用

• 
  require 当应用程序需要该文件时，例如，重要的消息模板或包含配置变量的文件，如果没有这些变量，应用程序就会中断。

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

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

• include_once
  可选的依赖项，这些依赖项会在后续加载时产生错误，或者由于 HTTP 开销而不希望发生两次的远程文件包含

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

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

使用 or 意味着您的代码在其他地方不可重用，即您正在拉取的脚本实际上执行代码，而不是提供类或某些函数库。requireinclude

如果你需要/包括现场执行的代码，那就是过程代码，你需要了解一种新的范式。如面向对象编程、基于函数的编程或函数式编程。

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

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

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

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

对可重用的 PHP 模板使用“include”。对必需的库使用“require”。

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

从手册：

require()与此相同，除非发生故障，否则它还会产生致命的级别错误。换句话说，它将停止脚本，而只发出警告 （） 以允许脚本继续。include()E_COMPILE_ERRORinclude()E_WARNING

变体也是如此。_once()

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

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

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

请参阅以下文档页面：

• 包括
• 需要
• include_once
• require_once

“包含/要求”，也可以多次包含同一文件：

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

require_once / include_once

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

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

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

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

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

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

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

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

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

<?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 将包含该文件一次，但会停止进一步执行。

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

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

2. 当您想要加载模板样式的文件时，请使用 include 函数

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

 

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

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

   因此，如果您尝试包含的文件是系统的核心，并且可能会对代码的其余部分造成巨大影响，则可以使用该函数，并且当您尝试包含的文件是包含一些不太重要的代码的简单文件时，可以使用该函数。requireinclude

   我个人的建议（对于不太重要的代码）是在代码处于开发阶段时在代码中的任何位置使用该函数，这样您就可以调试代码，然后在将其转移到生产环境之前按功能替换所有函数，这样如果您错过了任何错误，它不会影响最终用户，并且其余代码可以正常执行......requirerequireinclude

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

   和之间的基本区别是将检查文件是否已包含在内，如果文件已包含在内，则它不会包含文件，而无论文件是否已包含在内，该函数都将包含文件。requirerequire_oncerequire_oncerequire

   因此，如果您想一次又一次地包含某些代码，请使用该函数，而如果您只想在代码中包含一次某些代码，请使用 .requirerequire_once

只需使用 require 和 include。

因为想想如何使用include_once或require_once。 即查找保存包含或所需的PHP文件的日志数据。 因此，这比 include 和 require 慢。

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

就这样使用...

在自动加载器时代，如果你只需要使一些函数/类可用于你的代码，那么可能完全没有必要使用任何语句（当然，如果你仍然使用PHP作为模板引擎，你仍然需要在你的引导文件和模板中自动加载自己）。PSR-0 / PSR-4require_onceinclude

我使用的功能如下：

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

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

我必须从另一个PHP脚本文件调用这个doSomething（）函数。

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

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

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

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

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

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

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

2018 年 7 年后的答案

这个问题是七年前提出的，没有一个答案能为这个问题提供实际的帮助。在现代 PHP 编程中，您主要只使用一次来包含您的自动加载器类（通常使用 composer 自动加载器），它将加载您的所有类和函数（函数文件需要显式添加到文件中才能在所有其他文件中使用）。如果您的类无法从自动加载器加载，则用于加载它。require_oncecomposer.jsonrequire_once

有些场合我们需要用到。例如，如果您有一个非常大的数组定义，并且不想将其添加到类定义源代码中，则可以：require

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

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

如果您打算包含的文件包含可执行文件或声明了一些变量，则几乎总是需要使用 ，因为如果您首先使用，您的代码将不会被执行和/或您的变量不会以静默方式启动，从而导致绝对难以确定的错误。requirerequire_once

实际上没有实际的用例。includeinclude_once

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

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

例子：

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

这通常取决于你是要有条件地加载客户端库，还是继续加载它，不管你是否要使用它。

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

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

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

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

3 - 顾名思义，“require_once”和“include_once”， 如果文件已包含在 “要求”、“require_once”、“包括”或“include_once”

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

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

require_once执行与 do 相同的操作，但它将检查文件是否已加载或是否已执行。require

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

注意：或者，在脚本的特定执行过程中，同一文件可能被多次包含和计算，因此在这种情况下，它可能有助于避免函数重新定义、变量值重新分配等问题。include_oncerequire_once

在 PHP 中，有 4 个类似的函数用于包含和要求文件：

include()：该语句用于将一个文件的内容包含到另一个文件中。如果找不到要包含的文件，将生成警告，但脚本将继续执行。include()

require()：该语句类似于 include，但如果找不到文件，则会生成致命错误。该脚本将立即停止执行。require()

include_once()：该语句与 include 相同，但它只会包含一次文件，即使它在同一脚本中多次包含也是如此。include_once()

require_once()：该语句与 require 相同，但它只会包含一次文件，即使它在同一脚本中多次包含也是如此。require_once()

简单来说：

当您想要包含文件并继续执行脚本（即使文件丢失）时使用。include()

在需要包含文件并在文件丢失时停止执行脚本时使用。require()

当您只想包含一次文件时，请使用 或，以避免出现重复函数或变量的任何问题。include_once()require_once()

注意：一般情况下，建议使用 over，以确保包含所需的文件且不丢失。require_once()include_once()