PHP 5.5.37 is released

Geriçağırımlar / Çağırılılabilirler

Geriçağırımlar PHP 5.4.'ten itibaren callable tür ipucu ile belirtilebilirler. Bu belgelerde callback tür bilgisi aynı amaçla kullanıldı.

call_user_func() ya da usort() gibi bazı işlevler değiştirge olarak kullanıcı tarafından belirlenen geriçağırım işlevleri kabul eder. Geriçağırım işlevleri basit işlevler olabileceği gibi, duruk işlevler de dâhil olmak üzere object türünde nesne yöntemleri de olabilirler.

Aktarım

Bir PHP işlevi adı ile string türünde aktarılır. Her türlü yerleşik ve kullanıcı tanımlı işlev kullanılabilir, ancak; array(), echo, empty(), eval(), exit(), isset(), list(), print ya da unset() gibi dil sabitleri müstesna.

Örneklenmiş bir nesne yöntemi, 0 indisinde nesne, 1 indisinde yöntem adı olan bir dizi ile aktarılır.

Duruk sınıf yöntemleri, 0 indisinde nesne yerine sınıf adı kullanılarak, sınıfın nesnesi örneklendirilmeden de aktarılabilir. PHP 5.2.3.'ten itibaren, 'SınıfAdı::yöntemAdı' kullanarak aktarmak da mümkündür.

Kullanıcı tanımlı işlevler haricinde, isimsiz işlevler de geriçağırım değiştirgesi olarak aktarılabilirler.

Örnek 1 Geriçağırım işlev örnekleri

<?php 

// Örnek bir geriçağırım işlevi
function benim_gericagirim_islevim() {
    echo 
'merhaba dünya!';
}

// Örnek bir geriçağırım yöntemi
class BenimSinifim {
    static function 
benimGericagirimYontemim() {
        echo 
'Merhaba Dünya!';
    }
}

// Tür 1: Basit geriçağırım
call_user_func('benim_gericagirim_islevim'); 

// Tür 2: Duruk sınıf yöntemi çağrısı
call_user_func(array('BenimSinifim''benimGericagirimYontemim'));

// Tür 3: Nesne yöntem çağrısı
$nesne = new BenimSinifim();
call_user_func(array($nesne'benimGericagirimYontemim'));

// Tür 4: Duruk sınıf yöntemi çağrısı (PHP 5.2.3 itibariyle)
call_user_func('BenimSinifim::benimGericagirimYontemim');

// Tür 5: İlişkisel duruk sınıf yöntem çağrısı (PHP 5.3.0 itibariyle)
class {
    public static function 
kim() {
        echo 
"A\n";
    }
}

class 
extends {
    public static function 
kim() {
        echo 
"B\n";
    }
}

call_user_func(array('B''parent::kim')); // A

// Tür 6: Nesneler, __invoke uyguluyorlarsa çağırılabilir olarak kullanılabilirler (PHP 5.3 sonrası)
class {
    public function 
__invoke($ad) {
        echo 
'Merhaba '$ad"\n";
    }
}

$c = new C();
call_user_func($c'PHP!');
?>

Örnek 2 Örtme kullanan Geriçağırım örneği

<?php
// Bizim örtücümüz
$iki_misli = function($a) {
    return 
$a 2;
};

// Bu bizim sayı aralığımız
$sayilar range(15);

// Sayı aralığımızın her bir elemanını
// ikiye katlamak için burada örtücüyü
// bir geriçağırım olarak kullandık
$yeni_sayilar array_map($iki_misli$sayilar);

print 
implode(' '$yeni_sayilar);
?>

Yukarıdaki örneğin çıktısı:

2 4 6 8 10

Bilginize: PHP 4'te, bir geriçağırım yaratmak için, kopyasını değil; gerçek nesne'yi işaret eden bir gönderim kullanmak gerekiyordu. Daha fazla bilgi için bkz: Gönderimlerle İlgili Herşey.

Bilginize:

call_user_func() ve call_user_func_array() gibi işlevlerle kayıt altına alınmış geriçağırım işlevleri, bir önceki geriçağırım işlevinde oluşmuş ve yakalanmamış bir istisna varsa çağrılmaz.

