Use ob series functions to achieve static PHP website pages, obphp_PHP tutorial

Use ob series functions to achieve static PHP website pages, obphp

Converting the PHP execution page into HTML in advance is one of the so-called PHP static methods.

Other methods include template replacement, opcache and other methods.

The role of staticization:

Improve the response speed of the website and reduce the load on the server;
SEO for search engines;
Use PHP to output the buffer and write it directly into HTML, and scan the website regularly in the background. This is a relatively easy way to achieve static web pages.

Before staticization:

<&#63;php
for($i=0;$i<1000;$i++){
 echo "bull<br>";
}
&#63;>

Static:

<&#63;php
ob_start();
for($i=0;$i<1000;$i++){
 echo "bull<br>";
}
$str = ob_get_contents();
ob_end_clean();
$fp = fopen("test.html","w");
fwrite($fp,$str);
fclose($fp);
echo "<div>success write</div>";
&#63;>

This code will pre-form a test.html. To put it bluntly, it actually trades space for time. Like news websites, the published content will basically not change after it is written, so it is more suitable to statically convert it into HTML.

When users visit, they just need to direct to this html page.

Simply use apache benchmark to test the effect:

ab.exe -n1000 -c10

In more than 90% of connections, the difference between the two is at least 150ms. Compared with complex php, html still saves a lot of calculations.

Attached is an introduction to related functions

1. Flush: refresh the contents of the buffer and output.
Function format: flush()
Description: This function is frequently used and is very efficient.

2. ob_start: Open the output buffer
Function format: void ob_start(void)
Note: When the buffer is activated, all non-file header information from the PHP program will not be sent, but will be saved in the internal buffer. In order to output the contents of the buffer, you can use ob_end_flush() or flush() to output the contents of the buffer.

3. ob_get_contents: Returns the contents of the internal buffer.
Usage: string ob_get_contents(void)
Description: This function will return the contents of the current buffer. If the output buffer is not activated, it will return FALSE.

4. ob_get_length: Returns the length of the internal buffer.
Usage: int ob_get_length(void)
Description: This function will return the length in the current buffer; the same as ob_get_contents, if the output buffer is not activated. then returns FALSE.

5. ob_end_flush: Send the contents of the internal buffer to the browser and close the output buffer.
Usage: void ob_end_flush(void)
Description: This function sends the contents of the output buffer (if any).

6. ob_end_clean: Delete the contents of the internal buffer and close the internal buffer
Usage: void ob_end_clean(void)
Description: This function will not output the contents of the internal buffer but delete it!

7. ob_implicit_flush: Turn on or off absolute refresh
Usage: void ob_implicit_flush ([int flag])
Note: Anyone who has used Perl knows the meaning of $|=x. This string can open/close the buffer, and the ob_implicit_flush function is the same as that. The default is to close the buffer. After turning on absolute output, each script output Sent directly to the browser, no need to call flush() anymore.

How to achieve full-site staticization of a large PHP website? What if there are tens of thousands of pages that need to be regenerated every time a small article is changed?

Use libTemplate to generate static web pages

Author: iwind

An article originally published in dev-club, how to use template.inc in the template processing program PHPlib to generate static web pages , haha, it was actually included in the essence and reprinted by many websites. I think it is an honor. In fact, there are a lot of things about this on the Internet. The so-called IAMS (iwind article management system) I posted here is also there. Anyone who is interested can take a look. I will just briefly summarize it below.

It is generally said that there are three ways to generate static web pages. One is to configure the server. You can go to www.devarticles.com/c/b/PHP/ to find out. There are many places for this. The other is to use the ob_ function to control output. The method is as follows: first use ob_start(); to open the output buffer, then analyze the data, operate, etc., then use ob_get_contents(); to obtain the contents of the buffer, and then write to the file. According to this step, the following program can be written:
d8da0c9b3b1584476ffdf35bce1bff4e

In this way, the content of this dynamic page is written into the static page, $ targetFile. For example, some websites have a lot of homepage content and need to call n multiple query statements. You might as well generate static web pages regularly, which not only greatly improves the access speed, but also reduces the load on the server.

As you can see, I only use ob_ to process a single page. For batch writing or updating multiple pages, this method will not work. This is the third method I want to talk about, using templates. Templates are a good thing, and now everyone is using them more or less. It is recommended that netizens who are not familiar with simple template processing take the time to learn it. Generally, template processing programs are very simple. It is very simple to use templates to generate static web pages. The method is to obtain the analysis results and write the analysis results into a file. Let's use template.inc in PHPlib to talk about how to use templates to generate static web pages.

1. Modify template.inc
and add the following functions:
//Save the analysis results to a file
function savetofile ($dir,$varname){
$data=$this-> finish($this-> get_var($varname));
$fp=fopen($dir, "w+ ");
fwrite($fp,$data) ;
}
//Clear the assigned array
function renew(){
$this-> v...The rest of the text>>

How to make dynamic pages static in php system

The key to dynamic and static depends on what type of website you have. If it is not very real-time, similar to Sina News, the number of modifications after it is published may be relatively small. For such a website, you can use the method of generating static HTML pages. It's more appropriate. If your page content changes frequently, you can choose to use pseudo-static at this time. A better way is to combine caching, such as memcache and redis, which can reduce the load of the app and database server at the same time. , why not? The advantage of pseudo-static is that it is beneficial to SEO optimization, and can obtain higher rankings through search engines, thereby obtaining more traffic.

http://www.bkjia.com/PHPjc/863319.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/863319.htmlTechArticleUse the ob series of functions to achieve static PHP website pages. obphp pre-converts the PHP execution page into HTML, which is the so-called One of the PHP static methods. Others include template replacement, opcache, etc...