Nine PHP functions and features that you must know and are easy to use

The following are nine very useful functions in PHP. Have you used them?
1. Any number of parameters for a function
You may know that PHP allows you to define a function with default parameters. But you may not know that PHP also allows you to define a function with completely arbitrary parameters
Here is an example showing you a function with default parameters:

Copy code The code is as follows:

// Function with two default parameters
function foo($arg1 = '', $arg2 = '') { 

 echo "arg1: $arg1/n"; 
 echo "arg2: $arg2/n"; 

} 

foo('hello','world'); 
/ * Output: 
arg1: hello 
arg2: world 
*/

foo(); 
/* Output: 
arg1: 
arg2: 
 */

Now let’s take a look at a function with variable parameters, which uses the func_get_args() method:

Copy code The code is as follows:

// Yes, the formal parameter list is empty
function foo() { 

 // Get an array of all incoming parameters
 $args = func_get_args(); 

 foreach ($args as $k => $v) { 
 echo "arg".($k+1).": $v/n"; 
 } 

} 

foo(); 
/* Nothing will be output*/

foo('hello'); 
/ * Output
arg1: hello 
*/

foo('hello', 'world', 'again'); 
/* Output
arg1: hello 
arg2 : world 
arg3: again 
*/

2. Use Glob() to find files
Many PHP functions have a comparison Long self-explanatory function name, but when you see glob(), you may not know what this function is used for, unless you are already familiar with it.

You can think of this function just like scandir(), which can be used to find files.

Copy code The code is as follows:

// Get all files with the suffix PHP 
$files = glob( '*.php'); 

print_r($files); 
/* Output: 
Array 
( 
 [0] => phptest.php 
 [ 1] => pi.php 
 [2] => post_output.php 
 [3] => test.php 
) */
You can also search for multiple suffixes
// Get PHP files and TXT files 
$files = glob('*.{php,txt}', GLOB_BRACE); 

print_r($files); 
/* Output: 
Array 
( 
 [0] => phptest.php 
 [1] => pi.php 
 [2] => post_output.php 
 [3] => test.php 
 [4] => log.txt 
 [5] => test.txt 
) 
*/

You still have You can add the path:

Copy the code The code is as follows:

$files = glob('../images/a* .jpg'); 

print_r($files); 
/* Output: 
Array 
( 
 [0] => ../images/apple.jpg 
 [1] => ../images/art.jpg 
) 
*/

If you want to get the absolute path, you can call the realpath() function:

Copy code The code is as follows:

$files = glob('../images/a*.jpg'); 

// applies the function to each array element 
$files = array_map('realpath',$files); 

print_r($files); 
/* output looks like: 
Array 
( 
 [0] => C:/wamp/www/images/apple.jpg 
 [1] => C:/wamp/www/images/art.jpg 
) 
*/

3. Memory usage information
Observing the memory usage of your program allows you to better optimize your code.
PHP has a garbage collection mechanism and a very complex memory management mechanism. You can find out how much memory your script is using. To know the current memory usage, you can use the memory_get_usage() function. If you want to know the peak memory usage, you can call the memory_get_peak_usage() function.

Copy code The code is as follows:

echo "Initial: ".memory_get_usage()." bytes /n"; 
/* Output
Initial: 361400 bytes 
*/

// Use memory 
for ($i = 0; $i < 100000; $i++) { 
 $array []= md5($i); 
} 

// Delete half of the memory 
for ($i = 0; $i < 100000; $i++) { 
 unset($array[$i]); 
} 

echo "Final: ".memory_get_usage ()." bytes /n"; 
/* prints 
Final: 885912 bytes 
*/

echo "Peak: ".memory_get_peak_usage()." bytes /n"; 
/* Output peak value
Peak: 13687072 bytes 
*/

4. CPU usage information
Use the getrusage() function to let you know CPU usage. Note that this feature is not available under Windows.

Copy code The code is as follows:

print_r(getrusage()); 
/* Output
Array 
( 
 [ru_oublock] => 0 
 [ru_inblock] => 0 
 [ru_msgsnd] => 2 
 [ru_msgrcv] => 3 
 [ru_maxrss] = > 12692 
 [ru_ixrss] => 764 
 [ru_idrss] => 3864 
 [ru_minflt] => 94 
 [ru_majflt] => 0 
 [ru_nsign als] = > 1 
 [ru_nvcsw] => 67 
 [ru_nivcsw] => 4 
 [ru_nswap] => 0 
 [ru_utime.tv_usec] => .tv_sec] => 0 
 [ru_stime.tv_usec] => 6269 
 [ru_stime.tv_sec] => 0 
) 

*/

