require() and include() have many similarities, but also some differences. It's important to understand their differences, otherwise it's easy to make mistakes.
I introduce these two sentences together so that readers can compare and learn.
1.require() statement
The require() statement is used to specify the file instead of the statement itself, just like the include() statement in C language. If the URL fopen wrappers in the php configuration file php.ini is turned on (it is turned on by default), you can use the URL to specify the location of the file to call remote files.
One thing is to pay special attention when using require() and include() statements. That is, in the included file, the processor interprets the content according to the HTML mode, and returns to the PHP mode after processing the included content. So if you need to use PHP syntax in the included file, you must use the correct PHP start and end tags to include these statements.
require() and include() are a language feature in PHP, not a function. They are different from functions in many ways.
For example: the file included in require() cannot contain control structures, and statements such as return cannot be used. Using the return statement in a file included with require() will generate a processing error.
Unlike the include() statement, the require() statement will unconditionally read the contents of the file it contains, regardless of whether these statements are executed. So if you want to include different files according to different conditions, you must use the include() statement. Of course, if the statement at the location of require() is not executed, the statements in the file contained by require() will not be executed either.
require() cannot include different files according to different conditions in the loop body. The require() statement will only call the content of the file it contains when it is executed for the first time to replace the statement itself. When it is executed again, only the statement included in the first time will be executed. But the include() statement can include different files in the loop body.
The variables in the require() statement inherit the variable scope where the require() statement is located. All variables accessible at the location of the require() statement are accessible in the file included in the require() statement. If the require() statement is located inside a function, then the statements in the included file are equivalent to being defined inside the function.
The require() statement will read the file referenced by require before the PHP program is executed, so require is usually placed at the beginning of the program. Therefore, special attention should be paid to the fact that the require statement is a bit strong. Regardless of whether the program really needs the referenced files, as long as you use the require statement, it will include them! Even if you use this function to include in a conditional control statement, even if the condition is not true, the referenced file will be included! Zombies are formed. These zombies will not have any visible effect during operation, but it will obviously increase the burden, so pay special attention to this! If an inclusion error occurs using the require statement, the program will output an error message and stop running! !
If the require() statement includes a remote file by declaring the URL of the file, and the remote server interprets the file according to the PHP code, the content contained in the local PHP file is the result of processing on the remote server. For example:
/*
This example assumes that some_server server can interpret .php files but not .txt files. In the remote file
The variables $varfirst and $varsecond are required
*/
/*Cannot be executed correctly, the remote server does not process the .txt file*/
require("http://some_server/file.txt?varfirst=1&varsec
/ *Incorrect, this can only find the file.php file on the local machine*/
require("file.php?varfirst=1&varsec
/*Correct statement*/
require("http://some_server/file.php? varfirst=1&varsec
$varfirst=1;
$varsec
require("file.txt"); /*Correct statement*/
require("file.php"); /*Correct statement*/
Originally in php3 In .0, files included by require() can use the return statement, but the condition is that the return statement cannot appear inside {}, but must appear in the global scope of the included file. require() has been canceled in php4.0. ), but it can still be implemented using include().
2.include() statement
The include() statement has many similarities with the require() statement. Anything that is not explicitly stated in the require() statement above cannot be used. Except for the parts applicable to include(), the functions of the require() statement are fully applicable to the include() statement. The following describes the functions and characteristics of the include() statement that the require() statement does not have.
The include statement is only executed when it is executed. The files to be included will be read in.For the convenience of error handling, use the include statement. If an include error occurs, the program will skip the include statement. Although the error message will be displayed, the program will continue to execute!
The PHP processor will reprocess the include() statement every time it encounters it, so you can use include() in conditional control statements and loop statements to include different files according to different situations.
For example:
$files=array('first.php','second.php','third.php');
for($i=0;$i
php3.0. The following is an example:
Assume that the included file is test.inc and the main file main.php is located in a directory. The content of test.inc is as follows:
test.inc
echo "Before the return
n";
if(1)
{
return 27;
}
echo "After the return< ;br> n";
?>
Suppose the following statement is included in the main.php file:
$retval=include('test.inc');
echo "File returned:'$retval'< br>n";
?>
The php3.0 interpreter will report an error on the second line and cannot get the return value of the include() statement. But in php4.0, you will get the following result:
Before the return
File returned: '27'
Let's assume that main.php is changed to:
include('test.inc');
echo " Back in main.html
n";
?>
The output result in php4.0 is:
Before the return
Back in main.html
The output result in php5.0 is also:
Before the return
Back in main.html
The output result in php3.0 is:
Before the return
27Back in main.html
Parse error:parse error in /apache/htdocs/phptest/main.html on line 5
appears The above error is because the return statement is inside {} and not inside a function. If {} is removed so that it is located at the outermost layer of test.inc, the output result is:
Before the return
27Back in main.html
The reason why 27 appears is because include() return is not supported in php3.0 .
3.require_once() and include_once() statements
require_once() and include_once() statements correspond to require() and include() statements respectively. The require_once() and include_once() statements are mainly used when multiple files need to be included, which can effectively avoid errors in repeated definitions of functions or variables caused by including the same piece of code.For example: If you create two files util.inc and fool.inc, the program codes are:
util.inc:
define(PHPVERSION,floor(phpversion()));
echo "GLOBALS ARE NICE< br>n";
function goodTea()
{
return "Olong tea tastes good!";
}
?>
and fool.inc:
require ("util.inc");
function showVar($var) {
var_dump($var); .php contains these two files:
require("fool.inc");
require("util.inc");//This sentence will generate an error
$foo=array("1" ,array("complex","quaternion"));
echo "this is requiring util.inc again which is also
n";
echo "required in fool.incn";
echo "Running goodTea:". goodTea()."
n";
echo "Printing foo:
n";
showVar($foo);
?>
When error_require.php is run, the output is as follows:
GLOBALS ARE NICE
GLOBALS ARE NICE
Fatal error:Cannot redeclare goodTea() in util.inc on line 4
If you use the require_once() statement instead of the require() statement, the above error will not occur. We changed the require() statement in error_require.php and fool.inc to require_once() statement and renamed it to error_require_once.php. This is the result shown below:
GLOBALS ARE NICE
this is requiring util.inc again which is also
required in fool.inc Running goodTea:Olong tea tastes good!
Printing foo:
Array([0] => 1 [1] => Array ([0] => complex [1] = quaternion))
The syntax of the include_once() statement is similar to the include() statement. The main difference is to avoid repeated definitions of functions or variables caused by including a file multiple times.
The require_once statement has a reference chain, which ensures that the file is added to your program only once and avoids conflicts between variable values and function names.
Like the require_once statement, the include_once statement extends the functionality of include. During program execution, the specified file is included. If the program referenced from the file has been previously included, include_once() will not include it again. That is to say, the same file can only be referenced once!
The include_once() statement includes and runs the specified file during script execution. This behavior is similar to the include() statement, the only difference is that if the code in the file is already included, it will not be included again. As the name of this statement implies, it will only be included once.
include_once() should be used when the same file may be included more than once during script execution, and you want to ensure that it is only included once to avoid problems such as function redefinition and variable reassignment.
For more examples of using require_once() and include_once(), see the PEAR code in the latest PHP source program distribution package.
The return value is the same as include(). If the file is included, this function returns TRUE.
Note: include_once() is newly added in PHP 4.0.1pl2.
Note: Be aware that the behavior of include_once() and require_once() in case-insensitive operating systems (such as Windows)
may not be expected.
Example: include_once() is not case sensitive under Windows
include_once("a.php"); // this will include a.php
include_once("A.php"); // this will include a.php again on Windows! (PHP 4 only)
?>
This behavior was changed in PHP 5. The path was normalized first, so the implementation of C:PROGRA~1A.php and C:Program Filesa.php Likewise, the file will only be included once.
If the file to be included does not exist, include will prompt notice, and then continue to execute the following statement, require will prompt a fatal error and exit.
Under the win32 platform, they are included first and then executed, so it is best not to have include or require statements in the included files, which will cause directory confusion. Maybe the situation is different under Linux, I haven't tested it yet.
If a file does not want to be included multiple times, you can use include_once or require_once## to read and write document data.
function r($file_name) {
$filenum=@fopen($file_name,"r");
@flock($filenum,LOCK_SH);
$file_data=@fread($filenum,filesize( $file_name));
@fclose($filenum);
return $file_data;
}
function w($file_name,$data,$method="w"){
$filenum=@fopen($file_name,$method );
flock($filenum,LOCK_EX);
$file_data=fwrite($filenum,$data);
fclose($filenum);
return $file_data;
}
?>
The above introduces the similarities and differences between require_once require, include, require_once and include_once, including the content of require_once. I hope it will be helpful to friends who are interested in PHP tutorials.
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
