Donc, qu'est-ce qu'une fonction ?PHP?

Fonction - Il s'agit d'un mini-programme qui effectue des actions utiles et produit un résultat final.
Regardons le schéma :

Essayons d'écrire un mini-programme en utilisant un modèle de fonction prêt à l'emploi.
Modèle de fonction prêt :

Disons que nous devons écrire une fonction capable de calculer la somme des nombres 5 et 2. Nous regardons le modèle et écrivons :

Analysons le code.
la fonction suma() est une fonction nommée suma ;
écho 5 + 2 ; - dans le corps de la fonction nous avons indiqué qu'il faut additionner les nombres 5 et 2 (5 + 2) ;
somme(); - appelle la fonction. Appeler une fonction signifie l’exécuter. C'est-à-dire que le problème 5 + 2 doit être complété et donner un résultat de 7.

Essayons maintenant d'examiner les fonctions étape par étape.

Étapes de création d'une fonction en PHP

Scèneje. Création d'une fonction
N'oubliez pas le modèle de fonction prêt à l'emploi :

C'est ainsi qu'une fonction est créée en PHP.
Écrivons le texte " Je suis heureux de vous voir sur le site du blog».
N'oubliez pas : nous écrivons le texte en utilisant .

"; } ?>

Vous devez maintenant appeler la fonction « site() ».

ScèneII. Appel d'une fonction prête surPHP
La fonction a été créée et doit maintenant être exécutée. Pour exécuter et afficher une fonction, spécifiez simplement « function name(); »

site web();

Il ressemblera à ceci:

"; )site(); ?>

Vous pouvez procéder ainsi :

"; ) ?> Beaucoup de texte…..Beaucoup de texte.....

Entrez l'adresse dans votre navigateur :

Résultat:

Fonctions PHP avec arguments

Tous les exemples avec les fonctions ci-dessus étaient sans arguments. Je vais vous expliquer ce qu'est un argument dans le code :

J'ai donc créé une fonction appelée "site". Dans les paramètres (là où se trouvent les parenthèses), j'ai écrit deux variables $a et $b séparées par des virgules.

Site de fonction ($a, $b)

$a et $b sont les deux arguments.
écho "$a + $b = "; – ici, j'ai affiché le texte sur le moniteur. Résultat : 5 + 5 =
écho $a + $b; – ici j'ai indiqué à la fonction que les variables $a et $b doivent être additionnées.
site (15, 5); – appelé la fonction. Attention : entre parenthèses j'ai indiqué deux arguments (15, 5) qu'attendent les variables $a et $b. La variable $a recevra le premier argument - 15 , $b - le second 5 .

Pour ceux qui ne comprennent pas où l'argument est substitué et dans quel ordre, voici le schéma :

Donc le code fini :

Enregistrez sous "function.php" dans le dossier "test-1" du serveur local (voir leçon 1).

Entrez l'adresse dans votre navigateur :

https://localhost/test-1/function.php

Résultat:

Permettez-moi de compliquer un peu la fonction et de la rendre plus intéressante. J'ajouterai l'adresse du blog à l'argument et j'écrirai le nom du lien.

La fonction appelée « site » recevra l'argument https://site/ dans la variable $link, et la variable $title recevra le texte du lien - « Site blog – création de site internet !»

Code prêt :

Enregistrez sous "function.php" dans le dossier "test-1" du serveur local (voir leçon 1).

Entrez l'adresse dans votre navigateur.

Une fonction est un bloc de code nommé, dans ce cas en PHP, qui est défini une fois et peut ensuite être appelé pour exécution autant de fois que souhaité.

Une fonction est définie à l'aide du mot-clé function suivi des composants suivants :

• Un identifiant qui spécifie le nom de la fonction. Il servira à créer une nouvelle variable à laquelle la fonction sera affectée. Les noms de fonctions suivent les mêmes règles que la dénomination des variables.

  Remarque : Les noms de fonctions ne sont pas sensibles à la casse.

• Une paire de parenthèses autour d'une liste de zéro ou plusieurs identifiants, séparés par des virgules. Ces identifiants définiront les noms des paramètres de la fonction. Elles sont utilisées comme variables locales dans le corps de la fonction.
• Une paire d'accolades avec zéro ou plusieurs instructions. Ces instructions constituent le corps de la fonction : elles sont exécutées à chaque appel de la fonction.

