Detailed explanation of using Streams in PHP

Streams is a powerful tool provided by PHP. We often use it inadvertently. If we make good use of it, it will greatly improve the productivity of PHP. Harnessing the power of Streams will take your applications to the next level.

​

The following is a description of Streams from the PHP manual:

Streams was introduced in PHP version 4.3.0. It is used to unify the operation methods of files, networks, data compression, etc., and provides a set of common function interfaces for these file operations. In short, a stream is a resource object with streaming behavior. In other words, we can read and write to the stream in a linear manner. And you can use fseek() to jump to any position within the stream.

Each Streams object has a wrapper class, in which code related to handling special protocols and encodings can be added. Some commonly used packaging classes have been built into PHP, and we can also create and register custom packaging classes. We can even modify and enhance the wrapper class using existing context and filters.

Stream Basics

Stream can be referenced through ://. Among them, is the name of the packaging class, and the content in is specified by the syntax of the packaging class. The syntax of different packaging classes will be different.

The default packaging class of PHP is file://, which means that when we access the file system, we are actually using a stream. We can read the contents of the file in the following two ways, readfile('/path/to/somefile.txt') or readfile('file:///path/to/somefile.txt'). The methods are equivalent. If you use readfile('http://google.com/'), then PHP will select the HTTP stream wrapper class to operate.

As mentioned above, PHP provides many built-in package classes, protocols and filters. According to the method described below, you can query the packaging classes supported by this machine:

1 2 3 4

<?php print_r(stream_get_transports()); print_r(stream_get_wrappers()); print_r(stream_get_filters());

The output on my machine is:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 twenty one twenty two twenty three twenty four 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

Array ( [0] => tcp [1] => udp [2] => unix [3] => udg [4] => ssl [5] => sslv3 [6] => sslv2 [7] => tls ) Array ( [0] => https [1] => ftps [2] => compress.zlib [3] => compress.bzip2 [4] => php [5] => file [6] => glob [7] => data [8] => http [9] => ftp [10] => zip [11] => phar ) Array ( [0] => zlib.* [1] => bzip2.* [2] => convert.iconv.* [3] => string.rot13 [4] => string.toupper [5] => string.tolower [6] => string.strip_tags [7] => convert.* [8] => consumed [9] => dechunk [10] => mcrypt.* [11] => mdecrypt.* )

There are a lot of functions provided. Doesn’t it look good?

In addition to the above built-in Stream, we can also write more third-party Streams for Amazon S3, MS Excel, Google Storage, Dropbox and even Twitter.

php:// packaging class

PHP has a built-in wrapper class for handling I/O streams in this language. It can be divided into several categories. The basic ones are php://stdin, php://stdout, and php://stderr. These three streams are mapped to default I/O resources respectively. At the same time, PHP also provides php://input, through which the raw body in the POST request can be accessed in a read-only manner. This is a very useful feature, especially when dealing with remote services that embed data payloads into POST requests.

Below we use the cURL tool to do a simple test:

1	curl -d "Hello World" -d "foo=bar&name=John" <a href="http://localhost/dev/streams/php_input.php ">http://localhost/dev/streams/php_input.php</a>

The test results of using print_r($_POST) in PHP script are as follows:

1 2 3 4 5

Array ( [foo] => bar [name] => John )

We note that the first item of data cannot be accessed in the $_POST array. But if we use readfile('php://input'), the result is different:

1	Hello World&foo=bar&name=John

PHP 5.1 adds two more package classes, php://memory and php://tempstream, for reading and writing temporary data. As the name of the wrapper class implies, this data is stored in memory or temporary files in the underlying system.​

php://filter is a meta-package class used to add filter functionality to streams. The filter will be enabled when opening a stream using readfile() or file_get_contents()/stream_get_contents(). Below is an example:

1 2 3 4 5 6

<?php //Write encoded data file_put_contents("php://filter/write=string.rot13/resource=file:///path/to/somefile.txt","Hello World"); ​ //Read data and encode/decode readfile("php://filter/read=string.toupper|string.rot13/resource=http://www.google.com");

In the first example, a filter is used to encode the data saved to disk. In the second example, two cascaded filters are used to read the data from the remote URL. Using filters can bring extremely powerful functionality to your application.

Stream context

Context is a set of stream-related parameters or options. Use context to modify or enhance the behavior of the wrapper class. For example, using context to modify the HTTP wrapper is a commonly used usage scenario. In this way, we can complete some simple network operations without using the cURL tool. Below is an example:

1 2 3 4 5 6 7 8 9 10 11 12

<?php $opts = array( 'http'=>array(      'method'=>"POST", 'header'=> "Auth: SecretAuthTokenrn" .           "Content-type: application/x-www-form-urlencodedrn" .               "Content-length: ". strlen("Hello World"), 'content' => 'Hello World' ) ); $default = stream_context_get_default($opts); readfile('http://localhost/dev/streams/php_input.php');

First, you need to define an options array, which is a two-digit array. The parameters can be accessed in the form of $array['wrapper']['option_name']. (Note that the context options in each wrapper class are different). Then call stream_context_get_default() to set these options. stream_context_get_default() will also return the default context as a result. After the setting is completed, then call readfile(), and the context just set will be used to capture the content.

In the above example, the content is embedded in the request body so that remote scripts can use php://input to read the content. At the same time, we can also use apache_request_headers() to obtain the request header, as shown below:

1 2 3 4 5 6 7

Array ( [Host] => localhost [Auth] => SecretAuthToken [Content-type] => application/x-www-form-urlencoded [Content-length] => 11 )

In the above example, the parameters of the default context are modified. Of course, we can also create a new context and use it alternately.

1 2 3

<?php $alternative = stream_context_create($other_opts); readfile('http://localhost/dev/streams/php_input.php', false, $alternative);

in conclusion

How do we harness the power of streams in the real world? What practical benefits can using streams bring to our programs? As mentioned earlier, stream abstracts all file system-related functions, so the first application scenario I think of is to use the wrapper class of the virtual file system to access services provided by PaaS providers, such as accessing HeroKu or AppFog , none of them actually have a real file system. Using streams we can port our application to the cloud with only minor modifications. Next - in my next article - I will describe how to write custom wrapper classes to operate on special file formats and encoding formats.

The above has introduced a detailed explanation of the use of Streams in PHP, including aspects of the content. I hope it will be helpful to friends who are interested in PHP tutorials.