This structure seems very obscure, unless you know the CPU very well. Some explanations below:
ru_oublock: block output operation
ru_inblock: block input operation
ru_msgsnd: sent message
ru_msgrcv: received message
ru_maxrss: maximum resident set size
ru_ixrss: Total shared memory size
ru_idrss: Total non-shared memory size
ru_minflt: Page recycling
ru_majflt: Page invalidation
ru_nsignals: Signals received
ru_nvcsw: Active context switch
ru_nivcsw: Passive context switching
ru_nswap: Swap area
ru_utime.tv_usec: User mode time (microseconds)
ru_utime.tv_sec: User mode time (seconds)
ru_stime.tv_usec: System kernel time (microseconds) )
ru_stime.tv_sec: System kernel time? (seconds)

To see how much CPU your script consumes, we need to look at the values of "User Mode Time" and "System Kernel Time" . The seconds and microseconds parts are provided separately. You can divide the microseconds value by 1 million and add it to the seconds value to get the number of seconds with a fractional part.

Copy code The code is as follows:

// sleep for 3 seconds (non-busy) 
sleep(3) ; 

$data = getrusage(); 
echo "User time: ". 
 ($data['ru_utime.tv_sec'] + 
 $data['ru_utime.tv_usec'] / 1000000); 
echo "System time: ". 
 ($data['ru_stime.tv_sec'] + 
 $data['ru_stime.tv_usec'] / 1000000); 

 /* Output 
User time: 0.011552 
System time: 0 
*/

sleep does not occupy system time. We can look at the following example:

Copy code The code is as follows:

// loop 10 million times (busy) 
for($i=0;$ i<10000000;$i++) { 

} 

$data = getrusage(); 
echo "User time: ". 
 ($data['ru_utime.tv_sec' ] + 
 $data['ru_utime.tv_usec'] / 1000000); 
echo "System time: ". 
 ($data['ru_stime.tv_sec'] + 
 $data['ru_stime .tv_usec'] / 1000000); 

/* Output 
User time: 1.424592 
System time: 0.004204 
*/

This took about 14 Seconds of CPU time, almost all of which is user time since there are no system calls.
System time is the time the CPU spends executing kernel instructions on system calls. Here is an example:

Copy the code The code is as follows:

$start = microtime(true); 
// keep calling microtime for about 3 seconds 
while(microtime(true) - $start < 3) { 

} 

$data = getrusage(); 
echo "User time: ". 
 ($data['ru_utime.tv_sec'] + 
 $data['ru_utime.tv_usec'] / 1000000); 
echo "System time: ". 
 ($data['ru_stime.tv_sec'] + 
 $data['ru_stime.tv_usec'] / 1000000); 

/ * prints 
User time: 1.088171 
System time: 1.675315 
*/

We can see that the above example consumes more CPU.

5. System constants
PHP provides very useful system constants that allow you to get the current line number (__LINE__), file (__FILE__), directory (__DIR__), and function name (__FUNCTION__) , class name (__CLASS__), method name (__METHOD__) and namespace (__NAMESPACE__), much like C language.

We can think that these things are mainly used for debugging, but not necessarily. For example, we can use ?__FILE__ when including other files (of course, you can also use __DIR__ after PHP 5.3), as follows is an example.

Copy code The code is as follows:

// this is relative to the loaded script's path 
// it may cause problems when running scripts from different directories 
require_once('config/database.php'); 

// this is always relative to this file's path 
// no matter where it was included from 
require_once(dirname(__FILE__) . '/config/database.php');

The following is using __LINE__ to output some debug information, which will help you debug the program:

Copy code The code is as follows:

// some code 
// ... 
my_debug("some debug message", __LINE__); 
/* Output
Line 4: some debug message 
*/

// some more code 
// ... 
my_debug( "another debug message", __LINE__); 
/* Output
Line 11: another debug message 
*/

function my_debug($msg, $line) { 
 echo " Line $line: $msg/n"; 
}

6. Generate a unique ID
Many people use md5() to generate a unique ID, as shown below:
// generate unique string
echo md5(time() . mt_rand(1,1000000));
In fact, there is a function called uniqid() in PHP that is specially used for Here to do this:

Copy code The code is as follows:

// generate unique string 
echo uniqid(); 
/* Output 
4bd67c947233e 
*/

// generate another unique string 
echo uniqid(); 
/* Output 
4bd67c9472340 
*/ 