La syntaxe pour définir une fonction est la suivante :

Fonction nom_fonction([paramètres]) ( bloc de code )

Les crochets () indiquent facultatif. Donnons maintenant un exemple simple de définition de fonction :

Pour appeler une fonction, un opérateur d'appel est utilisé, qui est une paire de parenthèses. L'appel de fonction, comme toutes les instructions, se termine par un point-virgule (;) :

Lorsqu'une fonction est appelée, les instructions situées dans son corps sont exécutées.

Les fonctions peuvent être définies n'importe où dans le programme, ce qui signifie qu'il n'est pas nécessaire de les définir avant d'être utilisées. à l'exclusion le cas où les fonctions sont définies conditionnellement :

Toutes les fonctions de PHP ont une portée mondiale- ils peuvent être appelés en dehors de la fonction, même s'ils ont été définis à l'intérieur et vice versa :

Le plus souvent, les fonctions fonctionnent avec toutes les valeurs qui leur sont transmises. Pour qu’une fonction puisse transmettre certaines valeurs, elle doit contenir des paramètres. Ces paramètres sont essentiellement des variables ordinaires qui sont initialisées avec les valeurs transmises lors de l'appel de la fonction.

La note: La version adaptative du site est activée, qui s'adapte automatiquement à la petite taille de votre navigateur et masque certains détails du site pour en faciliter la lecture. Bon visionnage !

Bonjour à tous. Avec l'article d'aujourd'hui, nous continuons à plonger dans les profondeurs de PHP, mais pas seulement. A la fin de cet article, vous trouverez une grille de mots croisés, en résolvant laquelle vous pouvez obtenir de 500 à 1500 roubles Tous les détails, et nous continuons à apprendre.

Qu'est-ce qu'une fonction ?

Fonction est un morceau de code qui peut être exécuté de manière répétée à divers endroits dans un script PHP (notre page).

Syntaxe:

