Guide d'apprentissage PHP-Chapitre 8 (2)-tutoriel php-php.cn

Acheter des compétences de fonction

Jetons maintenant un coup d'œil à certaines des propriétés les plus magiques des fonctions, y compris les méthodes d'utilisation d'un nombre variable de paramètres et les méthodes permettant à la fonction de modifier les variables entrantes. les fonctions deviennent des méthodes d’utilisation des données.

Le contenu de cette section est la section la plus difficile de ce chapitre. Elle ne convient qu'aux programmeurs aventureux, curieux ou expérimentés.

Nombre de paramètres variables

Il est utile de connaître le nombre réel de paramètres lors de l'appel de la fonction entrante selon la situation. Il existe trois manières possibles de la gérer en PHP, dont une. ne peut être utilisé qu'en PHP4 :

1. Définissez une fonction avec des paramètres par défaut Lorsque la fonction omet des paramètres dans l'appel, elle utilisera la valeur par défaut à la place et aucun message d'avertissement ne sera affiché.

2． Utilisez les paramètres du tableau pour stocker ces valeurs. Le code du programme appelant est responsable de l'encapsulation de ce tableau. Le corps de la fonction doit séparer correctement les données.

3. Utilisez les fonctions variadiques de PHP4 (func_num_args(), func_get_arg() et func_get_args()).

Paramètres par défaut

Afin de définir une fonction avec des paramètres par défaut, modifiez simplement les paramètres formels dans l'expression spécifiée. Si les paramètres de l'appel réel sont inférieurs aux paramètres formels de la définition, PHP comparera et fera correspondre les paramètres formels avec les paramètres réels jusqu'à ce qu'ils soient épuisés, puis utilisera les spécifications prédéfinies pour remplir les paramètres restants.

Par exemple, les variables de la fonction suivante sont toutes définies avec des valeurs par défaut :

function tour_guide($city = « Gotham City »,

$desc = «vast métropole",

$how_many = "douzaines",

$of_what = "méchants costumés")

