Detailed explanation of performance comparison of inlcude() in PHP_PHP Tutorial

include performance

Copy code The code is as follows:

include('include.php');

Of course there is nothing wrong with this method, but it is slightly less efficient than the following method:

Copy Code The code is as follows:

include(realpath(dirname(_FILE_)).DIRECTORY_SEPARATOR.'include.php');

We may need to enter more in this way, but compared to the previous method that requires the PHP engine to iterate through include_path to find all names named 'include.php' to find the corresponding object, the absolute path of dirname (__FILE__) Specifying will allow the system to quickly locate the corresponding file.

The constant __FILE__ in PHP is actually very similar to AppDomain.CurrentDomain.BaseDirectory in C#. It returns the absolute path of the file where the code currently being executed is located. The function dirname() returns its parent folder path.
Another more efficient and simple way to write is include('./include.php'), which is equivalent to telling the system to find the 'include.php' file in the current path.

In large systems we often use another better way. We often add the following code to routing files or other initialization files:

Copy Code The code is as follows:

define('APP_PATH',realpath(dirname(_FILE_))));

This is equivalent to adding to the system A global variable points to the system root directory. When we need to reference files under a specific path later, we can use the following code:

Copy code Code As follows:

include(APP_PATH.DIRECTORY_SEPARATOR.'models'.'User.php');

Autoload and include performance comparison

For example, there are the following four scripts:

Copy code The code is as follows:

# file:include1.php
include 'include2.php';
//@todo something#file:include2.php
//@todo something#file:script1.php
include 'include2. php';
//@todo something
#file:script2.php
include 'include1.php';
include 'script1.php'
//@todo something

When script1.php is executed, include 'include2.php'; this line of code is executed once. When executing script2.php, this line of code is executed twice.
This is just a simple example. In an actual project, include2.php may be included more times. Will such repeated include affect performance? I wrote a script to test this.

Copy code The code is as follows:

#file:SimpleClass.php
class SimpleClass {
public function __construct() {
echo get_time() . "rn";
}
}
#file:php_include.php
for($i = 0;$i < $ loop;$i++) {
include_once "SimpleClass.php";
new SimpleClass();
}

When the $loop value is 1, the script consumes It takes about 0.00018906593322754 seconds. When $loop is 1000, the script takes about 0.076701879501343 seconds.

What if we use autoload to implement it?

Copy code The code is as follows:

#file:php_autoload.php
function __autoload( $class_name) {
include_once $class_name . '.php';
}for($i = 0;$i < $loop;$i++) {
new SimpleClass();
}

In this code, I defined the __autoload function. It is almost the same script. When $loop is 1, it takes 0.0002131462097168 seconds. When $loop is 1000, it takes only 1/ of the previous code. 7, 0.012391805648804 seconds.
But please pay attention to the code of SimpleClass, which outputs a line of string. If you remove this line of output and then compare, what will be the result?

When $loop is both 1000, the former takes 0.057836055755615 seconds, but after using autoload, it only takes 0.00199294090271 seconds! The efficiency difference is nearly 30 times!

As can be seen from the above test, when the file is only included once, autoload will consume a little more time, but if the file is included repeatedly, using autoload can greatly improve system performance.
As for whether to use autoload to liberate programmers, it depends on the beholder and the wise. In my opinion, if conditions permit, it is worth sacrificing this performance (in some cases, it may even improve performance) for more convenient development.

include() and require() performance

For include(), the file must be read and evaluated every time when include() is executed;
For require(), the file is only processed once (in fact, the file content replaces the require() statement).
This means that if you have code that contains one of these instructions and code that may be executed multiple times, it is more efficient to use require().
On the other hand, if you read a different file each time the code is executed, or have a loop that iterates through a set of files, use include(),
because you can set the names of the files you want to include A variable used when the parameter is include().

http://www.bkjia.com/PHPjc/325979.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/325979.htmlTechArticleinclude performance copy code The code is as follows: include('include.php'); Of course, there is nothing wrong with this method. It's just that it's slightly less efficient than the following method: Copy the code as...