add a note add a note

User Contributed Notes 10 notes

up
190
edanschwartz at gmail dot com
1 year ago
You can use 'self::methodName' as a callable, but this is dangerous. Consider this example:

<?php
class Foo {
    public static function
doAwesomeThings() {
       
FunctionCaller::callIt('self::someAwesomeMethod');
    }

    public static function
someAwesomeMethod() {
       
// fantastic code goes here.
   
}
}

class
FunctionCaller {
    public static function
callIt(callable $func) {
       
call_user_func($func);
    }
}

Foo::doAwesomeThings();
?>

This results in an error:
Warning: class 'FunctionCaller' does not have a method 'someAwesomeMethod'.

For this reason you should always use the full class name:
<?php
FunctionCaller
::callIt('Foo::someAwesomeMethod');
?>

I believe this is because there is no way for FunctionCaller to know that the string 'self' at one point referred to to `Foo`.
up
184
computrius at gmail dot com
2 years ago
When specifying a call back in array notation (ie. array($this, "myfunc") ) the method can be private if called from inside the class, but if you call it from outside you'll get a warning:

<?php

class mc {
   public function
go(array $arr) {
      
array_walk($arr, array($this, "walkIt"));
   }

   private function
walkIt($val) {
       echo
$val . "<br />";
   }

    public function
export() {
        return array(
$this, 'walkIt');
    }
}

$data = array(1,2,3,4);

$m = new mc;
$m->go($data); // valid

array_walk($data, $m->export()); // will generate warning

?>

Output:
1<br />2<br />3<br />4<br />
Warning: array_walk() expects parameter 2 to be a valid callback, cannot access private method mc::walkIt() in /in/tfh7f on line 22
up
195
steve at mrclay dot org
3 years ago
Performance note: The callable type hint, like is_callable(), will trigger an autoload of the class if the value looks like a static method callback.
up
154
Riikka K
1 year ago
A note on differences when calling callbacks as "variable functions" without the use of call_user_func() (e.g. "<?php $callback = 'printf'; $callback('Hello World!') ?>"):

- Using the name of a function as string has worked since at least 4.3.0
- Calling anonymous functions and invokable objects has worked since 5.3.0
- Using the array structure [$object, 'method'] has worked since 5.4.0

Note, however, that the following are not supported when calling callbacks as variable functions, even though they are supported by call_user_func():

- Calling static class methods via strings such as 'foo::doStuff'
- Calling parent method using the [$object, 'parent::method'] array structure

All of these cases are correctly recognized as callbacks by the 'callable' type hint, however. Thus, the following code will produce an error "Fatal error: Call to undefined function foo::doStuff() in /tmp/code.php on line 4":

<?php
class foo {
    static function
callIt(callable $callback) {
       
$callback();
    }
   
    static function
doStuff() {
        echo
"Hello World!";
    }
}

foo::callIt('foo::doStuff');
?>

The code would work fine, if we replaced the '$callback()' with 'call_user_func($callback)' or if we used the array ['foo', 'doStuff'] as the callback instead.
up
198
andrewbessa at gmail dot com
4 years ago
You can also use the $this variable to specify a callback:

<?php
class MyClass {

    public
$property = 'Hello World!';

    public function
MyMethod()
    {
       
call_user_func(array($this, 'myCallbackMethod'));
    }

    public function
MyCallbackMethod()
    {
        echo
$this->property;
    }

}
?>
up
172
metamarkers at gmail dot com
3 years ago
you can pass an object as a callable if its class defines the __invoke() magic method..
up
158
Yzmir Ramirez
2 years ago
> As of PHP 5.2.3, it is also possible to pass 'ClassName::methodName'

You can also use 'self::methodName'.  This works in PHP 5.2.12 for me.
up
59
mariano dot REMOVE dot perez dot rodriguez at gmail dot com
9 months ago
I needed a function that would determine the type of callable being passed, and, eventually,
normalized it to some extent. Here's what I came up with:

<?php