{

print("$ ville est un $desc rempli de

$how_many de $of_what. »); ("Chicago");

tour_guide("Chicago", "ville merveilleuse");

tour_guide("Chicago","ville merveilleuse",

"des millions de personnes",

"des gens bourrus avec des cœurs d'or et des histoires de malchance à raconter");

Le navigateur affichera des résultats similaires aux suivants. Les phrases sont déterminées par le navigateur utilisé :

Gotham City est une grande métropole remplie de dizaines de méchants costumés.

Chicago est une grande métropole remplie de dizaines de méchants costumés.

Chicago est une ville merveilleuse remplie de dizaines de méchants costumés. Une ville merveilleuse remplie de millions de méchants costumés.

Chicago est une ville merveilleuse remplie de millions de gens bourrus au cœur d'or et de malchance. des histoires à raconter.

Paramètres par défaut La principale limitation de est que la correspondance des paramètres réels avec les paramètres formels est déterminée par une comparaison séquentielle des deux, sur la base du premier arrivé, premier servi. Par conséquent, vous ne pouvez pas modifier les paramètres par défaut et vous retrouver avec de nombreux problèmes sans vous en rendre compte.

Remplacez plusieurs paramètres par des tableaux

Si vous n'êtes pas satisfait de la flexibilité de plusieurs paramètres, vous pouvez utiliser des tableaux comme moyen de communication, ce qui peut contourner tout le problème du comptage de paramètres.

L'exemple suivant utilise cette stratégie, et utilise également plusieurs petites astuces, telles que l'opérateur ternaire (introduit au chapitre 7) et le tableau associatif (mentionné de manière irrégulière au chapitre 6, il sera entièrement expliqué au chapitre 11) :

fonction tour_brochure($info_array)

{

$city =

IsSet ($info_array [?city?])?

$info_array[?city?]:"Gotham City";

$desc =

IsSet ($info_array[?city?])?

$info_array[ ?desc?]:« grande métropole »;

$how_many =

IsSet ($info_array[?how_many?])?

$info_array[?how_many?] : "des dizaines";

$of_what

IsSet ($info_array[?of_what?])?

$info_array[? of_what?] : "méchants costumés" ; >
print("$city est un $desc rempli de

$combien de $of_what. "

}

Cette fonction vérifie que le paramètre du tableau entrant est comparé à quatre valeurs différentes séparées par une chaîne spécifique, en utilisant l'opérateur conditionnel ternaire "?", et que la variable locale est spécifiée comme valeur entrante (si elle est déjà stockée dans le tableau), sinon elle est spécifié comme valeur par défaut. Maintenant, nous essayons d'appeler cette fonction avec deux tableaux différents :

tur_brochure(array()); //Empty array

$tour_info =

aray(? city? =>?Cozumel?,

?desc?=>?destination escapade?,

'of_what'= >'plages de sable');

tur_brochure( $tour_info);

Dans cet exemple, nous appelons d'abord tour_brochure avec un tableau vide (correspondant à aucun paramètre), puis nous l'appelons avec un tableau qui stocke l'une des quatre valeurs associées possibles. Le résultat de son navigateur est :

Gotham City est une grande métropole remplie de dizaines de méchants costumés.

Cozumel est une destination d'escapade remplie de dizaines de plages de sable.

Dans les deux cas, le nombre de "douzaines" est par défaut car aucun des deux tableaux n'a quoi que ce soit de stocké dans la section associée "how_many".

Utiliser plusieurs paramètres en PHP4

Enfin, PHP4 fournit certaines fonctions qui peuvent récupérer le nombre et la valeur des paramètres dans le corps de la fonction :

fnc_num_args(). ne prend aucun paramètre et renvoie le nombre de paramètres transmis lors de l'appel de la fonction.

fnc_get_arg() prend un paramètre entier n et renvoie le nième paramètre de l'appel de fonction. Le comptage des paramètres commence à 0.

fnc_get_args() ne prend aucun paramètre et renvoie un tableau contenant tous les paramètres de l'appel de fonction, avec un index de tableau commençant à 0.

Si vous les appelez en dehors du corps de la fonction, ces trois fonctions généreront des messages d'avertissement. Si l'index utilisé lors de l'appel est supérieur à l'index du dernier paramètre passé, func_get_arg() lancera également un avertissement.

Si la fonction de l'utilisateur utilise ces fonctions de fonction pour décoder les paramètres, vous pouvez utiliser pleinement l'appel de fonction mentionné ici. PHP ne fera pas en sorte que les paramètres réels soient plus grands que le nombre de paramètres formels dans la définition. . Les plaintes sont nombreuses. Les utilisateurs peuvent définir une fonction sans paramètres, puis utiliser cette fonction pour comparer et faire correspondre toute fonction réellement transmise.

Par exemple, considérons les deux instances de fonction suivantes, dont chacune renvoie un tableau d'arguments :

fnction args_as_array_1()

{

$arg_count = func_num_args();

$counter = 0;

$local_array = array();

wile($counter < $arg_count)

{

$local_array[$counter] =

fnc_get_arg($ary_counter);

$counter = $counter 1;

}

rturn($local_array);

}

fnction args_as_array_2()

{

rtun(func_get_args ());

>

La première fonction redondante utilise func_get_arg() pour récupérer chaque argument individuel et utilise le résultat de func_num_args() pour déterminer les limites de la boucle, de sorte qu'aucun paramètre supplémentaire n'est récupéré que celui réellement transmis. Chaque paramètre est stocké dans un tableau et le tableau est renvoyé. L'encapsulation de ces arguments est en fait effectuée par func_get_arps(), donc la deuxième version de cette fonction est très courte.

Voici un autre exemple. Nous réécrivons la fonction tour_guide() précédente, qui utilise plusieurs fonctions de paramètres pour remplacer les paramètres par défaut :

fnction tour_guide_2()

{

$num_args = func_num_args();

$city = $num_args > 0 ?

fnc_get_arg(0): "Gotham City"; = $num_args > 1 ?

$desc = $num_args > 1 ?

fnc_get_arg(1) : "grande métropole" ;

$how_many = $num_args > ; 2 ?

fnc_get_arg(2): "des dizaines";

$of_what = $num_args > 3 ?

fnc_get_arg(3): "méchants costumés";

pint("$city est un $desc rempli de

$combien de $of_what. "); >Le code de programme ci-dessus a la même fonction et le même effet que le code de programme prédéfini en forme de paramètre et est soumis aux mêmes restrictions. Les paramètres sont transmis de manière positionnelle, il n'y a donc aucun moyen de remplacer les « méchants costumés » par un autre contenu, seul « Gotham City » est utilisé comme valeur par défaut.

Appel par valeur ou appel par référence

L'action par défaut des fonctions définies par l'utilisateur en PHP est "par valeur". L'appel par valeur signifie que lorsqu'une variable est passé à un appel de fonction, PHP fait une copie de la valeur de la variable et la transmet à la fonction. Par conséquent, peu importe ce que fait la fonction, elle ne peut pas modifier les variables réelles qui apparaissent dans l’appel de fonction. Bien que ce comportement présente des avantages, il présente également des inconvénients. C'est certainement une bonne approche lorsque nous voulons simplement utiliser la valeur de retour de la fonction, mais cela peut gêner si la modification de la variable transmise est l'objectif réel.

Ce qui suit démontrera l'implémentation d'un exemple de soustraction plutôt inefficace pour implémenter l'appel par valeur :

fnction my_subtract($numl,$num2)

{

i ($numl < $num2)

de("Les nombres négatifs sont imaginaires");

$return_result = 0;

wile($numl > $num2)

{

$numl = $numl – 1;

$return_result = $return_result 1;

}

rturn($return_result);

}

$first_op = 493;

$second_op = 355;

$result1 = my_subtract($first_op ,$ second_op);

pint("result1 est $result1 ");

$result2 = my_subtract($first_op,$second_op);

Print (" result2 est $result2 ");

Super, on voit qu'effectuer deux fois la même soustraction donnera le même résultat :

rsult1 est 138

rsult2 est 138

Même si my_subtract modifie la valeur de son paramètre formel $numl, vous obtiendrez toujours ce résultat. La variable $numl ne stocke qu'une copie de la valeur du paramètre réel $first_op, donc $first_op ne le fait pas. sera affecté.

Appel par référence

PHP propose deux manières différentes de rendre une fonction plus capable de modifier des paramètres dans sa définition ou dans un appel de fonction, également appelé appel par référence.

Si vous souhaitez définir une fonction qui opère directement sur les variables entrantes, vous pouvez ajouter un symbole "&" devant les paramètres formels dans la définition, comme indiqué ci-dessous :

fonction my_subtract_ref( &$numl,&$num2)

{

i($numl-<$num2)

de("Les nombres négatifs sont imaginaires");

$return_result = 0;

wile($num1 >$num2)

{

$numl = $num1 – 1;

$return_result = $return_result 1;

}

rturn($return_result); $second_op = 355;

$result1 = ma _subtract_ref($first_op, $second_op );

pint("result1 est $result1 ");

$result2 = my_subtract_ref($first_op,$second_op);

pint("result2 est $result2 ”); , vous obtiendrez ce résultat :

rsult1 est 138

rsult1 est 0

C'est parce que le paramètre formel $numl et le paramètre réel $first_op fait référence au même contenu, modifier l'un équivaut à modifier l'autre.
Vous pouvez également forcer une fonction à transmettre des paramètres en conséquence en ajoutant le symbole "&" avant le paramètre réel (il s'agit d'une fonctionnalité qui est progressivement supprimée et pourrait être supprimée dans une future version de PHP). En d'autres termes, vous pouvez utiliser la fonction d'appel d'origine par valeur pour obtenir l'action par référence, comme suit :

$first_op = 493

$second_op = 355; >$result1 = my_subtract(&$first_op,&$second_op);

Print("result1 is $result1 ");

$result2= my_subtract(&$first_op , &$second_op);

Print("result2 is $result2 ");

Cette fois, nous avons obtenu le résultat suivant :

rsult1 est 138

rsult1 est 0

Pour PHP4, les paramètres variables peuvent également être utilisés en dehors des appels de fonction. En général, l'attribution d'une référence de variable ($varname) à une variable fait que les deux variables deviennent des alias,
s, l'une de l'autre, plutôt que d'être deux variables différentes avec la même valeur. Par exemple :

$name_1 = "Manfred von Richtofen" ;

$name_2 = "Percy Blakeney" ;

$alias_1 = $name_1 ; value

$alias_2=&$name_2; //Les variables sont les mêmes

$alias_1 = "Le Baron Rouge" //Le nom réel n'a pas changé

$alias_2 = "Le Mouron écarlate" "; //Peu importe de quoi il s'agit

Prnt("$alias_1 est $name_1 ");

Prnt("$ alias_2 est $name_2 ");

Le code du programme ci-dessus obtiendra une sortie du navigateur comme celle-ci :

Le Baron Rouge est Manfred von Richtofen

Le Pimpernel Écarlate est The Scarlet Pimpernel

Nom de la fonction variable

Une technique très flexible en PHP consiste à utiliser des variables pour remplacer l'emplacement où l'utilisateur définit la fonction. Autrement dit, au lieu de saisir le nom littéral de la fonction dans le code du programme, vous pouvez saisir une variable commençant par le symbole "&", et la fonction réelle appelée lors de l'exécution dépend de la chaîne attribuée à la variable. Dans un sens, cela permet d’utiliser des fonctions comme données. Cette technique peut être familière aux programmeurs C, mais aussi aux débutants de tout type de langage Lisp tel que Scheme ou Common Lisp.

Par exemple, les deux appels de fonction suivants sont exactement équivalents :

function Customized_greeting()

{

print("Vous êtes accueilli dans un manière personnalisée ! ");

}

customized_greeting();

$my_greeting = 'customized_greeting'; my_greeting();

Le code du programme ci-dessus produit le même résultat :

Vous êtes accueilli de manière personnalisée !

Vous êtes accueilli de manière personnalisée !

Parce que le nom de la fonction est une chaîne, elle peut également être utilisée comme paramètre de la fonction ou renvoyée comme résultat de la fonction.

Exemple étendu

Examinons le type de problèmes que vous pourriez rencontrer lors de l'utilisation de l'une des fonctionnalités les plus avancées des fonctions, notamment l'utilisation du nom de la fonction comme paramètre de fonction.

Exemple 8-1 Cet exemple montre un exemple étendu de la fonction. Cette fonction complète la fonction de remplacement du mot de passe. Il s'agit du système de mot de passe le plus primitif, utilisant l'alphabet pour remplacer une lettre par une autre. les informations affichées.

Le code de programme suivant est plus long et plus avancé que n'importe quel code de programme présenté jusqu'à présent dans ce livre. Pour ceux qui ne veulent pas connaître les détails, vous pouvez ignorer ce code.

Exemple 8-1 Remplacement de chiffre

/*Partie 1 : calculs cryptographiques et fonctions utilitaires*/

fonction ajouter 1 ($num)

{

retour(($num 1)&);

}

fonction sub_1($num)

{

retour( ($num 25)% 26);

}

fonction swap 2 ($num)

{

if($num % 2 == 0)

return($num 1)；

else

return($num - 1)；

}

fonction swap 26($num)

{

return(25 - $num)；

}

fonction lettre inférieure ($char string)

{

return(ord($char string) >=ord('a'))&&

(ord(&char string)< =ord('z')))；

}

fonction lettre majuscule($char string)

{

return((ord($char string) >=ord('A' ))&&&

(ord($char string)< =ord('z')))；

}

/*第二部份：chiffre de lettre函式 */

chiffrement de lettre de fonction ($chaîne de caractères, $code func)

{

if!(lettre supérieure($chaîne de caractères)||

lettre inférieure ($char string)))

return($char string)；

if(lettre supérieure($char string))

$base num = ord('A')；

else

$base num = ord($char string) –

$base num)；

retour (chr($base num

($code func ($char num )

% 26)))；

}

/*第三部份：主要string cipher 函式 */

function string cipher($message,$cipher func)

{

$coded message = ””；

$longueur du message = strlen($message)；

pour($index= 0；

$index < $longueur du message；

$index )

$message codé .=

chiffrement de lettre ($message[$index],$cipher func)；

return($message codé)；

}

范例8-1共有三个部分。在第一部份中，我们定义了几个对数字0—25进行简单数字运算的函式，这些数字代表密码程序中的字母A—Z。函式add_1把给它的数字加1，以「26」为模数（仅意味着26以及超过26的数字会«绕回»到开头从「0」开始。0变成1 、 1变成2 、…、25变成0。Sub_1则是沿另一个方向转换数字，透过加上25（在这种模数算法中就等于减1），25变成24 、 24变成23 、… 、0变成25。Swap_2则是以成对的方式置换数字的位置（0到1 、1到0 、 2到3 、 3到2…

所有这些函式都算是这个简易密码程序的基础。最后还有两个公用程序函式，用以测试字符是大写还是小写字母。

第二部分就是个letter_cipher（）函式，并该函式的工作是取得第一部分中的一个算术函式，然后应用它来对简单字母进行编码。该函式会先测试它处理的字符串（其中只有单元一字符）是否为字母；如果不是，则按原样传回。如果字符是个字母，则可使用。Ord()的功用是将其转化为数字，然后减支适当的字母（ a或A），以把数字限定到0—25之间。一旦位于这个范围内，就可以应用其名字以字符串方式传入的密码函式中，然后再把数字转换成字母，最后传回它。

最后，第三部分是string_cipher（）函式，该函式带有一个字符串讯息，还有一个密码函式，它传回的是一个新字符串值，其值为透过函式进行编码的内容。这里用到一两个以前没见到的功能（其中包括字符串连接运算子「.=」，在第十章中会提到），这个函式从讯息字符串的字母逐一进行处理，建构出新字符串，并用新字母下面，我们编写一些程序码测试string_cipher（）；

$ originak = « Mon message secret est ABCDEFG »；

Print(« Le message original est :$orginal ")；

$coding_array = array('add_1',

'sub_1,

'swap_2',

'swap_26') ；

Pour($count = 0；

$count < sizeof($coding_array)；

$coded_message =

String_cipher($original, $code)；

Print(“$code encoding is :$coded_message ”)；

}

这些测试程序码使用了预先定义的四个字母编码函式，把它们隐藏在一个阵列中，然后回圈遍巡该阵列，编码$original讯息，并输出显示编码后的版本。浏览器输出如下所示：

message original est : Mon message secret est ABCDEFG

l'encodage add_1 est :Nz tfdsfu nfttbhf jt BCDEFGH

l'encodage sub_1 est :Lx rdbqfs nfttbhf jt BADCFRH

l'encodage swap_2 est :Nz tfdqfs nfttbhf jt BADCFEH

swap_26 l'encodage est : Nb hvxivg nvhhztv rh ZYXWVUT

我们可以把这个函式做为资料的方法再深入一步，编写一个给序列中的讯息应用多个密码的函比。这个函式也使用了PHP4的可变参数型函式：

Fonction chained_code ($message)

{

/* 先取得反映定讯息，然后替编辑码函式名称找个任意数目。

Applique chaque fonction d'encodage au résultat précédent et renvoie son résultat. */

$argc = func_num_args();

$coded = $message;

Pour ($count = 1; $count<$argc;$count)

{

$function_name = func_get_arg($count);

$coded =

String_cipher($coded,

$function_name) ;

}

Return($coded);

}

Le premier paramètre de Chained_code() doit être une chaîne de message, suivi du correspondant N'importe quel nombre de noms pour les fonctions cryptographiques. Le message codé est le résultat de l'application de la première fonction de codage au message, puis de l'application de la deuxième fonction de codage au résultat, et ainsi de suite. Nous pouvons tester cela en utilisant diverses combinaisons de fonctions de codage alphabétique prédéfinies.

$tricky =

Chained_code($original,

'add_1''swap_26',

'add_1''swap_2');

Print("La version encodée délicate est $tricky ");

$easy =

Chained_code($original,

'add_1',' swap_26',

'swap_','sub_1',

'add_1', 'swap_2,'

'swap_26,''sub_1,');

Print("La version codée facile est $easy ");

Le résultat est :

La version codée délicate est Ma guwjh muggysu qg YXWXUVS

La version codée facile est Mon message secret est ABCDEFG

Comme vous pouvez le voir, le message « délicat » est une combinaison de codes pré-codés, mais ne correspond exactement à aucune fonction d'encodage unique. L'encodage "facile" est une combinaison plus complexe de ces fonctions, et le résultat est le message original... sans aucune modification ! (Ce n'est pas parce que le code clé n'est pas valide, nous voulons simplement que les lecteurs comprennent pourquoi cette séquence particulière de fonctions d'édition peut à nouveau revenir au message d'origine.)

Ce que fait ce petit script de mot de passe Le but d'afficher le range est de vous faire comprendre que même si le programme de mot de passe est un peu plus compliqué, puisque PHP prend en charge l'utilisation de noms de fonctions comme paramètres de fonction, cela rend cette affaire assez simple.

Résumé

La plupart des fonctionnalités PHP existent dans un grand nombre de fonctions intégrées, qui sont fournies par l'équipe de développement open source de PHP. Chaque fonction doit avoir une description (même si certaines sont brèves) dans le manuel en ligne sur http://www.php.net.

Vous pouvez également écrire votre propre fonction, qui est ensuite accessible de la même manière que les fonctions intégrées. Les fonctions sont écrites dans une syntaxe simple de style C, comme suit :

Fonction ma_fonction ($argl,$arg2,…)

{

Statement1;

Statement2;

…

Return($value); En conjonction avec d'autres paramètres, tout type de valeur peut également être renvoyé. Il n'est pas nécessaire de déclarer les types de paramètres et les valeurs de retour.

En PHP4, il n'y a pas de différence entre le nombre de définitions de fonctions et d'appels de fonctions, du moment que chaque fonction appelée a été définie. Aucune déclaration de fonction distincte ni aucun prototypage n’est requis. Les variables spécifiées dans une fonction seront limitées à la zone de fonction à moins qu'une déclaration globale ne soit utilisée. Les variables locales peuvent être déclarées statiques, ce qui signifie qu'elles conservent leurs valeurs entre les appels de fonction.

Le comportement d'action par défaut des fonctions définies par l'utilisateur est "call_by_reference". Cela signifie que la fonction utilise une copie des paramètres en fonctionnement et ne peut donc pas être modifiée dans la variable d'origine de l'appel de fonction. En ajoutant un "&" avant le paramètre, vous pouvez forcer "l'appel par référence", qui peut être utilisé soit du côté définissant, soit du côté appelant. PHP propose diverses manières de faire varier le nombre de paramètres pris par une fonction. Enfin, la fonction à appeler peut être déterminée au moment de l'exécution en remplaçant le nom de la fonction définie par l'utilisateur par une variable de chaîne, permettant à la fonction d'être traitée comme des données et transmise entre d'autres fonctions.

Ce qui précède est le contenu du Guide d'apprentissage PHP - Chapitre 8 (2). Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !