PHP 函数重载
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/4697705/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
PHP function overloading
提问by Vamsi Krishna B
Coming from C++ background ;)
How can I overload PHP functions?
来自 C++ 背景 ;)
如何重载 PHP 函数？
One function definition if there are any arguments, and another if there are no arguments? Is it possible in PHP? Or should I use if else to check if there are any parameters passed from $_GET and POST?? and relate them?
如果有任何参数，一个函数定义，如果没有参数另一个？在 PHP 中可能吗？或者我应该使用 if else 来检查是否有任何从 $_GET 和 POST 传递的参数？？并将它们联系起来？
回答by BoltClock
You cannot overload PHP functions. Function signatures are based only on their names and do not include argument lists, so you cannot have two functions with the same name. Class method overloadingis different in PHP than in many other languages. PHP uses the same word but it describes a different pattern.
您不能重载 PHP 函数。函数签名仅基于它们的名称，不包括参数列表，因此不能有两个具有相同名称的函数。PHP 中的类方法重载与许多其他语言不同。PHP 使用相同的词，但它描述了不同的模式。
You can, however, declare a variadic functionthat takes in a variable number of arguments. You would use func_num_args()and func_get_arg()to get the arguments passed, and use them normally.
你可以，但是，声明可变参数函数，它接受的参数个数可变。您将使用func_num_args()和func_get_arg()来获取传递的参数，并正常使用它们。
For example:
例如：
function myFunc() {
for ($i = 0; $i < func_num_args(); $i++) {
printf("Argument %d: %s\n", $i, func_get_arg($i));
}
}
/*
Argument 0: a
Argument 1: 2
Argument 2: 3.5
*/
myFunc('a', 2, 3.5);
回答by Stephen
PHP doesn't support traditional method overloading, however one way you might be able to achieve what you want, would be to make use of the __callmagic method:
PHP 不支持传统的方法重载，但是您可能能够实现所需的一种方法是使用__call魔术方法：
class MyClass {
public function __call($name, $args) {
switch ($name) {
case 'funcOne':
switch (count($args)) {
case 1:
return call_user_func_array(array($this, 'funcOneWithOneArg'), $args);
case 3:
return call_user_func_array(array($this, 'funcOneWithThreeArgs'), $args);
}
case 'anotherFunc':
switch (count($args)) {
case 0:
return $this->anotherFuncWithNoArgs();
case 5:
return call_user_func_array(array($this, 'anotherFuncWithMoreArgs'), $args);
}
}
}
protected function funcOneWithOneArg($a) {
}
protected function funcOneWithThreeArgs($a, $b, $c) {
}
protected function anotherFuncWithNoArgs() {
}
protected function anotherFuncWithMoreArgs($a, $b, $c, $d, $e) {
}
}
回答by Adil Abbasi
To over load a function simply do pass parameter as null by default,
要重载函数，只需默认将参数传递为 null，
class ParentClass
{
function mymethod($arg1 = null, $arg2 = null, $arg3 = null)
{
if( $arg1 == null && $arg2 == null && $arg3 == null ){
return 'function has got zero parameters <br />';
}
else
{
$str = '';
if( $arg1 != null )
$str .= "arg1 = ".$arg1." <br />";
if( $arg2 != null )
$str .= "arg2 = ".$arg2." <br />";
if( $arg3 != null )
$str .= "arg3 = ".$arg3." <br />";
return $str;
}
}
}
// and call it in order given below ...
$obj = new ParentClass;
echo '<br />$obj->mymethod()<br />';
echo $obj->mymethod();
echo '<br />$obj->mymethod(null,"test") <br />';
echo $obj->mymethod(null,'test');
echo '<br /> $obj->mymethod("test","test","test")<br />';
echo $obj->mymethod('test','test','test');
回答by SeanDowney
It may be hackish to some, but I learned this way from how Cakephp does some functions and have adapted it because I like the flexibility it creates
对某些人来说这可能是 hackish，但我从 Cakephp 如何执行某些功能中学到了这种方式并对其进行了调整，因为我喜欢它创造的灵活性
The idea is you have different type of arguments, arrays, objects etc, then you detect what you were passed and go from there
这个想法是你有不同类型的参数、数组、对象等，然后你检测你传递的内容并从那里开始
function($arg1, $lastname) {
if(is_array($arg1)){
$lastname = $arg1['lastname'];
$firstname = $arg1['firstname'];
} else {
$firstname = $arg1;
}
...
}
回答by Hisham Dalal
<?php
/*******************************
* author : [email protected]
* version : 3.8
* create on : 2017-09-17
* updated on : 2020-01-12
*****************************/
#> 1. Include Overloadable class
class Overloadable
{
static function call($obj, $method, $params=null) {
$class = get_class($obj);
// Get real method name
$suffix_method_name = $method.self::getMethodSuffix($method, $params);
if (method_exists($obj, $suffix_method_name)) {
// Call method
return call_user_func_array(array($obj, $suffix_method_name), $params);
}else{
throw new Exception('Tried to call unknown method '.$class.'::'.$suffix_method_name);
}
}
static function getMethodSuffix($method, $params_ary=array()) {
$c = '__';
if(is_array($params_ary)){
foreach($params_ary as $i=>$param){
// Adding special characters to the end of method name
switch(gettype($param)){
case 'array': $c .= 'a'; break;
case 'boolean': $c .= 'b'; break;
case 'double': $c .= 'd'; break;
case 'integer': $c .= 'i'; break;
case 'NULL': $c .= 'n'; break;
case 'object':
// Support closure parameter
if($param instanceof Closure ){
$c .= 'c';
}else{
$c .= 'o';
}
break;
case 'resource': $c .= 'r'; break;
case 'string': $c .= 's'; break;
case 'unknown type':$c .= 'u'; break;
}
}
}
return $c;
}
// Get a reference variable by name
static function &refAccess($var_name) {
$r =& $GLOBALS["$var_name"];
return $r;
}
}
//----------------------------------------------------------
#> 2. create new class
//----------------------------------------------------------
class test
{
private $name = 'test-1';
#> 3. Add __call 'magic method' to your class
// Call Overloadable class
// you must copy this method in your class to activate overloading
function __call($method, $args) {
return Overloadable::call($this, $method, $args);
}
#> 4. Add your methods with __ and arg type as one letter ie:(__i, __s, __is) and so on.
#> methodname__i = methodname($integer)
#> methodname__s = methodname($string)
#> methodname__is = methodname($integer, $string)
// func(void)
function func__() {
pre('func(void)', __function__);
}
// func(integer)
function func__i($int) {
pre('func(integer '.$int.')', __function__);
}
// func(string)
function func__s($string) {
pre('func(string '.$string.')', __function__);
}
// func(string, object)
function func__so($string, $object) {
pre('func(string '.$string.', '.print_r($object, 1).')', __function__);
//pre($object, 'Object: ');
}
// func(closure)
function func__c(Closure $callback) {
pre("func(".
print_r(
array( $callback, $callback($this->name) ),
1
).");", __function__.'(Closure)'
);
}
// anotherFunction(array)
function anotherFunction__a($array) {
pre('anotherFunction('.print_r($array, 1).')', __function__);
$array[0]++; // change the reference value
$array['val']++; // change the reference value
}
// anotherFunction(string)
function anotherFunction__s($key) {
pre('anotherFunction(string '.$key.')', __function__);
// Get a reference
$a2 =& Overloadable::refAccess($key); // $a2 =& $GLOBALS['val'];
$a2 *= 3; // change the reference value
}
}
//----------------------------------------------------------
// Some data to work with:
$val = 10;
class obj {
private $x=10;
}
//----------------------------------------------------------
#> 5. create your object
// Start
$t = new test;
#> 6. Call your method
// Call first method with no args:
$t->func();
// Output: func(void)
$t->func($val);
// Output: func(integer 10)
$t->func("hello");
// Output: func(string hello)
$t->func("str", new obj());
/* Output:
func(string str, obj Object
(
[x:obj:private] => 10
)
)
*/
// call method with closure function
$t->func(function($n){
return strtoupper($n);
});
/* Output:
func(Array
(
[0] => Closure Object
(
[parameter] => Array
(
[$n] =>
)
)
[1] => TEST-1
)
);
*/
## Passing by Reference:
echo '<br><br>$val='.$val;
// Output: $val=10
$t->anotherFunction(array(&$val, 'val'=>&$val));
/* Output:
anotherFunction(Array
(
[0] => 10
[val] => 10
)
)
*/
echo 'Result: $val='.$val;
// Output: $val=12
$t->anotherFunction('val');
// Output: anotherFunction(string val)
echo 'Result: $val='.$val;
// Output: $val=36
// Helper function
//----------------------------------------------------------
function pre($mixed, $title=null){
$output = "<fieldset>";
$output .= $title ? "<legend><h2>$title</h2></legend>" : "";
$output .= '<pre>'. print_r($mixed, 1). '</pre>';
$output .= "</fieldset>";
echo $output;
}
//----------------------------------------------------------
回答by Marlin Ouverson
What about this:
那这个呢：
function($arg = NULL) {
if ($arg != NULL) {
etc.
etc.
}
}
回答by mtpultz
In PHP 5.6 you can use the splat operator...as the last parameter and do away with func_get_args()and func_num_args():
在 PHP 5.6 中，您可以使用splat 运算符...作为最后一个参数并取消func_get_args()and func_num_args()：
function example(...$args)
{
count($args); // Equivalent to func_num_args()
}
example(1, 2);
example(1, 2, 3, 4, 5, 6, 7);
You can use it to unpack arguments as well:
您也可以使用它来解压参数：
$args[] = 1;
$args[] = 2;
$args[] = 3;
example(...$args);
Is equivalent to:
相当于：
example(1, 2, 3);
回答by Raman Deep Bajwa
<?php
class abs
{
public function volume($arg1=null, $arg2=null, $arg3=null)
{
if($arg1 == null && $arg2 == null && $arg3 == null)
{
echo "function has no arguments. <br>";
}
else if($arg1 != null && $arg2 != null && $arg3 != null)
{
$volume=$arg1*$arg2*$arg3;
echo "volume of a cuboid ".$volume ."<br>";
}
else if($arg1 != null && $arg2 != null)
{
$area=$arg1*$arg2;
echo "area of square = " .$area ."<br>";
}
else if($arg1 != null)
{
$volume=$arg1*$arg1*$arg1;
echo "volume of a cube = ".$volume ."<br>";
}
}
}
$obj=new abs();
echo "For no arguments. <br>";
$obj->volume();
echo "For one arguments. <br>";
$obj->volume(3);
echo "For two arguments. <br>";
$obj->volume(3,4);
echo "For three arguments. <br>";
$obj->volume(3,4,5);
?>
回答by Sahil Gulati
PHP does not support overloading for now. Hope this will be implemented in the other versions like other programming languages.
PHP 目前不支持重载。希望这会像其他编程语言一样在其他版本中实现。
Checkout this library, This will allow you to use PHP Overloading in terms of closures. https://github.com/Sahil-Gulati/Overloading
签出这个库，这将允许您在闭包方面使用 PHP 重载。 https://github.com/Sahil-Gulati/Overloading
回答by Rovshan Mamedov
Sadly there is no overload in PHP as it is done in C#. But i have a little trick. I declare arguments with default null values and check them in a function. That way my function can do different things depending on arguments. Below is simple example:
遗憾的是，PHP 中没有重载，因为它是在 C# 中完成的。但我有一个小技巧。我使用默认空值声明参数并在函数中检查它们。这样我的函数可以根据参数做不同的事情。下面是一个简单的例子：
public function query($queryString, $class = null) //second arg. is optional
{
$query = $this->dbLink->prepare($queryString);
$query->execute();
//if there is second argument method does different thing
if (!is_null($class)) {
$query->setFetchMode(PDO::FETCH_CLASS, $class);
}
return $query->fetchAll();
}
//This loads rows in to array of class
$Result = $this->query($queryString, "SomeClass");
//This loads rows as standard arrays
$Result = $this->query($queryString);
