Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)
Mit einer Parameterliste kann man Informationen an eine Funktion übergeben. Die Parameterliste ist eine durch Kommas getrennte Liste von Ausdrücken.
PHP unterstützt die Weitergabe von Parametern als Werte (das ist der Standard), als Verweise und als Vorgabewerte. Eine variable Anzahl von Parametern wird ebenfalls unterstützt, siehe auch die Funktionsreferenzen für func_num_args(), func_get_arg() und func_get_args() für weitere Informationen.
Beispiel #1 Arrays an Funktionen übergeben
<?php
function rechne_array($eingabe)
{
echo "$eingabe[0] + $eingabe[1] = ", $eingabe[0]+$eingabe[1];
}
?>
Normalerweise werden den Funktionen Werte als Parameter übermittelt. Wenn man den Wert dieses Parameters innerhalb der Funktion ändert, bleibt der Parameter außerhalb der Funktion unverändert. Wollen Sie aber erreichen, dass die Änderung auch außerhalb der Funktion sichtbar wird, müssen Sie die Parameter als Verweise (Referenzen) übergeben.
Wenn eine Funktion einen Parameter generell als Verweis behandeln soll, setzt man in der Funktionsdefinition ein kaufmännisches Und (&) vor den Parameternamen:
Beispiel #2 Übergeben von Funktionsparametern als Verweis
<?php
function fuege_etwas_anderes_an (&$string)
{
$string .= 'und nun zu etwas anderem.';
}
$str = 'Dies ist ein String, ';
fuege_etwas_anderes_an ($str);
echo $str; // Ausgabe: 'Dies ist ein String, und nun zu etwas anderem.'
?>
Eine Funktion kann C++-artige Vorgabewerte für skalare Parameter wie folgt definieren:
Beispiel #3 Einsatz von Vorgabeparametern
<?php
function machkaffee ($typ = "Cappucino")
{
return "Ich mache eine Tasse $typ.\n";
}
echo machkaffee ();
echo machkaffee (null);
echo machkaffee ("Espresso");
?>
Die Ausgabe von diesem kleinen Skript ist:
PHP gestattet es, Arrays und den speziellen Typ NULL als Vorgabewert zu nutzen, zum Beispiel:
Beispiel #4 Nichtskalare Typen als Vorgabewert
<?php
function makecoffee ($types = array("cappuccino"), $coffeeMaker = NULL)
{
$device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
return "Ich mache eine Tasse ".join(", ", $types)." mit $device.\n";
}
echo makecoffee ();
echo makecoffee (array("cappuccino", "lavazza"), "teapot");
?>
Der Vorgabewert muss ein konstanter Ausdruck sein, darf also zum Beispiel keine Variable, Eigenschaft einer Klasse oder ein Funktionsaufruf sein.
Bitte beachten Sie, dass alle Vorgabewerte rechts von den Nicht-Vorgabeparametern stehen sollten - sonst wird es nicht funktionieren. Betrachten Sie folgendes Beispiel:
Beispiel #5 Ungültige Anwendung von Vorgabewerten
<?php
function mach_joghurt ($typ = "rechtsdrehendes", $geschmack)
{
return "Mache einen Becher $typ $geschmack-joghurt.\n";
}
echo mach_joghurt ("Brombeer"); // arbeitet nicht wie erwartet
?>
Die Ausgabe dieses Beispiels ist:
Nun vergleichen Sie bitte oberes Beispiel mit folgendem:
Beispiel #6 Richtiger Einsatz von Vorgabewerten
<?php
function mach_joghurt ($geschmack, $typ = "rechtsdrehendes")
{
return "Mache einen Becher $typ $geschmack-Joghurt.\n";
}
echo mach_joghurt ("Brombeer"); // arbeitet wie erwartet.
?>
... und jetzt ist die Ausgabe:
Hinweis: Das Setzen von Standardwerten für Argumente, die als Referenz übergeben werden ("passed by reference") wird seit PHP 5 unterstützt.
Beginnend mit PHP 4 wird eine variable Anzahl von Parametern in benutzerdefinierten Funktionen unterstützt. Das Handling dieser Parameter fällt mittels der Funktionen func_num_args(), func_get_arg() und func_get_args() sehr leicht.
Es ist keine spezielle Syntax erforderlich. Die Parameter können wie gehabt explizit in den Funktionsdeklarationen angegeben werden und werden sich wie gewohnt verhalten.
You can use (very) limited signatures for your functions, specifing type of arguments allowed.
For example:
public function Right( My_Class $a, array $b )
tells first argument have to by object of My_Class, second an array. My_Class means that you can pass also object of class that either extends My_Class or implements (if My_Class is abstract class) My_Class. If you need exactly My_Class you need to either make it final, or add some code to check what $a really.
Also note, that (unfortunately) "array" is the only built-in type you can use in signature. Any other types i.e.:
public function Wrong( string $a, boolean $b )
will cause an error, because PHP will complain that $a is not an *object* of class string (and $b is not an object of class boolean).
So if you need to know if $a is a string or $b bool, you need to write some code in your function body and i.e. throw exception if you detect type mismatch (or you can try to cast if it's doable).
This may be helpful when you need to call an arbitrary function known only at runtime:
You can call a function as a variable name.
<?php
function foo(){
echo"\nfoo()";
}
function callfunc($x, $y = '')
{
if( $y=='' )
{
if( $x=='' )
echo "\nempty";
else $x();
}
else
$y->$x();
}
class cbar {
public function fcatch(){ echo "\nfcatch"; }
}
$x = '';
callfunc($x);
$x = 'foo';
callfunc($x);
$o = new cbar();
$x = 'fcatch';
callfunc($x, $o);
echo "\n\n";
?>
The code will output
empty
foo()
fcatch
Nothing was written here about argument types as part of the function definition.
When working with classes, the class name can be used as argument type. This acts as a reminder to the user of the class, as well as a prototype for php control. (At least in php 5 -- did not check 4).
<?php
class foo {
public $data;
public function __construct($dd)
{
$this->data = $dd;
}
};
class test {
public $bar;
public function __construct(foo $arg) // Strict typing for argument
{
$this->bar = $arg;
}
public function dump()
{
echo $this->bar->data . "\n";
}
};
$A = new foo(25);
$Test1 = new test($A);
$Test1->dump();
$Test2 = new test(10); // wrong argument for testing
?>
outputs:
25
PHP Fatal error: Argument 1 passed to test::__construct() must be an object of class foo, called in testArgType.php on line 27 and defined in testArgType.php on line 13
Hey,
I started to learn for the Zend Certificate exam a few days ago and I got stuck with one unanswered-well question.
This is the question:
“Absent any actual need for choosing one method over the other, does passing arrays by value to a read-only function reduce performance compared to passing them by reference?’
This question answered by Zend support team at Zend.com:
"A copy of the original $array is created within the function scope. Once the function terminates, the scope is removed and the copy of $array with it." (By massimilianoc)
Have a nice day!
Shaked KO
I like to pass an associative array as an argument. This is reminiscent of a Perl technique and can be tested with is_array. For example:
<?php
function div( $opt )
{
$class = '';
$text = '';
if( is_array( $opt ) )
{
foreach( $opt as $k => $v )
{
switch( $k )
{
case 'class': $class = "class = '$v'";
break;
case 'text': $text = $v;
break;
}
}
}
else
{
$text = $opt;
}
return "<div $class>$text</div>";
}
?>
There is a nice trick to emulate variables/function calls/etc as default values:
<?php
$myVar = "Using a variable as a default value!";
function myFunction($myArgument=null) {
if($myArgument===null)
$myArgument = $GLOBALS["myVar"];
echo $myArgument;
}
// Outputs "Hello World!":
myFunction("Hello World!");
// Outputs "Using a variable as a default value!":
myFunction();
// Outputs the same again:
myFunction(null);
// Outputs "Changing the variable affects the function!":
$myVar = "Changing the variable affects the function!";
myFunction();
?>
In general, you define the default value as null (or whatever constant you like), and then check for that value at the start of the function, computing the actual default if needed, before using the argument for actual work.
Building upon this, it's also easy to provide fallback behaviors when the argument given is not valid: simply put a default that is known to be invalid in the prototype, and then check for general validity instead of a specific value: if the argument is not valid (either not given, so the default is used, or an invalid value was given), the function computes a (valid) default to use.
Actually the use of class or global constants does buy us something. It helps enforce the DRY (don't repeat yourself) principle.
@ jbarnett at flowershopnetwork dot com:
Yes, but that doesn't get us anywhere; you could just as well have said:
myMethod($arg = "constant value")
Class constants must have constant values, as well. http://www.php.net/manual/en/language.oop5.constants.php
With regards to:
It is also possible to force a parameter type using this syntax. I couldn't see it in the documentation.
function foo(myclass par) { }
I think you are referring to Type Hinting. It is documented here: http://ch2.php.net/language.oop5.typehinting
Note that constants can also be used as default argument values
so the following code:
define('TEST_CONSTANT','Works!');
function testThis($var=TEST_CONSTANT) {
echo "Passing constants as default values $var";
}
testThis();
will produce :
Passing constants as default values Works!
(I tried this in both PHP 4 and 5)
Note that passing by reference doesn't speed up your php script. PHP is smart enough not to simply copy data every time the language requires it. Rahter, PHP uses a reference and waits until the copy (a copied variable or a copy used in a function) is actually used as a copy and creates one then.
This might be documented somewhere OR obvious to most, but when passing an argument by reference (as of PHP 5.04) you can assign a value to an argument variable in the function call. For example:
function my_function($arg1, &$arg2) {
if ($arg1 == true) {
$arg2 = true;
}
}
my_function(true, $arg2 = false);
echo $arg2;
outputs 1 (true)
my_function(false, $arg2 = false);
echo $arg2;
outputs 0 (false)
I ran into the problem that jcaplan mentionned. I had just finished building 2 handler classes and one interface.
During my testing I realized that my handlers were not initializing their variables to their default values when my interface was calling them with 'null' values:
this is a simplified illustration:
<?php
function some_function($v1='value1',$v2='value2',$v3='value3'){
echo $v1.', ';
echo $v2.', ';
echo $v3;
}
some_function(); //this will behave as expected, displaying 'value1, value2, value3'
some_function(null,null,null); //this on the other hand will display ', ,' since the variables will take the null value.
?>
I came to about the same conclusion as jcaplan. To force your function parameters to take a default value when a null is passed you need to include a conditionnal assignment inside the function definition.
<?php
function some_function($v1='value1',$v2='value1',$v3=null){
$v1=(is_null($v1)?'value1':$v1);
$v2=(is_null($v2)?'value2':$v2);
$v3=(is_null($v3)?'value3':$v3);
echo $v1;
echo $v2;
echo $v3;
}
/*
The default value whether null or an actual value is not so important in the parameter list, what is important is that you include it to allow a default behavior. The default value in the declaration becomes more important at this point:
*/
?>
In function calls, PHP clearly distinguishes between missing arguments and present but empty arguments. Thus:
<?php
function f( $x = 4 ) { echo $x . "\\n"; }
f(); // prints 4
f( null ); // prints blank line
f( $y ); // $y undefined, prints blank line
?>
The utility of the optional argument feature is thus somewhat diminished. Suppose you want to call the function f many times from function g, allowing the caller of g to specify if f should be called with a specific value or with its default value:
<?php
function f( $x = 4 ) {echo $x . "\\n"; }
// option 1: cut and paste the default value from f's interface into g's
function g( $x = 4 ) { f( $x ); f( $x ); }
// option 2: branch based on input to g
function g( $x = null ) { if ( !isset( $x ) ) { f(); f() } else { f( $x ); f( $x ); } }
?>
Both options suck.
The best approach, it seems to me, is to always use a sentinel like null as the default value of an optional argument. This way, callers like g and g's clients have many options, and furthermore, callers always know how to omit arguments so they can omit one in the middle of the parameter list.
<?php
function f( $x = null ) { if ( !isset( $x ) ) $x = 4; echo $x . "\\n"; }
function g( $x = null ) { f( $x ); f( $x ); }
f(); // prints 4
f( null ); // prints 4
f( $y ); // $y undefined, prints 4
g(); // prints 4 twice
g( null ); // prints 4 twice
g( 5 ); // prints 5 twice
?>
by default Classes constructor does not have any arguments. Using small trick with func_get_args() and other relative functions constructor becomes a function w/ args (tested in php 5.1.2). Check it out:
class A {
public function __construct() {
echo func_num_args() . "<br>";
var_dump( func_get_args());
echo "<br>";
}
}
$oA = new A();
$oA = new A( 1, 2, 3, "txt");
Output:
0
array(0) { }
4
array(4) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> string(3) "txt" }
PASSING A "VARIABLE-LENGTH ARGUMENT LIST OF REFERENCES" TO A FUNCTION
As of PHP 5, Call-time pass-by-reference has been deprecated, this represents no problem in most cases, since instead of calling a function like this:
myfunction($arg1, &$arg2, &$arg3);
you can call it
myfunction($arg1, $arg2, $arg3);
provided you have defined your function as
function myfuncion($a1, &$a2, &$a3) { // so &$a2 and &$a3 are
// declared to be refs.
... <function-code>
}
However, what happens if you wanted to pass an undefined number of references, i.e., something like:
myfunction(&$arg1, &$arg2, ..., &$arg-n);?
This doesn't work in PHP 5 anymore.
In the following code I tried to amend this by using the
array() language-construct as the actual argument in the
call to the function.
<?php
function aa ($A) {
// This function increments each
// "pseudo-argument" by 2s
foreach ($A as &$x) {
$x += 2;
}
}
$x = 1; $y = 2; $z = 3;
aa(array(&$x, &$y, &$z));
echo "--$x--$y--$z--\n";
// This will output:
// --3--4--5--
?>
I hope this is useful.
Sergio.
Given that we have two coding styles:
#
# Code (A)
#
funtion foo_a (&$var)
{
$var *= 2;
return $var;
}
foo_a($a);
#
# Code (B)
#
function foo_b ($var)
{
$var *= 2;
return $var;
}
foo_b(&$a);
I personally wouldn't recommend (B) - I think it strange why php would support such a convention as it would have violated foo_b's design - its use would not do justice to its function prototype. And thinking about such use, I might have to think about copying all variables instead of working directly on them...
Coding that respects function prototypes strictly would, I believe, result in code that is more intuitive to read. Of course, in php <=4, not being able to use default values with references, we can't do this that we can do in C:
#
# optional return-value parameters
#
int foo_c (int var, int *ret)
{
var *= 2;
if (ret) *ret = var;
return var;
}
foo_c(2, NULL);
Of course, since variables are "free" anyway, we can always get away with it by using dummy variables...
zlel
Of course you can fake a global variable for a default argument by something like this:
<?php
function self_url($text, $page, $per_page = NULL) {
$per_page = ($per_page == NULL) ? $GLOBALS['gPER_PAGE'] : $per_page; # setup a default value of per page
return sprintf("<a href=%s?page=%s&perpage=%s>%s</a>", $_SERVER["PHP_SELF"], $page, $per_page, $text);
}
?>
It is so easy to create a constant that the php novice might do so accidently while attempting to call a function with no arguments. For example:
<?php
function LogoutUser(){
// destroy the session, the cookie, and the session ID
blah blah blah;
return true;
}
function SessionCheck(){
blah blah blah;
// check for session timeout
...
if ($timeout) LogoutUser; // should be LogoutUser();
}
?>
OOPS! I don't notice my typo, the SessionCheck function
doesn't work, and it takes me all afternoon to figure out why not!
<?php
LogoutUser;
print "new constant LogoutUser is " . LogoutUser;
?>
(in reply to benk at NOSPAM dot icarz dot com / 24-Jun-2005 04:21)
I could make use of this assignment, as below, to have a permanently existing, but changing data block (because it is used by many other classes), where the order or the refreshed contents are needed for the others: (DB init done by one, an other changed the DB, and thereafter all others need to use the other DB without creating new instances, or creating a log array in one, and we would like to append the new debug strings to the array, atmany places.)
class xyz {
var argN = array();
function xyz($argN) {
$this->argN = &$argN;
}
function etc($text) {
array_push($this->argN, $text);
}
}
class abc {
var argM = array();
function abc($argM) {
$this->argM = &$argM;
}
function etc($text) {
array_push($this->argM, $text);
}
}
$messages=array("one", "two");
$x = new xyz(&$messages);
$x->etc("test");
$a = new abc(&$messages);
$a->etc("tset");
...
This isn't necessarily the right place to store this piece of information, but I discovered a neat feature of the 'by reference' operator (&). You can use this assignment operator to assign a pointer to another variable. This makes it possible to update BOTH varaibles and have the value change in the other. I have not yet explored scope of this test, but here is a simple test that I ran on PHP 4.3.9 with the following results:
$abc = "Test";
$def = "";
print("ABC = $abc\tDEF = $def\n"); // ABC = Test DEF =
$def = &$abc;
print("ABC = $abc\tDEF = $def\n"); // ABC = Test DEF = Test
$abc = "test2";
print("ABC = $abc\tDEF = $def\n"); // ABC = test2 DEF = test2
$def = "nextval";
print("ABC = $abc\tDEF = $def\n"); // ABC = nextval DEF = nextval
unset($def);
print("ABC = $abc\tDEF = $def\n"); // ABC = nextval DEF =
$def = "yet another value";
print("ABC = $abc\tDEF = $def\n"); // ABC = nextval DEF = yet another value
Argument evaluation left to right means that you can save yourself a temporary variable in the example below whereas $current = $prior + ($prior=$current) is just the same as $current *= 2;
function Sum() { return array_sum(func_get_args()); }
function Fib($n,$current=1,$prior=0) {
for (;--$n;) $current = Sum($prior,$prior=$current);
return $current;
}
Csaba Gabor
PS. You could, of course, just use array_sum(array(...)) in place of Sum(...)
I have some functions that I'd like to be able to pass arguments two ways: Either as an argument list of variable length (e.g. func(1, 2, 3, 4)) or as an array (e.g., func(array(1,2,3,4)). Only the latter can be constructed on the fly (e.g., func($ar)), but the syntax of the former can be neater.
The way to do it is to begin the function as follows:
$args = func_get_args();
if (is_array ($args[0]))
$args = $args[0];
Then one can just use $args as the list of arguments.
Call-time pass-by-ref arguments are deprecated and may not be supported later, so doing this:
----
function foo($str) {
$str = "bar";
}
$mystr = "hello world";
foo(&$mystr);
----
will produce a warning when using the recommended php.ini file. The way I ended up using for optional pass-by-ref args is to just pass an unused variable when you don't want to use the resulting parameter value:
----
function foo(&$str) {
$str = "bar";
}
foo($_unused_);
----
Note that trying to pass a value of NULL will produce an error.
A tiny clarification on the notes of "keeper at odi dot com dot br", et. al.
Functions explicitly prototyped with formal parameters passed by reference can't have default values. However, functions prototyped to assign default values to formal parameters may be passed references.
For example, this is a parse error:
function foo(&$bar = null) {
// formal parameters as references can't have default values
$bar = 242;
}
While this is perfectly legal (and probably what you want, mostly):
function foo($bar = null) {
$bar = 242;
}
foo(); // valid call, no warnings about missing args
foo(&$x); // valid call, post $x == 242
not only do default values not work with passing by reference, but you can't pass NULL as a parameter that is expected to be a reference, and passing too few parameters to a function causes a warning.
have function
function foo($bar=3) {
if (!isset($bar)) {
echo "I'm not set to my default value";
}
and if you do
foo($some_unset_variable);
the $bar variable does not adopt default value (3) as one might expect but it is not set.
Concerning default values for arguments passed by reference:
I often use that trick:
func($ref=$defaultValue) {
$ref = "new value";
}
func(&$var);
print($var) // echo "new value"
Setting $defaultValue to null enables you to write functions with optional arguments which, if given, are to be modified.
concerning rbronosky@mac.com 11-May-2001 06:17:
You can include the variable name in the output if you simply pass that name instead of the value:
function show($arrayName) {
global $$arrayName;
echo("<pre>\n$arrayName == ");
print_r($$arrayName);
echo "</pre>";
}
show('myArray');
Follow up to resource passing:
It appears that if you have defined the resource in the same file
as the function that uses it, you can get away with the global trick.
Here's the failure case:
include "functions_doing_globals.php"
$conn = openDatabaseConnection();
invoke_function_doing_global_conn();
...that it fails.
Perhaps it's some strange scoping problem with include/require, or
globals trying to resolve before the variable is defined, rather
than at function execution.
Whem arguments are passed by reference, default values won't work.
I have tried the example given by ak@avatartech.com
it did not work I use php 4.0.6 on windows 98
I do think that it is good that there is no automatic parameter passing, thus it would force people to do good programming practie
There is no way how to deal with calling by reference when variable lengths argument list are passed.
<br>Only solutions is to use construction like this:<br>
function foo($args) {<br>
...
}
foo(array(&$first, &$second));
Above example pass by value a list of references to other variables :-)
It is courios, becouse when you call a function with arguments passed via &$parameter syntax, func_get_args returns array of copies :-(
rwi
here is the code to pass a user defined function as an argument. Just like in the usort method.
<?php
func2("func1");
function func1 ($arg){
print ("Hello $arg");
}
function func2 ($arg1){
$arg1("World"); //Does the same thing as the next line
call_user_func ($arg1, "World");
}
?>
With reference to the note about extract() by dietricha@subpop.com:
He is correct and this is great! What he does not say explicitly is that the extracted variable names have the scope of the function, not the global namespace. (This is the appropriate behavior IMO.) If for some reason you want the extracted variables to be visible in the global namespace, you must declare them 'global' inside the function.
Nice to know is this:
If you call a function giving an unset variable, it will be unset in the function. Consider this:
<?php
function my_test ($var) {
if (isset ($var)) echo ("set");
}
my_test ($unused);
?>
This will _not_ echo "set", regardless of the variable being passed by value or by reference.
(If my newlines are messed up, sorry, this seems to be a konqueror problem)
if you compiled with "--enable-track-vars" then an easy way to get variable function args is to use extract().
<?php
$args = array("color" = "blue","number" = 3);
function my_func($args){
extract($args);
echo $color;
echo $number;
}
?>
the above strategy makes it real easy to globalize form data within functions, or to pass form data arrays to functions:
<input type="text" name="test[color]" value="blue">
etc, etc.
Then in your function, pass $test to extract() to turn the array data into global vars.
or
<?php
function my_func($HTTP_POST_VARS){
extract($HTTP_POST_VARS);
// use all your vars by name!
}
?>
If you prefer to use named arguments to your functions (so you don't have to worry about the order of variable argument lists), you can do so PERL style with anonymous arrays:
<?php
function foo($args)
{
print "named_arg1 : " . $args["named_arg1"] . "\n";
print "named_arg2 : " . $args["named_arg2"] . "\n";
}
foo(array("named_arg1" => "arg1_value", "named_arg2" => "arg2_value"));
?>
will output:
named_arg1 : arg1_value
named_arg2 : arg2_value
Re: Passing By Reference Inside A Class
Passing arguments by reference does work inside a class. When you do:
$this->testVar = $ref;
inside setTestVar(), you're copying by value instead of copying by reference. I think what you want there is this:
$this->testVar = &$ref;
Which is the new "assign by reference" syntax that was added in PHP4.
You may pass any number of extra parameters to a function, regardless of the prototyping. In addition, the arguments passed to a function will be available via the variable names defined in the function prototype, as well as via the func_get_arg() and func_get_args() functions.
For example:
function printme ($arg) {
for ($ndx = 0; $ndx < $num_args; ++$ndx)
$output .= func_get_arg ($ndx);
print $output;
}
printme ("one ", "two"); # This prints "one two".
This behavior is useful for setting default values for function arguments and for ensuring that a certain number of arguments get passed to a function.
Diese Seite bei php.net