PHP: name parameters when passing them to a method? - php

Question

Some languages allow us to name parameters when passing them to methods, e.g.:
private static function hello(a, long, list = 0, of = 0, parameters = 0)
{
...
}
self::hello(a=1, long=2, list=3, of=4);
It certainly simplifies reading code in some cases. Is there a similar functionality in php?
The most simple construction that I could imagine is:
self::hello(/*a*/ 1, /*long*/ 2, /*list*/ 3, /*of*/ 4);
[offtopic]Love Obj C... It requires to name parameters:[self helloA:1 long:2 list:3 of:4];[/offtopic]

Answer 1

PHP does not provide such functionality but it can be faked to a large degree of realism. I just wrote this thing. Not 100% tested but if used correctly, it will work.
Example of how you use it:
call_user_func_args(function($a1, $a2, array $a3 = null, $a4 = null){
var_dump(func_get_args());
}, array(
'a1' => 1,
'a3' => null,
'a2' => 2,
));
// Output
array (size=3)
0 => int 1
1 => int 2
2 => null
It uses \ in front of classes as it's namespaced code intended for use with PHP 5.3 or later. Remove the \ to try to use it in 5.2, but no guarantees.
Here is the code:
/**
* Calls a function with named arguments.
* Just written and quite tested. If you find bugs, please provide feedback and I'll update the code.
* In a sane usage scenario, it will work. If you try your best, you might break it :)
* If true, $ValidateInput tries to warn you of issues with your Arguments, bad types, nulls where they should not be.
*
* #copyright Claudrian
* #param callable $Callable
* #param array $Arguments
* #param bool $ValidateInput
* #return mixed
*/
function call_user_func_args($Callable, array $Arguments, $ValidateInput = false){
// Make sure the $Callable is callable
if(!is_callable($Callable)){
trigger_error('$Callable is not a callable.', E_USER_WARNING);
return false;
}
// No arguments, no game
if(empty($Arguments)){
return call_user_func($Callable);
}
// Validate the input $Arguments
array_change_key_case($Arguments, CASE_LOWER);
foreach($Arguments as $ArgumentName => $ArgumentValue){
if(empty($ArgumentName) or is_numeric($ArgumentName)){
trigger_error('$Arguments cannot have numeric offsets.', E_USER_WARNING);
return false;
}
if(!preg_match('~^[a-z_][a-z0-9_]*$~', $ArgumentName)){
trigger_error('$Arguments contains illegal character offsets.', E_USER_WARNING);
return false;
}
}
// Get access to the function
try {
$Reflector = new \ReflectionFunction($Callable);
} catch(\Exception $Exception){
trigger_error($Exception->getMessage(), E_USER_WARNING);
return false;
}
// If function has not arguments, just call it but it's stupid
$RequiredParameterCount = $Reflector->getNumberOfRequiredParameters();
$ParameterCount = $Reflector->getNumberOfParameters();
if(!$ParameterCount){
return call_user_func($Callable);
}
// Prepare the $Parameters
$Parameters = array();
$PresetParameters = array();
foreach($Reflector->getParameters() as $Parameter){
$LowerName = strtolower($Name = $Parameter->getName());
$Argument = ($Available = array_key_exists($Name, $Arguments)) ? $Arguments[$Name] : null;
$Default = ($IsDefault = $Parameter->isDefaultValueAvailable()) ? $Parameter->getDefaultValue() : null;
$Parameters[$LowerName] = array(
'Name' => $Name,
'Offset' => $Parameter->getPosition(),
'Optional' => $Parameter->isOptional(),
'Nullable' => $Parameter->allowsNull(),
'Reference' => $Parameter->isPassedByReference(),
'Array' => $Parameter->isArray(),
'Defaultable' => $IsDefault,
'Default' => $Default,
'Available' => $Available,
'Provided' => $Available ? $Argument : $Default,
);
}
// Pop pointless nulls (from the last to the first)
end($Parameters);
while($Parameter = current($Parameters)){
if(!$Parameter['Nullable'] or !$Parameter['Optional'] or !is_null($Parameter['Provided'])){
break;
}
array_pop($Parameters); // Pop trailing null optional nullable arguments
prev($Parameters); // Move one back
}
// Prepare the final $Arguments
$Arguments = array();
foreach($Parameters as $Name => $Parameter){
if($ValidateInput){
if(is_null($Parameter['Provided']) and !$Parameter['Nullable']){
trigger_error("Argument '{$Name}' does not accept NULL.", E_USER_NOTICE);
}
if($Parameter['Array'] and !is_array($Parameter['Provided'])){
if(!$Parameter['Nullable'] and is_null($Parameter['Provided'])){
trigger_error("Argument '{$Name}' should be an array.", E_USER_NOTICE);
}
}
if(!$Parameter['Available'] and !$Parameter['Optional'] and !$Parameter['Defaultable']){
trigger_error("Argument '{$Name}' is not optional and not provided.", E_USER_NOTICE);
}
}
// Stoe this in the final $Arguments array
$Arguments[] = $Parameter['Provided'];
}
// Invoke the actual function
return $Reflector->invokeArgs($Arguments);
}

Answer 2

You could do
$a=1;
$long=2;
$list=3;
$of=4;
self::hello($a, $long, $list, $of);
Other way, would be to use setters to set the values in object before You call hello.
Though in Your example it's a private method...
Your reference here should be http://www.php.net/manual/en/functions.arguments.php