Function siteOn())( // corps de la fonction echo "Bonjour à tous les lecteurs du site sur le blog !"; )

Où siteSur– il s'agit d'un nom de fonction arbitraire, il n'est pas sensible à la casse. La fonction dans l'exemple ci-dessus génère le texte donné. Lorsque l'interpréteur PHP traite le code, il ne voit que la déclaration de la fonction, sans son corps, et ne l'exécute bien entendu pas. Le corps de la fonction est stocké en mémoire jusqu'à la fin du script PHP, c'est-à-dire jusqu'au chargement de la page.

Après avoir écrit une fonction, notre tâche est de l'appeler aux endroits dont nous avons besoin. Voici comment procéder :

"; ) siteOn(); // appel de la fonction siteOn(); // appel de la fonction siteOn(); // appel de la fonction ?>

Dans l’exemple ci-dessus, nous avons appelé la fonction 3 fois, et voici le résultat :

Pourquoi les fonctions sont-elles nécessaires ?

Il semblerait que cela fonctionne, et alors ? On pourrait simplement écrire cette ligne 3 fois sans fonction. Nous pourrions, mais si nous voulons soudainement changer quelque chose dans ce fragment, nous devrons alors le changer à un seul endroit, et non à trois. Mais ce n'est pas tout! Nous avons maintenant envisagé une option simple, lorsque tout est à proximité et dans un seul fichier. Dans la vraie vie, un fichier peut contenir des milliers de lignes et elles peuvent être dispersées de manière chaotique dans le fichier.

C'est une chose d'entrer et de tout changer dans une seule fonction, c'en est une autre de le changer à 10 endroits et même de rechercher dans tout le fichier. Mais ce n'est pas tout! Les sites Web ne sont pas constitués d'un seul fichier ; nous pourrions avoir besoin d'un morceau de code dans des dizaines de fichiers différents, et nous devrions rechercher toutes les répétitions de ce code pendant beaucoup de temps. Grâce aux fonctions, on sait que par exemple on stocke toutes les fonctions dans tel ou tel fichier, je vais y aller et le changer une fois.

Autrement dit, vous pouvez prendre la règle suivante : si une section du code est répétée, alors assurez-vous d'en faire une fonction !

Contrôle d'existence

En PHP, vous ne pouvez pas déclarer deux fois la même fonction. Par exemple, si vous écrivez :

// n'importe quel code ou sans) fonction siteOn() ( // n'importe quel code ou sans } ?>

Ensuite, nous obtenons l'erreur suivante. Au fait, rappelez-vous toutes les erreurs typiques :

Impossible de redéclarer siteOn() (précédemment déclaré dans Z:\home\custom\www\index.php:3) dans Z:\home\custom\www\index.php à la ligne 9

Cette erreur indique que nous avons déjà déclaré une telle fonction, et elle indique même dans quel fichier et ligne nous l'avons déjà fait. Veuillez noter que PHP possède plusieurs milliers de fonctions intégrées, cette situation peut donc facilement survenir lors de votre développement.

Pour savoir si une telle fonction existe déjà ou non, vous pouvez utiliser la fonction intégrée function_exists(). Exemple:

// n'importe quel code ou sans) if(function_exists("siteOn"))( echo "Cette fonction existe déjà !"; ) ?>

Résultat:

Personnellement, je n'utilise jamais cette fonctionnalité, mais vous devriez la connaître.

Arguments de fonction

Un argument d’une fonction peut également être appelé son paramètre. Cela ressemble à ceci :

Dans l'exemple ci-dessus, l'argument de la fonction est une variable $auteur. Comment peut-il être utilisé? Lors de l’appel de fonctions, nous pouvons y transmettre la valeur de l’argument. Cela confère à nos fonctions une flexibilité et une dynamique sans précédent :

"; ) siteOn("Sergey"); // première méthode $name = "Andrey"; // deuxième méthode siteOn($name); siteOn(); // n'envoie rien ?>

Résultat:

Comme vous pouvez le voir, lorsque nous ne transmettions pas d'argument, nous obtenions une erreur du type Avertissement, après quoi l'exécution de notre script PHP s'est quand même poursuivie. Encore une fois, l'erreur contient des informations très détaillées sur l'endroit où tout cela s'est produit. L'avertissement est une erreur grave et ne peut être ignoré.

Une fonction peut avoir n'importe quel nombre d'arguments, par exemple :

"; ) siteOn("Sergey", "Site on!"); // première méthode $name = "Andrey"; // deuxième méthode siteOn($name, "Sweet Tooth"); siteOn("Fyodor Ivanov"); // n'a passé qu'un seul argument ?>

Résultat:

Appels de fonctions non standard

Quelques subtilités. Personne n'utilise généralement la méthode suivante pour appeler des fonctions, et je ne vous conseille pas non plus de le faire, mais vous devriez le savoir. Regardons:

"; ) $text = "siteOn"; // met le nom de la fonction dans une variable$text("Sergey", "Site activé !"); // appelle la fonction via une variable ?>

Le résultat sera comme d'habitude :

Exemple pratique d'utilisation de fonctions

Vous vous souvenez de la table de multiplication de la précédente ? Là nous avons 2 paramètres : nombre de lignes Et le nombre de colonnes, que nous définissons dans les variables. Il est temps de créer une fonction complète à partir de ce code qui prendra les deux valeurs ci-dessus !

Je laisserai tout le code de la leçon précédente inchangé, sauf que maintenant nous n'avons plus besoin de définir le nombre de lignes et de colonnes, nous le ferons lors de l'appel de la fonction :

// a commenté ces 2 lignes, puisque la quantité est désormais passée lors de l'appel de la fonction // $lignes = 20 ; // nombre de lignes, tr // $cols = 20 ; // nombre de colonnes, td$table = "

Résultat:

Arguments par défaut

Lors de la création d'une fonction, nous pouvons attribuer des valeurs par défaut à des arguments arbitraires. Les arguments qui ont des valeurs par défaut peuvent être omis lors de l'appel d'une fonction et ce ne sera pas une erreur. Car au lieu de l’argument manquant, la fonction remplacera automatiquement la valeur par défaut. Exemple:

"; ) siteOn("Sergey"); ?>

Dans cet exemple, nous argumentons $blog valeur par défaut assignée Site activé ! Ensuite, ils ont appelé la fonction avec un seul argument, et le second a utilisé sa valeur par défaut.

Résultat:

les arguments par défaut sont toujours écrits en dernier.

En d'autres termes : les arguments requis (sans valeur par défaut) doivent apparaître en premier de gauche à droite, suivis des arguments qui ont une valeur par défaut.

Indice:
Pour obtenir une liste complète des fonctions PHP intégrées, dans la colonne de droite, cliquez sur le bouton Rechercher lorsque la ligne de recherche « Recherche PHP » est vide.
Si vous voulez en savoir plus description avec un exemple précis Fonctions PHP précisez-le dans la ligne de recherche PHP. →

Il existe deux formes principales de fonctions en PHP : intégrées et définies par l'utilisateur.

Le mot-clé est utilisé pour définir une fonction personnalisée fonction.

Exemple 1

Depuis PHP 4.0, vous pouvez utiliser les valeurs d'argument par défaut.

Exemple 2

RÉSULTAT DES EXEMPLES 1-2 :

Chapitre

Chapitre

Note: Le code ci-dessous ne fonctionnera pas comme prévu. La variable $full sera vraie dans tous les cas.

Amusant($ar, false); fonction fun($row, $full = true)( ... )

Passer un argument par référence

Exemple 3

RÉSULTAT DE L'EXEMPLE 3 :

Af = 10 ; bf = 6 Après appel de la fonction : af = 16; petit-déjeuner = 6

Valeurs de retour

Pour renvoyer les valeurs d'une fonction, utilisez l'opérateur retour. Vous pouvez renvoyer plusieurs valeurs si vous appliquez une liste liste().

Exemple 4

RÉSULTAT DE L'EXEMPLE 4 :

Fonctions dynamiques

En PHP, vous pouvez utiliser fonctions dynamiques. Cela signifie que si une variable reçoit le nom d’une fonction, alors cette variable peut être traitée exactement de la même manière que la fonction elle-même.

Exemple 5

RÉSULTAT DE L'EXEMPLE 5 :

Nous sommes à l’intérieur de la fonction funct1(); Nous sommes à l’intérieur de la fonction funct2();

Variables globales

Pour qu'une variable créée en dehors d'une fonction soit disponible à l'intérieur de la fonction, vous devez la déclarer globale à l'aide de l'instruction mondial.

Exemple 6

RÉSULTAT DE L'EXEMPLE 6 :

La variable globale a la valeur - 45

Variables statiques

Pour qu'une variable conserve sa valeur entre les appels de fonction, vous devez la déclarer statique à l'aide de l'instruction statique.

Exemple 7

La variable $ss a été créée et initialisée. Cette variable restera locale à la fonction funct(). Lors du deuxième appel à funct() et des suivants, l'initialisation est ignorée et la dernière valeur attribuée est mémorisée.

RÉSULTAT DE L'EXEMPLE 7 :

1. Lundi

Le roi se promenait dans le parc

2. Mardi

Le roi chassait

Peu importe à quel point nous utilisons PHP, certaines fonctions apparaissent toujours dont nous n'avons même jamais entendu parler. Certains d’entre eux nous seraient très utiles. J'ai créé une petite liste de fonctions utiles qui devraient figurer dans l'arsenal de tout programmeur PHP.

1. Créer des fonctions avec un nombre variable d'arguments

Très probablement, vous savez déjà que PHP nous permet de créer des fonctions avec des arguments facultatifs. Je vais maintenant montrer une fonction dans laquelle le nombre d'arguments peut varier d'un cas à l'autre.

Mais d'abord, rappelons-nous comment nous créons des fonctions de la manière habituelle :

// fonction avec deux paramètres optionnels function foo($arg1 = "", $arg2 = "") ( echo "arg1: $arg1\n"; echo "arg2: $arg2\n"; ) foo("hello", "monde"); /* affichera : arg1: hello arg2: world */ foo(); /* affichera : arg1 : arg2 : */

Voyons maintenant comment écrire une fonction avec un nombre illimité d'arguments. Pour ce faire, utilisez la méthode func_get_args() :

// ne spécifie pas d'arguments, la fonction foo() ( // renvoie un tableau d'arguments passés $args = func_get_args(); foreach ($args as $k => $v) ( echo "arg".($k+1) ." : $v\n" ) ) foo(); /* ne produira rien */ foo("hello"); /* affichera arg1 : bonjour */ foo("hello", "world", "again"); /* affichera arg1 : bonjour arg2 : monde arg3 : encore */

2. Utilisez Glob() pour rechercher des fichiers

Souvent, les noms des fonctions parlent d’eux-mêmes. On ne peut pas en dire autant de la fonction glob().

Sans entrer dans trop de détails, sa fonctionnalité est similaire à la méthode scandir(). Il permet de trouver le fichier recherché à l'aide d'un modèle :

// trouve tous les fichiers php $files = glob("*.php"); print_r($fichiers); /* affichera : Array ( => phptest.php => pi.php => post_output.php => test.php) */

Pour trouver des fichiers de plusieurs types, vous devez écrire comme ceci :

// trouve tous les fichiers php et txt $files = glob("*.(php,txt)", GLOB_BRACE); print_r($fichiers); /* sortie : Array ( => phptest.php => pi.php => post_output.php => test.php => log.txt => test.txt) */

Vous pouvez également spécifier le chemin dans le modèle :

$files = glob("../images/a*.jpg"); print_r($fichiers); /* sortie : Array ( => ../images/apple.jpg => ../images/art.jpg) */

Pour obtenir le chemin complet d'un document, utilisez la méthode realpath() :

$files = glob("../images/a*.jpg"); // Applique la fonction "realpath" à chaque élément du tableau $files = array_map("realpath",$files); print_r($fichiers); /* affichera : Array ( => C:\wamp\www\images\apple.jpg => C:\wamp\www\images\art.jpg) */

3. Informations sur la mémoire utilisée

Si vous suivez la quantité de mémoire consommée par vos scripts, vous les optimiserez probablement plus souvent.

PHP dispose d'un puissant outil de suivi de la mémoire. Les charges peuvent être différentes dans différentes parties du script. Afin d'obtenir la valeur de la mémoire actuellement utilisée, nous devons utiliser la méthode memory_get_usage(). Pour fixer la quantité maximale de mémoire utilisée, utilisez memory_get_peak_usage()

Echo "Initial : ".memory_get_usage()." octets \n" ; /* Initial : 361 400 octets */ // donne une petite charge pour ($i = 0 ; $i< 100000; $i++) { $array = md5($i); } // и ещё for ($i = 0; $i < 100000; $i++) { unset($array[$i]); } echo "Final: ".memory_get_usage()." bytes \n"; /* Final: 885912 bytes */ echo "Peak: ".memory_get_peak_usage()." bytes \n"; /* Peak: 13687072 bytes */

4. Informations sur le processeur

Pour ce faire, vous devez utiliser la méthode getrusage(). Mais gardez à l’esprit que cette fonctionnalité ne fonctionnera pas sous Windows.

Print_r(getrusage()); /* imprime Array ( => 0 => 0 => 2 => 3 => 12692 => 764 => 3864 => 94 => 0 => 1 => 67 => 4 => 0 => 0 => 0 => 6269 => 0) */

L'image décrite ci-dessus sera claire pour ceux qui ont de l'expérience dans l'administration système. Pour tous les autres, nous proposons une transcription :

• ru_oublock : nombre d'opérations d'écriture de bloc
• ru_inblock : nombre d'opérations de lecture de bloc
• ru_msgsnd : nombre de messages envoyés
• ru_msgrcv : nombre de messages reçus
• ru_maxrss : taille maximale d'un ensemble non paginé
• ru_ixrss : quantité totale de mémoire partagée
• ru_idrss : volume total de données non partagées
• ru_minflt : nombre de pages mémoire utilisées
• ru_majflt : nombre d'erreurs de page manquante
• ru_nsignals : nombre de signaux reçus
• ru_nvcsw : nombre de changements de contexte par le processus
• ru_nivcsw : nombre de changements de contexte forcés
• ru_nswap : nombre d'accès au disque lors de la pagination
• ru_utime.tv_usec : temps de fonctionnement en mode utilisateur (microsecondes)
• ru_utime.tv_sec : temps de fonctionnement en mode utilisateur (secondes)
• ru_stime.tv_usec : temps de fonctionnement en mode privilégié (microsecondes)
• ru_stime.tv_sec : temps de fonctionnement en mode privilégié (secondes)

Afin de savoir quelles ressources de votre processeur sont utilisées par le script, vous avez besoin de la valeur du « temps utilisateur » (temps utilisateur) et du « temps système » (temps du mode privilégié). Vous pouvez obtenir le résultat en secondes et en microsecondes. Pour convertir le nombre total de secondes en nombre décimal, vous devez diviser la valeur en microsecondes par 1 million et ajouter la valeur en secondes à la valeur.

C'est un peu déroutant. Voici un exemple :

// repos pendant 3 secondes sleep(3); $data = getrusage(); echo "Temps utilisateur : ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1 000 000); echo "Heure système : ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1 000 000); /* imprime Temps utilisateur : 0,011552 Temps système : 0 */

Bien que l'exécution du script ait pris environ 3 secondes, le processeur n'était pas très chargé. Le fait est que lorsqu'il est appelé (veille), le script ne consomme pratiquement aucune ressource processeur. En général, de nombreuses tâches prennent beaucoup de temps, mais n’utilisent pas le processeur. Par exemple, en attente d'opérations liées au disque. Vous n’utilisez donc pas toujours le temps CPU dans vos scripts.

Voici un autre exemple :

// marche 10 millions de fois pendant($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); /* выводит User time: 1.424592 System time: 0.004204 */

Le script prenait 1,4 seconde de temps CPU. Dans ce cas, les temps d’appel système sont généralement faibles.

Le temps en mode privilégié (temps système) est le temps que le processeur passe à exécuter les requêtes système adressées au noyau au nom du programme. Exemple:

$start = microtime(true); // appelle microtime toutes les 3 secondes 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); /* выводит User time: 1.088171 System time: 1.675315 */

Le temps système a désormais été dépensé beaucoup plus que dans l'exemple précédent. Tout cela grâce à la méthode microtime(), qui utilise les ressources système.

Cependant, il convient de noter que l'heure affichée peut ne pas être exacte car À un moment donné, les ressources du processeur sont également utilisées par d'autres programmes, ce qui peut entraîner une légère erreur.

5. Constantes magiques

Il existe de nombreuses constantes magiques en PHP, telles que le numéro de ligne actuel (__LINE__), le chemin du fichier (__FILE__), le chemin du répertoire (__DIR__), le nom de la fonction (__FUNCTION__), le nom de la classe (__CLASS__), le nom de la méthode (__METHOD__) et les espaces de noms ( __ESPACE DE NOM__).

Nous ne les considérerons pas tous. Regardons-en quelques-uns :

// ce script dépend de l'emplacement actuel du fichier et // peut causer des problèmes s'il est utilisé à partir de différents répertoires require_once("config/database.php"); // ce script ne posera pas de problèmes require_once(dirname(__FILE__) . "/config/database.php");

Utilisez __LINE__ lors du débogage des scripts :

// code // ... my_debug("un message de débogage", __LINE__); /* affichera la ligne 4 : un message de débogage */ // plus de code // ... my_debug("un autre message de débogage", __LINE__); /* affichera la ligne 11 : un autre message de débogage */ function my_debug($msg, $line) ( echo "Line $line: $msg\n"; )

6. Générer des identifiants uniques

Il arrive parfois que vous deviez générer une chaîne unique. J'ai vu plusieurs fois que la fonction md5() est utilisée pour résoudre ce problème :

// génère une chaîne aléatoire echo md5(time() . mt_rand(1.1000000));

Mais en fait, PHP a une fonction spéciale uniqid() à ces fins

// génère une chaîne aléatoire echo uniqid(); /* affichera 4bd67c947233e */ // encore une fois echo uniqid(); /* affichera 4bd67c9472340 */

À l'œil nu, vous pouvez voir que les premiers symboles sont, pour le moins, similaires... Cela est dû au fait que cette méthode utilise le temps du serveur pour générer des symboles. C'est même utile, parce que... Toutes les valeurs générées sont obtenues par ordre alphabétique, ce qui permet de les trier rapidement.

Afin de réduire les chances d'obtenir un doublon, on peut ajouter un préfixe ou utiliser un deuxième paramètre (augmente le nombre de caractères) :

// préfixé par echo uniqid("foo_"); /* affichera foo_4bd67d6cd8b8f */ // avec le deuxième paramètre echo uniqid("",true); /* affichera 4bd67d6cd8b926.12135106 */ // les deux echo uniqid("bar_",true); /* affichera bar_4bd67da367b650.43684647 */

Cette méthode génère des chaînes plus petites que md5, économisant ainsi de l'espace.

7. Sérialisation

Avez-vous déjà eu à stocker des données complexes dans une base de données ou un fichier ? Afin de convertir un objet en chaîne, PHP propose une fonction spéciale.

De manière générale, il existe 2 de ces méthodes : Serialize() et unserialize().

// tableau complexe $myvar = array("hello", 42, array(1,"two"), "apple"); // conversion en chaîne $string = serialize($myvar); echo $chaîne ; /* affichera 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";) */ // récupère la valeur d'origine $newvar = unserialize($string); print_r($nouvellevar); /* affichera Array ( => bonjour => 42 => Array ( => 1 => deux) => pomme) */

C'est ainsi que fonctionnent ces fonctions. Cependant, en raison de la croissance rapide de la popularité de JSON, 2 méthodes json_encode() et json_decode() ont été ajoutées à PHP 5.2. Leur travail est similaire à Serialize() :

// tableau complexe $myvar = array("hello", 42, array(1,"two"), "apple"); // conversion en chaîne $string = json_encode($myvar); echo $chaîne ; /* affichera ["hello",42,,"apple"] */ // restaurera la valeur d'origine $newvar = json_decode($string); print_r($nouvellevar); /* affiche Array ( => bonjour => 42 => Array ( => 1 => deux) => pomme) */

Cette option est plus compacte et compatible avec d'autres langages comme JavaScript. Cependant, lorsque vous travaillez avec des objets très complexes, une perte de données peut survenir.

8. Compression des chaînes

Quand on parle de compression, on pense immédiatement aux fichiers d’archives au format ZIP. PHP offre la possibilité de compresser de longues chaînes sans aucun fichier.

L'exemple suivant montre comment fonctionnent les fonctions gzcompress() et 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 quis iaculis. Etiam ac massa sed turpis tempor luctus. $compressé = gzcompress($string); echo "Taille originale : ". strlen($chaîne)."\n"; /* affichera Taille d'origine : 800 */ echo "Taille compressée : ". strlen($compressé)."\n"; /* affichera Taille compressée : 418 */ // return $original = gzuncompress($compressed);

Nous pouvons réduire le volume du texte de 50%. Dans le même but, vous pouvez utiliser les méthodes gzencode() et gzdecode(), qui utilisent un algorithme de compression différent.

9. Exécuter avant de quitter

PHP possède une fonction register_shutdown_function() qui vous permettra d'exécuter du code avant d'arrêter le script.

Disons que vous souhaitez obtenir des informations... Durée d'exécution du script :

// récupère l'heure de début $start_time = microtime(true); // certaines opérations // ... // affichent le temps d'exécution echo "l'exécution a pris : ". (microtime(true) - $start_time). "secondes.";

À première vue, cette tâche peut paraître triviale. A ces fins, vous pouvez placer le code à la fin du fichier. Cependant, si la fonction exit() se déclenche quelque part avant cela, ce code ne fonctionnera jamais. De plus, cela ne fonctionnera pas s'il y a une erreur sur la page ou si l'utilisateur interrompt le chargement de la page (en cliquant sur le bouton correspondant dans son navigateur) ;

Lors de l'utilisation de la méthode register_shutdown_function(), le code sera exécuté dans tous les cas :

$start_time = microtime(true); register_shutdown_function("mon_shutdown"); function my_shutdown() ( global $start_time; echo "l'exécution a pris : ". (microtime(true) - $start_time). " secondes."; )

Conclusion

PHP est une planète entière qui ne cesse de nous surprendre par son contenu. Que pensez-vous de ces fonctions ?