You may notice that the first few digits of the generated ID are the same. This is because the generator depends on the system time. This is actually a very good feature because it is easy for you to Sort these IDs for you. MD5 cannot do this.
You can also add a prefix to avoid duplication of names:

Copy the code The code is as follows:

// Prefix
echo uniqid('foo_'); 
/* output
foo_4bd67d6cd8b8f 
*/

// has more entropy
echo uniqid('',true); 
/* Output 
4bd67d6cd8b926.12135106 
*/

// Both have 
echo uniqid('bar_',true); 
/* Output 
bar_4bd67da367b650. 43684647 
*/

Moreover, the generated ID will be shorter than that generated by MD5, which will save you a lot of space.

7. Serialization
Will you save a more complex data structure into a database or file? You don't need to write your own algorithm. PHP has already done it for you. It provides two functions: serialize() and unserialize():

Copy code The code is as follows:

//A complex array
$myvar = array( 
 'hello', 
 42, 
 array(1,'two'), 
 'apple' 
); 

// Serialization
$string = serialize($myvar); 

echo $string; 
/* Output
a:4: {i:0;s:5:"hello";i:1;i:42;i:2;a:2:{i:0;i:1;i:1;s:3:"two"; }i:3;s:5:"apple";} 
*/

// Deserialization
$newvar = unserialize($string); 

print_r ($newvar); 
/* Output
Array 
( 
 [0] => hello 
 [1] => 42 
 [2] => Array 
 ( 
 [0] => 1 
 [1] => two 
 ) 

 [3] => apple 
) 
*/

This is a native function of PHP. However, JSON is becoming more and more popular today, so after PHP5.2, PHP begins to support JSON. You can use the json_encode() and json_decode() functions

Copy code The code is as follows:

// a complex array 
$myvar = array( 
 'hello', 
 42, 
 array(1,'two'), 
 'apple'
); 

// convert to a string 
$string = json_encode($myvar) ; 

echo $string; 
/* prints 
["hello",42,[1,"two"],"apple"] 
*/

 // you can reproduce the original variable 
$newvar = json_decode($string); 

print_r($newvar); 
/* prints 
Array 
( 
 [ 0] => hello 
 [1] => 42 
 [2] => Array 
 ( 
 [0] => 1 
 [1] => two 
 ) 

 [3] => apple 
) 
*/

This looks more compact and is also compatible with Javascript and other languages. But for some very complex data structures, data loss may occur.

8. String compression
When we talk about compression, we may think of file compression. In fact, strings can also be compressed. PHP provides gzcompress() and gzuncompress() functions:

Copy code The code is as follows:

$string = 
 "Lorem ipsum dolor sit amet, consectetur 
adipiscing elit. Nunc ut elit id mi ultricies 
adipiscing. lacus quis ante. Lorem ipsum dolor 
sit amet, consectetur adipiscing elit. Aliquam 
pretium ullamcorper urna quis iaculis. Sed magna nisi, ornare in mollis in, mollis 
sed nunc. Etiam at justo in leo congue mollis. 
Nullam in neque eget metus hendrerit scelerisque 
eu non enim. >$compressed = gzcompress($string); 

echo "Original size: ". strlen($string)."/n"; 
/* Output original size
Original size: 800 
*/

echo "Compressed size: ". strlen($compressed)."/n"; 
/* Output the compressed size
Compressed size: 418 
*/ 

//Decompress 
$original = gzuncompress($compressed);


Almost 50% compression ratio. At the same time, you can also use the gzencode() and gzdecode() functions to compress, just using different compression algorithms. 



9. Register shutdown function 

There is a function called register_shutdown_function() that allows you to run code before the entire script is shut down. Let’s look at an example below: 

Copy the code
The code is as follows:

// capture the start time $ start_time = microtime(true);

// do some stuff // ... // display how long the script took echo "execution took: ".

(microtime(true) - $start_time).

" seconds.";

The above example is just used to calculate the running time of a certain function. Then, if you call the exit() function in the middle of a function, your final code will not be run. Also, if the script is terminated in the browser (the user presses the stop button), it cannot be run.
When we use register_shutdown_function(), your program will be run even after the script is stopped:

Copy the code The code is as follows :

$start_time = microtime(true); 

register_shutdown_function('my_shutdown'); 

// do some stuff 
// ... 

function my_shutdown() { 
 global $start_time; 

 echo "execution took: ". 
 (microtime(true) - $start_time). 
 " " seconds. "; 
}