PHP-Lernhandbuch – Kapitel 8 (2)

Funktionsfähigkeiten erwerben

Werfen wir nun einen Blick auf einige der magischeren Eigenschaften von Funktionen, einschließlich Methoden zur Verwendung einer variablen Anzahl von Parametern und Methoden, mit denen die Funktion die eingehenden Variablen ändern kann Funktionen werden zu Methoden zur Verwendung von Daten.

Der Inhalt dieses Abschnitts ist der anspruchsvollste Abschnitt dieses Kapitels. Er ist nur für abenteuerlustige, neugierige oder erfahrene Programmierer geeignet.

Anzahl der variablen Parameter

Es ist nützlich, die tatsächliche Anzahl der Parameter zu kennen, wenn die eingehende Funktion je nach Situation aufgerufen wird. Es gibt drei Möglichkeiten, damit in PHP umzugehen, eine davon kann nur in PHP4 verwendet werden:

1. Definieren Sie eine Funktion mit Standardparametern. Wenn die Funktion Parameter im Aufruf weglässt, verwendet sie stattdessen den Standardwert und es wird keine Warnmeldung angezeigt.

2． Verwenden Sie Array-Parameter, um diese Werte zu speichern. Der aufrufende Programmcode ist für das Umschließen dieses Arrays verantwortlich, und der Funktionskörper muss die Daten ordnungsgemäß trennen.

3． Verwenden Sie die Variadic-Funktionen in PHP4 (func_num_args(), func_get_arg() und func_get_args()).

Standardparameter

Um eine Funktion mit Standardparametern zu definieren, ändern Sie einfach die formalen Parameter in angegebene Ausdrücke. Wenn die Parameter im tatsächlichen Aufruf kleiner sind als die formalen Parameter in der Definition, vergleicht PHP die formalen Parameter mit den tatsächlichen Parametern und gleicht sie ab, bis sie aufgebraucht sind, und verwendet dann die voreingestellten Spezifikationen, um die verbleibenden Parameter auszufüllen.

Zum Beispiel sind die Variablen in der folgenden Funktion alle mit Standardwerten definiert:

function tour_guide($city = „Gotham City“,

$desc = „vast metropolis“,

$how_many = „dozens“,

$of_what = „kostümierte Schurken“)

