PHP各种引入文件函数的执行效率include require fpassthru readfile

pond2539

http://www.ccvita.com/163.html
　　在研究如何提高php的执行效率问题
一直觉着include过多的文件会提高php的执行时间
但是又时候一些文件确实又需要去引入,尝试着去试验php的各种引入文件函数的执行效率
下面的资料表明,将数据缓存成php文件并不是最好的方式
在小数据量的情况下做文本缓存的可读性最好
　　另外说句 其实有些时候还是google好用
http://www.raditha.com/wiki/Readfile_vs_include

　　It is not often that you can write a PHP script that does not need
to include the contents of different files as part of it’s output. If
these includes happen to be php scripts themselves you have no choice
but to use require or include.
However more often than not, the contents are static, usually html
template component. With static includes you have many more options
available.
aerwear
We will analyse some of these functions to find out which one is most
suitable when dealing with files with static content. We use the term
function loosely, because require and include are not real functions
but language constructs.

　　




Function
Brief Description



string file_get_contents ( string filename [, int use_include_path])
  Reads entire file into a string



int fpassthru ( resource handle)
Output all remaining data on a file pointer



string fgets ( resource handle [, int length])  
Gets line from file pointer



array file ( string filename [, int use_include_path])
Reads entire file into an array




require(string filename)

include(string filename)

require_once(string filename)

include_once(string filename)



includes and evaluates the specific file.



int readfile ( string filename [, int use_include_path])
  Outputs a file

　　We will now attempt to ‘include’ the contents of a 1 megabyte file
into the output produced by our php script. How you can generate files
of specific sizes is described elsewhere. The execution times and peak memory consumption, as reported by xdebug have been tabulated below.

　　We compensate for file caching and background processes by executing
each script 4 times and taking the average (mean) of the result number
2-4. The first result is always rejected. Any result that appears to be
outlier is rejected. The mean is rounded to 5 decimal places.

　　



Function
Sample Usage
Time (s)
Memory (b)



file_get_contents
echo file_get_contents($filename);
0.00564
1067856



fpassthru

fpassthru($fp);
0.00184
  20032



fgets


$fp = fopen($filename,"rb");

while(!feof($fp))

{

echo fgets($fp);

}



0.07190
30768



file
echo join(”",file($filename));  
  0.06464
2185624



require_once
require_once($filename);
0.08065
2067696



include
include($filename);
0.08202
2067696



readfile
readfile($filename);
0.00191
19208

　　What’s obvious from these results is that using fpassthru is far
superior to all other methods. What’s not so obvious is that fpassthru
and readfile are equally good. The fpassthru version runs 0.00007
seconds quicker than the readfile version. What that really means is
that you need to run the script at least 100000 times to make
significant saving. On memory consumption readfile seems to have use up
around 1kb less than passthru. A kilo byte is a drop in the ocean for
modern web servers with hundreds of megabytes if not gigabytes of
memory.

　　The only conclusion that can be drawn from these studies is that
fpassthru and readfile are equally good if you wish to include static
content as part of the script’s output.

　　Before you rush off to change all your includes and requires into
readfiles or fpassthrus let’s run the same test with a smaller (32Kb
file). 32Kb is a more realistic size for an included file.

　　



Function
Time (s)
Memory (b)




32Kb File
1Mb File
32Kb File
1Mb File


file_get_contents
0.00152
0.00564
52480
1067856


fpassthru
0.00117
0.00184
20016
20032


fgets
0.00195
0.07190
30760
30768


file
0.00157
0.06464
87344
2185624


require_once
0.00225
0.08065
67992
2067696


include
0.00222
0.08202
67928
2067624


readfile
0.00117
0.00191
19192
19208
　　readfile and fpassthru have once again tied for first place. This
new set of results just confirms the fact that speed and scalability
comes from your design and not from your code. The difference between
the best performance and the worst is just 0.00108s too close to call.

　　The most significant feature of these results is that both fpassthru
and readfile scale really well. In other words, memory consumption and
execution time does not increase significantly with increase in file
size. That does not always mean your script will be faster just because
you use these functions instead of require or include.