/**
* The callable types and normalizations are given in the table below:
*
*  Callable                        | Normalization                   | Type
* ---------------------------------+---------------------------------+--------------
*  function (...) use (...) {...}  | function (...) use (...) {...}  | 'closure'
*  $object                         | $object                         | 'invocable'
*  "function"                      | "function"                      | 'function'
*  "class::method"                 | ["class", "method"]             | 'static'
*  ["class", "parent::method"]     | ["parent of class", "method"]   | 'static'
*  ["class", "self::method"]       | ["class", "method"]             | 'static'
*  ["class", "method"]             | ["class", "method"]             | 'static'
*  [$object, "parent::method"]     | [$object, "parent::method"]     | 'object'
*  [$object, "self::method"]       | [$object, "method"]             | 'object'
*  [$object, "method"]             | [$object, "method"]             | 'object'
* ---------------------------------+---------------------------------+--------------
*  other callable                  | idem                            | 'unknown'
* ---------------------------------+---------------------------------+--------------
*  not a callable                  | null                            | false
*
* If the "strict" parameter is set to true, additional checks are
* performed, in particular:
*  - when a callable string of the form "class::method" or a callable array
*    of the form ["class", "method"] is given, the method must be a static one,
*  - when a callable array of the form [$object, "method"] is given, the
*    method must be a non-static one.
*
*/
function callableType($callable, $strict = true, callable& $norm = null) {
  if (!
is_callable($callable)) {
    switch (
true) {
      case
is_object($callable):
       
$norm = $callable;
        return
'Closure' === get_class($callable) ? 'closure' : 'invocable';
      case
is_string($callable):
       
$m    = null;
        if (
preg_match('~^(?<class>[a-z_][a-z0-9_]*)::(?<method>[a-z_][a-z0-9_]*)$~i', $callable, $m)) {
          list(
$left, $right) = [$m['class'], $m['method']];
          if (!
$strict || (new \ReflectionMethod($left, $right))->isStatic()) {
           
$norm = [$left, $right];
            return
'static';
          }
        } else {
         
$norm = $callable;
          return
'function';
        }
        break;
      case
is_array($callable):
       
$m = null;
        if (
preg_match('~^(:?(?<reference>self|parent)::)?(?<method>[a-z_][a-z0-9_]*)$~i', $callable[1], $m)) {
          if (
is_string($callable[0])) {
            if (
'parent' === strtolower($m['reference'])) {
              list(
$left, $right) = [get_parent_class($callable[0]), $m['method']];
            } else {
              list(
$left, $right) = [$callable[0], $m['method']];
            }
            if (!
$strict || (new \ReflectionMethod($left, $right))->isStatic()) {
             
$norm = [$left, $right];
              return
'static';
            }
          } else {
            if (
'self' === strtolower($m['reference'])) {
              list(
$left, $right) = [$callable[0], $m['method']];
            } else {
              list(
$left, $right) = $callable;
            }
            if (!
$strict || !(new \ReflectionMethod($left, $right))->isStatic()) {
             
$norm = [$left, $right];
              return
'object';
            }
          }
        }
        break;
    }
   
$norm = $callable;
    return
'unknown';
  }
 
$norm = null;
  return
false;
}

?>

Hope someone else finds it useful.
up
-1
bradyn at NOSPAM dot bradynpoulsen dot com
2 months ago
When trying to make a callable from a function name located in a namespace, you MUST give the fully qualified function name (regardless of the current namespace or use statements).

<?php

namespace MyNamespace;

function
doSomethingFancy($arg1)
{
   
// do something...
}

$values = [1, 2, 3];

array_map('doSomethingFancy', $values);
// array_map() expects parameter 1 to be a valid callback, function 'doSomethingFancy' not found or invalid function name

array_map('MyNamespace\doSomethingFancy', $values);
// => [..., ..., ...]
up
-1
pawel dot tadeusz dot niedzielski at gmail dot com
2 months ago
@edanschwartz at gmail dot com

You can use ::class property to always indicate the class you're in when using static methods:

<?php
class Foo {
    public static function
doAwesomeThings() {
       
FunctionCaller::callIt(self::class . '::someAwesomeMethod');
    }

    public static function
someAwesomeMethod() {
       
// fantastic code goes here.
   
}
}

class
FunctionCaller {
    public static function
callIt(callable $func) {
       
call_user_func($func);
    }
}

Foo::doAwesomeThings();
?>
To Top