{

print(“$ city ​​ist ein $desc gefüllt mit

$how_many of $of_what.< BR >“

tour_guide();

tour_guide ("Chicago");

tour_guide("Chicago", "wunderbare Stadt");

tour_guide("Chicago", "wunderbare Stadt",

„Millionen wimmeln“,

„schroffe Menschen mit Herzen aus Gold und Pechgeschichten“);

Der Browser gibt Ergebnisse ähnlich den folgenden aus Der Satz wird durch den verwendeten Browser bestimmt:

Gotham City ist eine großartige Metropole voller Dutzende kostümierter Bösewichte.

Chicago ist eine großartige Metropole voller Dutzende kostümierter Bösewichte.

Chicago ist eine wundervolle Stadt voller Dutzende kostümierter Bösewichte.

Chicago ist eine wundervolle Stadt voller Millionen schroffer Menschen mit Herzen aus Gold und Pech Geschichten zum Erzählen.

Standardparameter Die Hauptbeschränkung von besteht darin, dass die Zuordnung tatsächlicher Parameter zu formalen Parametern durch einen sequentiellen Vergleich der beiden nach dem Prinzip „Wer zuerst kommt, mahlt zuerst“ bestimmt wird. Daher können Sie nicht mit den Standardparametereinstellungen herumspielen und am Ende viele Probleme bekommen, ohne es zu merken.

Ersetzen Sie mehrere Parameter durch Arrays

Wenn Sie mit der Flexibilität mehrerer Parameter nicht zufrieden sind, können Sie Arrays als Kommunikationsmittel verwenden, wodurch das gesamte Problem der Parameterzählung umgangen werden kann.

Das folgende Beispiel verwendet diese Strategie und verwendet auch einige kleine Tricks, wie den ternären Operator (eingeführt in Kapitel 7) und das assoziative Array (unregelmäßig erwähnt in Kapitel 6, es wird ausführlich in Kapitel 11 erklärt). :

function tour_brochure($info_array)

{

$city =

IsSet ($info_array [?city?])?

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

$desc =

IsSet ($info_array[?city?] )?

$info_array[ ?desc?]:“great metroprlis“;

$how_many =

IsSet ($info_array[?how_many?])?

$info_array[?how_many?]: "dutzende";

$of_what

IsSet ($info_array[?of_what?])?

$info_array[? of_what?]: "kostümierte Bösewichte"; >
print("$city ist ein $desc gefüllt mit

$how_many of $of_what.< BR >");

}

Diese Funktion Überprüft mithilfe des ternären Bedingungsoperators „?“, ob der eingehende Array-Parameter mit vier verschiedenen Werten verglichen wird, die durch eine bestimmte Zeichenfolge getrennt sind, und die lokale Variable wird als eingehender Wert angegeben (falls bereits im Array gespeichert), andernfalls wird sie verwendet ist als Standardwert angegeben. Nun versuchen wir, diese Funktion mit zwei verschiedenen Arrays aufzurufen:

tur_brochure(array()); //Empty array

$tour_info =

aray(? city? =>?Cozumel?,

?desc?=>?Reiseziel?,

'of_what'= >'Sandstrände');

tur_brochure( $tour_info);

In diesem Beispiel rufen wir tour_brochure zunächst mit einem leeren Array (entsprechend keinen Parametern) auf und rufen es dann mit einem Array auf, das einen der vier möglichen zugehörigen Werte speichert. Die Browserausgabe lautet:

Gotham City ist eine großartige Metropole voller Dutzende kostümierter Bösewichte.

Cozumel ist ein Reiseziel voller Dutzende Sandstrände.

In beiden Fällen ist die Anzahl „Dutzende“ voreingestellt, da in keinem der Arrays etwas im zugehörigen Abschnitt „how_many“ gespeichert ist.

Verwendung mehrerer Parameter in PHP4

Schließlich stellt PHP4 einige Funktionen bereit, um die Anzahl und den Wert von Parametern im Funktionskörper abzurufen:

fnc_num_args() braucht Keine Parameter und gibt die Anzahl der Parameter zurück, die beim Aufruf der Funktion übergeben wurden.

fnc_get_arg() nimmt einen ganzzahligen Parameter n und gibt den n-ten Parameter des Funktionsaufrufs zurück. Die Parameterzählung beginnt bei 0.

fnc_get_args() akzeptiert keine Parameter und gibt ein Array zurück, das alle Parameter des Funktionsaufrufs enthält, wobei der Array-Index bei 0 beginnt.

Wenn Sie sie außerhalb des Funktionskörpers aufrufen, geben diese drei Funktionen Warnmeldungen aus. Wenn der beim Aufruf verwendete Index höher ist als der Index des letzten übergebenen Parameters, gibt func_get_arg() ebenfalls eine Warnung aus.

Wenn die Funktion des Benutzers diese Funktionsfunktionen zum Dekodieren von Parametern verwendet, können Sie den hier erwähnten Funktionsaufruf vollständig nutzen. PHP führt nicht dazu, dass die tatsächlichen Parameter größer sind als die Anzahl der formalen Parameter in der Definition . Es gibt viele Beschwerden. Benutzer können eine Funktion ohne Parameter definieren und diese Funktion dann verwenden, um jede tatsächlich übergebene Funktion zu vergleichen und abzugleichen.

Betrachten Sie beispielsweise die folgenden zwei Funktionsinstanzen, von denen jede ein Array von Argumenten zurückgibt:

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());

}

Die erste redundante Funktion verwendet func_get_arg(), um jedes einzelne Argument abzurufen, und verwendet das Ergebnis von func_num_args(), um außerhalb der Grenzen zu kreisen, sodass nicht mehr Parameter abgerufen werden, als tatsächlich übergeben wurden. Jeder Parameter wird in einem Array gespeichert und das Array wird zurückgegeben. Das Umschließen solcher Argumente erfolgt tatsächlich durch func_get_arps(), daher ist die zweite Version dieser Funktion sehr kurz.

Hier ist ein weiteres Beispiel. Wir schreiben die vorherige Funktion tour_guide() um, die mehrere Parameterfunktionen verwendet, um die Standardparameter zu ersetzen:

Funktion tour_guide_2()

{

$num_args = func_num_args();

$city = $num_args > 0 ?

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

$desc = $num_args > ; 2 ?

fnc_get_arg(2): „dutzende“;

$of_what = $num_args > 3 ?

fnc_get_arg(3): „kostümierte Bösewichte“;

pint("$city ist ein $desc gefüllt mit

$how_many von $of_what. < BR >"); 🎜>
tur_guide2();

Der obige Programmcode hat die gleiche Funktion und Wirkung wie der voreingestellte Parameter-Programmcode und unterliegt den gleichen Einschränkungen. Die Parameter werden positionell übergeben, sodass es keine Möglichkeit gibt, „kostümierte Bösewichte“ durch andere Inhalte zu ersetzen. Als Standardwert wird nur „Gotham City“ verwendet.

Call-by-Value vs. Call-by-Reference

Die Standardaktion benutzerdefinierter Funktionen in PHP ist „by-value“. Call-by-value bedeutet, dass bei einer Variable an einen Funktionsaufruf übergeben wird, erstellt PHP eine Kopie des Variablenwerts und übergibt ihn an die Funktion. Unabhängig davon, was die Funktion tut, kann sie daher die tatsächlichen Variablen, die im Funktionsaufruf erscheinen, nicht ändern. Obwohl dieses Verhalten Vorteile hat, hat es auch Nachteile. Dies ist sicherlich ein guter Ansatz, wenn wir nur den Rückgabewert der Funktion nutzen möchten, kann jedoch stören, wenn das eigentliche Ziel darin besteht, die übergebene Variable zu ändern.

Im Folgenden wird die Implementierung eines eher ineffizienten Subtraktionsbeispiels zur Implementierung von Call-by-Value demonstriert:

fnction my_subtract($numl,$num2)

{

i ($numl < $num2)

de(“Negative Zahlen sind imaginär”);

$return_result = 0;

wile($numl > $num2)

{

$numl = $numl – 1;
rturn($return_result);

}

$first_op = 493 ;

$second_op = 355;

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

pint(“result1 is $result1< BR >“);

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

Print(“result2 ist $result2< BR >“);

Großartig, wir sehen, dass das Das Ergebnis der zweimaligen Durchführung derselben Subtraktion ist dasselbe:

rsult1 ist 138

rsult2 ist 138

Auch wenn my_subtract den Wert seines formalen Parameters $numl ändert, Sie wird weiterhin dieses Ergebnis erhalten. Die Variable $numl speichert nur eine Kopie des Werts im tatsächlichen Parameter $first_op, sodass $first_op davon nicht betroffen ist.

Call-by-Reference

PHP bietet zwei verschiedene Möglichkeiten, um eine Funktion besser in die Lage zu versetzen, Parameter in ihrer Definition oder in einem Funktionsaufruf, auch Call-by-Reference genannt, zu ändern.

Wenn Sie eine Funktion definieren möchten, die direkt auf die eingehenden Variablen einwirkt, können Sie vor den formalen Parametern in der Definition ein „&“-Symbol hinzufügen, wie unten gezeigt:

Funktion my_subtract_ref( &$numl,&$num2)

{

i($numl-<$num2)

de(“Negative Zahlen sind imaginär”);

$return_result = 0;

wile($num1 >$num2)

{

$numl = $num1 – 1;

$return_result = $return_result + 1;

}

rturn($return_result); >$second_op = 355;

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

pint(“result1 ist $result1< BR >“);

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

pint( „result2 is $result2< BR >“);

Wenn wir nun die gleiche Subtraktion wie vor dem Aufruf durchführen, erhalten Sie diese Ausgabe:

rsult1 ist 138

rsult1 ist 0

Dies liegt daran, dass sich der formale Parameter $numl und der tatsächliche Parameter $first_op auf denselben Inhalt beziehen. Das Ändern des einen ist gleichbedeutend mit dem Ändern des anderen.
Sie können eine Funktion auch dazu zwingen, Parameter entsprechend zu übergeben, indem Sie das „&“-Symbol vor dem eigentlichen Parameter hinzufügen (dies ist eine Funktion, die nach und nach ausläuft und möglicherweise in einer zukünftigen Version von PHP entfernt wird). Mit anderen Worten: Sie können die ursprüngliche Aufruffunktion nach Wert wie folgt verwenden:

$first_op = 493;

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

Print(“result1 is $result1< BR >“);

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

Print(“result2 is $result2< BR >“);

Diesmal haben wir das folgende Ergebnis erhalten:

rsult1 ist 138

rsult1 ist 0

Für PHP4 können variable Parameter auch außerhalb von Funktionsaufrufen verwendet werden. Im Allgemeinen führt die Zuweisung einer Variablenreferenz (&$varname) zu einer Variablen dazu, dass die beiden Variablen zu Aliasen
(d. h. Doppelgängern) voneinander werden und nicht zwei verschiedene Variablen mit demselben Wert sind. Zum Beispiel:

$name_1 = "Manfred von Richtofen";

$name_2 = "Percy Blakeney";

$alias_1 = $name_1; //Variablen haben das Gleiche value

$alias_2=&$name_2; //Die Variablen sind die gleichen

$alias_1 = „The Red Baron“; //Der tatsächliche Name hat sich nicht geändert

$alias_2 = "The Scarlet Pimpernel" "; //Es spielt keine Rolle, was es ist

Prnt("$alias_1 ist $name_1< BR> ");

Prnt("$ alias_2 ist $name_2< BR > ");

Der obige Programmcode erhält folgende Browserausgabe:

Der Rote Baron ist Manfred von Richtofen

Der Scharlachrote Pimpernel ist The Scarlet Pimpernel

Variabler Funktionsname

Eine sehr flexible Technik in PHP besteht darin, Variablen zu verwenden, um den Ort zu ersetzen, an dem der Benutzer die Funktion definiert. Das heißt, anstatt den literalen Funktionsnamen in den Programmcode einzugeben, können Sie eine Variable eingeben, die mit dem Symbol „&“ beginnt, und die tatsächliche Funktion, die während der Ausführung aufgerufen wird, hängt von der der Variablen zugewiesenen Zeichenfolge ab. Dies ermöglicht gewissermaßen die Verwendung von Funktionen als Daten. Diese Technik dürfte C-Programmierern bekannt sein, aber auch Anfängern jeder Art von Lisp-Sprache wie Scheme oder Common Lisp.

Zum Beispiel sind die folgenden zwei Funktionsaufrufe genau äquivalent:

functioncustomized_greeting()

{

print(“Sie werden in einem begrüßt individuelle Art und Weise!< >Der obige Programmcode erzeugt die gleiche Ausgabe:

Sie werden auf eine individuelle Art und Weise begrüßt!

Sie werden auf eine individuelle Art und Weise begrüßt!

Aufgrund des Funktionsnamens Ist eine Zeichenfolge, kann sie auch als Parameter der Funktion verwendet oder als Funktionsergebnis zurückgegeben werden.

Erweitertes Beispiel+

Werfen wir einen Blick auf die Probleme, die auftreten können, wenn Sie eine der erweiterten Funktionen von Funktionen verwenden, einschließlich der Verwendung von Funktionsnamen als Funktionsparameter.

Beispiel 8-1 Dieses Beispiel zeigt ein erweitertes Beispiel der Funktion. Diese Funktion vervollständigt die Funktion des Ersetzens des Passworts. Dies ist das primitivste Passwortsystem, bei dem ein Buchstabe durch einen anderen ersetzt wird die angezeigten Informationen.

Der folgende Programmcode ist länger und fortgeschrittener als jeder bisher in diesem Buch gezeigte Programmcode. Wer die Details nicht wissen möchte, kann diesen Code überspringen.

Beispiel 8-1 Dichte Substitution

/*Teil 1: kryptografische Berechnungen und Nutzenfunktionen*/

Funktion add 1 ($num)

{

return(($num+ 1)%26);

}

function sub_1($num)

{

return (($num+ 25)% 26);

}

Funktionstausch 2 ($num)

{

if($num % 2 = = 0)

return($num+ 1)；

else

return($num - 1)；

}

function swap 26($num)


{

return(25 - $num)；

}

Funktion Kleinbuchstabe($char string)

{

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

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

}

Funktion Großbuchstabe($char string)

{

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

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

}

/*第二部份：Buchstabenverschlüsselung函式 */

Funktion Buchstabenverschlüsselung ($char string, $code func)

{

if!(upper alphabet($char string)||

unterer Buchstabe ($char string)))

return($char string)；

if(upper leter($char string))

$base num = ord('A')；

else

$base num = ord($char string) –

$base num)；

return (chr($base num + 

($code func ($char num )

% 26)))；

}

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

function string cipher($message,$cipher func)

{

$coded message = ””；

$message length = strlen($message)；

for($index= 0；

$index < $Nachrichtenlänge；

$index++)

$codierte Nachricht .=

Buchstabenverschlüsselung ($message[$index],$cipher func)；

return($coded message)；

}

范例8-1共有三个部分。在第一部份中，我们定义了几个对数字0—25进行简单数字运算的函式, 这些数字代表密码程序中的字母A—Z。add_1把给它的数字加1, also 26% der Zeit（仅意味着26以及超过26的数字会“绕回“到开头从「0」开始.0变成1 、 1变成2 、…、25变成0。Sub_1则是沿另一个方向转换数字，透过加上25（在这种模数算法中就等于1, 25, 24, 24, 23, 0, 25. Swap_2到2… (25) 🎜>
所有这些函式都算是这个简易密码程序的基础.最后还有两个公用程序函式,用以测试字符是大写还是小写字母.

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

最后，第三部分是string_cipher（）函式,该函式带有一个字符串讯息,还有一个密码函式,它传回的是一个新字符串值,其值为透过函式进行编码的内容.这里用到一两个以前没见到的功能（其中包括字符串连接运算子「.=」,在第十章中会提到），这个函式从讯息字符串的字母逐一进行处理, 建构出新字符串, 并用新字母是对对照旧字母的数字表示应用了$cipher_func得到的结果，到这里你大概了解这些足够了.

下面，我们编写一些程序码测试string_cipher（）；

$ originak = „Meine geheime Nachricht ist ABCDEFG“；

Print(“Originalnachricht ist :$orginal< BR >“)；

$coding_array = array('add_1',

'sub_1,

'swap_2',

'swap_26') ；

For($count = 0；

$count < sizeof($coding_array)；

$coded_message = 

String_cipher($original, $code)；

Print(“$codekodierung ist:$coded_message< BR >”)；

}

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

ursprüngliche Nachricht ist: Meine geheime Nachricht ist ABCDEFG

add_1-Kodierung ist:Nz tfdsfu nfttbhf jt BCDEFGH

sub_1-Kodierung ist:Lx rdbqfs nfttbhf jt BADCFRH

swap_2-Kodierung ist:Nz tfdqfs nfttbhf jt BADCFEH

swap_26-Kodierung ist: Nb hvxivg nvhhztv rh ZYXWVUT

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

Function chained_code ($message)

{

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

Wendet jede Codierungsfunktion auf das vorherige Ergebnis an und gibt ihr Ergebnis zurück. */

$argc = func_num_args();

$coded = $message;

For ($count = 1; $count<$argc;$count++)

{

$function_name = func_get_arg($count);

$coded =

String_cipher($coded,

$function_name) ;

}

Return($coded);

}

Der erste Parameter von Chained_code() sollte eine Nachrichtenzeichenfolge sein, gefolgt von der entsprechenden Beliebig viele Namen für kryptografische Funktionen. Die codierte Nachricht ist das Ergebnis der Anwendung der ersten Codierungsfunktion auf die Nachricht, der anschließenden Anwendung der zweiten Codierungsfunktion auf das Ergebnis usw. Wir können dies testen, indem wir verschiedene Kombinationen vordefinierter alphabetischer Kodierungsfunktionen verwenden.

$tricky =

Chained_code($original,

'add_1''swap_26',

'add_1''swap_2');

Print(„Tricky encoded version is $tricky< BR >“);

$easy =

Chained_code($original,

'add_1',' swap_26',

'swap_','sub_1',

'add_1', 'swap_2,'

'swap_26,''sub_1,');

Print(„Einfach codierte Version ist $easy< BR >“);

Das Ergebnis ist:

Tricky codierte Version ist Ma guwjh Muggysu qg YXWXUVS

Die einfach codierte Version ist Meine geheime Nachricht ist ABCDEFG

Wie Sie sehen können, ist die „knifflige“ Nachricht eine Kombination vorcodierter Codes, entspricht jedoch nicht genau einer einzelnen Codierungsfunktion. Die „einfache“ Kodierung ist eine komplexere Kombination dieser Funktionen und das Ergebnis ist die ursprüngliche Nachricht ... ohne Änderungen! (Dies liegt nicht daran, dass der Schlüsselcode ungültig ist, wir möchten den Lesern lediglich verstehen lassen, warum diese spezielle Abfolge von Bearbeitungsfunktionen wieder zur ursprünglichen Nachricht zurückkehren kann.)

Was dieses kleine Passwort-Skript tut Der Zweck, das anzuzeigen Der Bereich soll Ihnen verständlich machen, dass das Passwortprogramm zwar etwas komplizierter ist, da PHP die Verwendung von Funktionsnamen als Funktionsparameter unterstützt, die Sache jedoch recht einfach ist.

Zusammenfassung

Der Großteil der PHP-Funktionalität besteht aus einer großen Anzahl integrierter Funktionen, die vom Open-Source-Entwicklungsteam von PHP bereitgestellt werden. Für jede Funktion sollte im Online-Handbuch unter http://www.php.net eine Beschreibung (auch wenn einige davon kurz sind) vorhanden sein.

Sie können auch Ihre eigene Funktion schreiben, auf die dann genauso zugegriffen werden kann wie auf die integrierten Funktionen. Funktionen werden in einfacher C-Stil-Syntax wie folgt geschrieben:

Function my_function ($argl,$arg2,…)

{

Statement1;

Anweisung2;

…

Return($value); In Verbindung mit anderen Parametern kann auch jede Art von Wert zurückgegeben werden. Es ist nicht erforderlich, die Parametertypen und Rückgabewerte zu deklarieren.

In PHP4 gibt es keinen Unterschied zwischen der Anzahl der Funktionsdefinitionen und Funktionsaufrufen, solange jede aufgerufene Funktion definiert wurde. Es ist keine separate Funktionsdeklaration oder Prototyping erforderlich. Innerhalb einer Funktion angegebene Variablen sind auf den Funktionsbereich beschränkt, sofern keine globale Deklaration verwendet wird. Lokale Variablen können als statisch deklariert werden, was bedeutet, dass sie ihre Werte zwischen Funktionsaufrufen behalten.

Das Standardaktionsverhalten benutzerdefinierter Funktionen ist „call_by_reference“. Dies bedeutet, dass die Funktion eine Kopie der Parameter im Betrieb verwendet und daher nicht in der Originalvariable geändert werden kann. Durch das Hinzufügen eines „&“ vor dem Parameter können Sie „Call-by-Reference“ erzwingen, das entweder auf der definierenden Seite oder auf der aufrufenden Seite verwendet werden kann. PHP bietet verschiedene Möglichkeiten, die Anzahl der von einer Funktion übernommenen Parameter variabel zu gestalten. Schließlich kann die aufzurufende Funktion zur Ausführungszeit bestimmt werden, indem der Name der benutzerdefinierten Funktion durch eine Zeichenfolgenvariable ersetzt wird. Dadurch kann die Funktion als Daten behandelt und zwischen anderen Funktionen hin- und hergereicht werden.

Das Obige ist der Inhalt des PHP-Lernhandbuchs – Kapitel 8 (2). Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).