8 fonctions essentielles au développement PHP

[Introduction] Les programmeurs qui ont fait du développement PHP doivent savoir qu'il existe de nombreuses fonctions intégrées dans PHP. Les maîtriser peut vous aider à devenir plus à l'aise dans le développement PHP. Cet article partagera 8 fonctions PHP essentielles pour le développement. certains d'entre eux sont très pratiques, j'espère que tous les développeurs PHP pourront les maîtriser. 1. Passez un certain nombre de fonctions

Les programmeurs qui ont développé PHP doivent savoir qu'il existe de nombreuses fonctions intégrées dans PHP. Les maîtriser peut vous aider à devenir plus à l'aise dans le développement PHP. Cet article partagera 8 Tous. des fonctions PHP nécessaires au développement sont très pratiques. J'espère que tous les développeurs PHP pourront les maîtriser.

1. Passez n'importe quel nombre de paramètres de fonction

Nous sommes en programmation .NET ou JAVA, Généralement, le nombre de paramètres de fonction est fixe, mais PHP vous permet d'utiliser n'importe quel nombre de paramètres. L'exemple suivant vous montre les paramètres par défaut des fonctions PHP :

// 两个默认参数的函数  
function foo($arg1 = ”, $arg2 = ”) {  
echo “arg1: $arg1\n”;  
echo “arg2: $arg2\n”;  
}  
foo(‘hello’,'world’);  
/* 输出: 
arg1: hello 
arg2: world 
*/  
foo();  
/* 输出: 
arg1: 
arg2: 
*/  
下面这个示例是PHP的不定参数用法，其使用到了 func_get_args()方法：  
// 是的，形参列表为空  
function foo() {  
// 取得所有的传入参数的数组  
$args = func_get_args();  
foreach ($args as $k => $v) {  
echo “arg”.($k+1).”: $v\n”;  
}  
}  
foo();  
/* 什么也不会输出 */  
foo(‘hello’);  
/* 输出 
arg1: hello 
*/  
foo(‘hello’, ‘world’, ‘again’);  
/* 输出 
arg1: hello 
arg2: world 
arg3: again 
*/

2. Utilisez glob() pour rechercher des fichiers

Les noms de fonction de la plupart des fonctions PHP peuvent être compris littéralement Objectif, mais quand vous voyez glob(), vous ne savez peut-être pas à quoi il sert. En fait, glob() est identique à scandir() et peut être utilisé pour rechercher des fichiers. Veuillez consulter l'utilisation suivante :

// 取得所有的后缀为PHP的文件  
$files = glob(‘*.php’);  
print_r($files);  
/* 输出: 
Array 
( 
[0] => phptest.php 
[1] => pi.php 
[2] => post_output.php 
[3] => test.php 
) 
*/

Vous pouvez également rechercher plusieurs suffixes :

// 取PHP文件和TXT文件  
$files = glob(‘*.{php,txt}’, GLOB_BRACE);  
print_r($files);  
/* 输出: 
Array 
( 
[0] => phptest.php 
[1] => pi.php 
[2] => post_output.php 
[3] => test.php 
[4] => log.txt 
[5] => test.txt 
) 
*/

Vous pouvez également ajouter le chemin :

$files = glob(‘../images/a*.jpg’);  
print_r($files);  
/* 输出: 
Array 
( 
[0] => ../images/apple.jpg 
[1] => ../images/art.jpg 
) 
*/

Si vous souhaitez des chemins absolus, vous pouvez appeler la fonction realpath() :

$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. Obtenez des informations sur l'utilisation de la mémoire

Le mécanisme de recyclage de la mémoire de PHP est déjà très puissant. Vous pouvez également utiliser des scripts PHP pour obtenir le For actuel. l'utilisation de la mémoire, appelez la fonction memory_get_usage() pour obtenir l'utilisation actuelle de la mémoire et appelez la fonction memory_get_peak_usage() pour obtenir l'utilisation maximale de la mémoire. Le code de référence est le suivant :

echo “Initial: “.memory_get_usage().” bytes \n”;  
/* 输出 
Initial: 361400 bytes 
*/  
// 使用内存  
for ($i = 0; $i < 100000; $i++) {  
$array []= md5($i);  
}  
// 删除一半的内存  
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”;  
/* 输出峰值 
Peak: 13687072 bytes 
*/

4. Obtenir les informations sur l'utilisation du processeur

a obtenu l'utilisation de la mémoire. Vous pouvez également utiliser getrusage() de PHP pour obtenir l'utilisation du processeur. est disponible sous Windows Non disponible.

print_r(getrusage());  
/* 输出 
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_nsignals] => 1 
[ru_nvcsw] => 67 
[ru_nivcsw] => 4 
[ru_nswap] => 0 
[ru_utime.tv_usec] => 0 
[ru_utime.tv_sec] => 0 
[ru_stime.tv_usec] => 6269 
[ru_stime.tv_sec] => 0 
) 
*/

Cette structure semble très obscure, à moins de connaître très bien le CPU. Voici quelques explications :

• ru_oublock : opération de sortie de bloc

• ru_inblock : opération d'entrée de bloc

• ru_msgsnd : message envoyé

• ru_msgrcv : message reçu

• ru_maxrss : taille maximale définie pour les résidents

• ru_ixrss : Taille totale de la mémoire partagée

• ru_idrss : Taille totale de la mémoire non partagée

• ru_minflt : Recyclage des pages

• ru_majflt : Page invalide

• ru_nsignals : Signaux reçus

• ru_nvcsw : Changement de contexte actif

• ru_nivcsw : changement de contexte passif

• ru_nswap : zone d'échange

• ru_utime.tv_usec : temps du mode utilisateur (microsecondes))

• ru_utime.tv_sec : Temps du mode utilisateur (secondes)

• ru_stime.tv_usec : Temps du noyau système (microsecondes)

• ru_stime.tv_sec : Temps du noyau système ? (secondes)

Pour voir combien de CPU votre script consomme, nous devons examiner le "temps du mode utilisateur" et le valeur de « Temps du noyau système ». Les parties secondes et microsecondes sont fournies séparément. Vous pouvez diviser la valeur en microsecondes par 1 million et l'ajouter à la valeur en secondes pour obtenir le nombre de secondes avec une partie fractionnaire.

// 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);  
/* 输出 
User time: 0.011552 
System time: 0 
*/

la veille ne prend pas de temps système, on peut regarder l'exemple suivant :

// loop 10 million times (busy)  
for($i=0;$i<10000000;$i++) {  
}  
$data = getrusage();  
echo “User time: “.  
($data[&#39;ru_utime.tv_sec&#39;] +  
$data[&#39;ru_utime.tv_usec&#39;] / 1000000);  
echo “System time: “.  
($data[&#39;ru_stime.tv_sec&#39;] +  
$data[&#39;ru_stime.tv_usec&#39;] / 1000000);  
/* 输出 
User time: 1.424592 
System time: 0.004204 
*/

Cela a pris environ 14 secondes de temps CPU, presque tout le temps de l'utilisateur depuis il n'y a pas d'appels système.

Le temps système est le temps que le processeur passe à exécuter les instructions du noyau lors des appels système. Voici un exemple :

$start = microtime(true);  
// keep calling microtime for about 3 seconds  
while(microtime(true) – $start < 3) {  
}  
$data = getrusage();  
echo “User time: “.  
($data[&#39;ru_utime.tv_sec&#39;] +  
$data[&#39;ru_utime.tv_usec&#39;] / 1000000);  
echo “System time: “.  
($data[&#39;ru_stime.tv_sec&#39;] +  
$data[&#39;ru_stime.tv_usec&#39;] / 1000000);  
/* prints 
User time: 1.088171 
System time: 1.675315 
*/

On voit que l'exemple ci-dessus consomme plus de CPU.

5. Obtenir les constantes système

PHP fournit des constantes système très utiles qui vous permettent d'obtenir le numéro de ligne actuel (__LINE__), le fichier (__FILE__), le répertoire (__DIR__) et le nom de la fonction ( __FUNCTION__ ), nom de classe (__CLASS__), nom de méthode (__METHOD__) et espace de noms (__NAMESPACE__), un peu comme le langage C.

Nous pouvons penser que ces éléments sont principalement utilisés pour le débogage, mais pas nécessairement. Par exemple, nous pouvons utiliser ?__FILE__ pour inclure d'autres fichiers (bien sûr, vous pouvez également utiliser __DIR__ après PHP 5.3), comme suit. est un exemple.

// 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’);

Ce qui suit utilise __LINE__ pour générer des informations de débogage, qui vous aideront à déboguer le programme :

// some code  
// …  
my_debug(“some debug message”, __LINE__);  
/* 输出 
Line 4: some debug message 
*/  
// some more code  
// …  
my_debug(“another debug message”, __LINE__);  
/* 输出 
Line 11: another debug message 
*/  
function my_debug($msg, $line) {  
echo “Line $line: $msg\n”;  
}

6. Générer un identifiant unique

Plusieurs. mes amis utilisent md5() pour générer des nombres uniques, mais md5() présente plusieurs inconvénients : 1. Désordre, ce qui entraîne une diminution des performances de tri dans la base de données. 2. Trop long et nécessite plus d'espace de stockage. En fait, PHP est livré avec une fonction pour générer un identifiant unique. Cette fonction est uniqid(). Voici l'utilisation :

// generate unique string  
echo uniqid();  
/* 输出 
4bd67c947233e 
*/  
// generate another unique string  
echo uniqid();  
/* 输出 
4bd67c9472340 
*/

Cet algorithme est généré sur la base de l'horodatage du processeur, donc dans une période de temps similaire, les premiers chiffres de l'ID sont les mêmes, ce qui est également pratique pour trier les ID, si vous le souhaitez Pour mieux éviter la duplication, vous pouvez ajouter un préfixe avant l'identifiant, tel que :

// 前缀  
echo uniqid(‘foo_’);  
/* 输出 
foo_4bd67d6cd8b8f 
*/  
// 有更多的熵  
echo uniqid(”,true);  
/* 输出 
4bd67d6cd8b926.12135106 
*/  
// 都有  
echo uniqid(‘bar_’,true);  
/* 输出 
bar_4bd67da367b650.43684647 
*/

Sérialisation

.

PHP序列化功能大家可能用的比较多，也比较常见，当你需要把数据存到数据库或者文件中是，你可以利用PHP中的serialize() 和 unserialize()方法来实现序列化和反序列化，代码如下： 

// 一个复杂的数组  
$myvar = array(  
‘hello’,  
42,  
array(1,’two’),  
‘apple’  
);  
// 序列化  
$string = serialize($myvar);  
echo $string;  
/* 输出 
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”;} 
*/  
// 反序例化  
$newvar = unserialize($string);  
print_r($newvar);  
/* 输出 
Array 
( 
[0] => hello 
[1] => 42 
[2] => Array 
( 
[0] => 1 
[1] => two 
) 
[3] => apple 
) 
*/

如何序列化成json格式呢，放心，php也已经为你做好了，使用php 5.2以上版本的用户可以使用json_encode() 和 json_decode() 函数来实现json格式的序列化，代码如下： 

// 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 
) 
*/

8、字符串压缩 

当我们说到压缩，我们可能会想到文件压缩，其实，字符串也是可以压缩的。PHP提供了 gzcompress() 和gzuncompress() 函数： 

$string =  
“Lorem ipsum dolor sit amet, consectetur  
adipiscing elit. Nunc ut elit id mi ultricies  
adipiscing. Nulla facilisi. Praesent pulvinar,  
sapien vel feugiat vestibulum, nulla dui pretium orci,  
non ultricies elit lacus quis ante. Lorem ipsum dolor  
sit amet, consectetur adipiscing elit. Aliquam  
pretium ullamcorper urna quis iaculis. Etiam ac massa  
sed turpis tempor luctus. Curabitur sed nibh eu elit  
mollis congue. Praesent ipsum diam, consectetur vitae  
ornare a, aliquam a nunc. In id magna pellentesque  
tellus posuere adipiscing. Sed non mi metus, at lacinia  
augue. 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. Ut malesuada lacus eu nulla bibendum  
id euismod urna sodales. “;  
$compressed = gzcompress($string);  
echo “Original size: “. strlen($string).”\n”;  
/* 输出原始大小 
Original size: 800 
*/  
echo “Compressed size: “. strlen($compressed).”\n”;  
/* 输出压缩后的大小 
Compressed size: 418 
*/  
// 解压缩  
$original = gzuncompress($compressed);

几乎有50% 压缩比率。同时，你还可以使用 gzencode() 和 gzdecode() 函数来压缩，只不用其用了不同的压缩算法。 

以上就是8个开发必备的PHP功能，是不是都很实用呢？

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!