PHP Doku:: Prüft ob der Inhalt einer Variable als Funktion aufgerufen werden kann - function.is-callable.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzVariablen- und typbezogene ErweiterungenVariablenbehandlungFunktionen zur Behandlung von Variablenis_callable

Ein Service von Reinhard Neidl - Webprogrammierung.

Funktionen zur Behandlung von Variablen

<<is_bool

is_double>>

is_callable

(PHP 4 >= 4.0.6, PHP 5)

is_callable Prüft ob der Inhalt einer Variable als Funktion aufgerufen werden kann

Beschreibung

bool is_callable ( mixed $var [, bool $syntax_only = false [, string &$callable_name ]] )

Prüft ob der Inhalt einer Variable als Funktion aufgerufen werden kann. Es wird geprüft ob eine einfache Variable den Namen einer gültigen Funktion enthält, oder ob in einem Array ein gültig codierter Objekt- und Funktionsname enthalten ist.

Parameter-Liste

var

Kann entweder der Name einer Funktion als String oder ein Objekt und der Name einer seiner Methoden als Array in der Form

array($SomeObject, 'MethodName')
sein.

syntax_only

Wenn dieser Parameter auf TRUE gesetzt wird so prüft die Funktion nur ob var möglicherweise eine Funktion oder Methode enthält. Einfache Variablen werden nur zurückgewiesen wenn sie keinen String enthalten. Arrays werden auf die richtige Struktur geprüft, d.g. das das Array zwei Elemente hat von denen der erste ein Objekt oder String und der zweite ein String ist.

callable_name

Hier wird der "aufrufbare Name" abgelegt. Für das obige Beispiel ist dies "someClass::someMethod". Beachten Sie dass dies keine statische Methode ist auch wenn die Syntax das nahelegt.

Rückgabewerte

Liefet TRUE wenn var aufrufbar is, sonst FALSE.

Beispiele

Beispiel #1 is_callable() Beispiel

<?php
// Wie man prüft ob eine Variable als Funktion aufgerufen werden kann

//
//  Einfache Variable die eine Funktion enthält
//

function someFunction() 
{
}

$functionVariable 'someFunction';

var_dump(is_callable($functionVariablefalse$callable_name));  // bool(true)

echo $callable_name"\n";  // someFunction

//
//  Array das eine Methode enthält
//

class someClass {

  function 
someMethod() 
  {
  }

}

$anObject = new someClass();

$methodVariable = array($anObject'someMethod');

var_dump(is_callable($methodVariabletrue$callable_name));  //  bool(true)

echo $callable_name"\n";  //  someClass::someMethod

?>

Siehe auch

  • function_exists() - Falls die angegebene Funktion definiert ist, wird TRUE zurück gegeben
  • method_exists() - Prüft on eine Methode innerhalb eines Objekts existiert


20 BenutzerBeiträge:
- Beiträge aktualisieren...
Jaik Dean
1.12.2010 12:52
It's worth noting that passing an object and method name will not work for lambdas/closures stored within an object property. Here's a test case in 5.3.3.

<?php

class TestClass
{
    public
$testMethod;

    public function
__construct()
    {
       
$this->testMethod = function(){};
    }
}

$test = new TestClass();

is_callable(array($test, 'testMethod')); // false
is_callable($this->testMethod); // true
?>
colin
3.10.2010 20:30
I haven't seen anyone note this before, but is_callable will correctly determine the existence of methods made with __call. The method_exists function will not.

Example:
<?php

class Test {

    public function
testing($not = false) {
       
$not = $not ? 'true' : 'false';
        echo
"testing - not: $not<br/>";
    }
   
    public function
__call($name, $args) {
        if(
preg_match('/^not([A-Z]\w+)$/', $name, $matches)) {
           
$fn_name = strtolower($matches[1]);
            if(
method_exists($this, $fn_name)) {
               
$args[] = true; // add NOT boolean to args
               
return call_user_func_array(array($this, $matches[1]), $args);
            }
        }
        die(
"No method with name: $name<br/>");
    }

}

$t = new Test();
$t->testing();
$t->notTesting();

echo
"exists: ".method_exists($t, 'notTesting').'<br/>';
echo
"callable: ".is_callable(array($t, 'notTesting'));

?>

Output:

testing - not: false
testing - not: true
exists:
callable: 1
minty at nospam dot com
10.07.2010 23:34
Although not mentioned anywhere on the manual page, is_callable works as expected with closures.

<?php

$func
= function() { return; };
var_dump(is_callable($func)); // boolean (true)

?>
Constantin Kpplinger
10.06.2010 21:16
It seems the only issue left with is_callable() is the disable_functions ini-setting. Apart from that, is_callable() will reliably evaluate whether the passed function or method can be called from within the same context is_callable() was called from, taking visibility and inheritance into account. This includes functions, regular and static methods, magic functions and methods and implemented interfaces (which are regular methods within the implementing class anyway).

<?php
function regular_function() {}

abstract class
ParentTest
{
    public function
public_parent_method() {}
    protected function
protected_parent_method() {}
    public static function
static_method() {}
    protected static function
protected_static_method() {}
}

class
CallableTest extends ParentTest implements Countable
{
    public function
__invoke() { } // Introduced in 5.3, see http://php.net/manual/language.oop5.magic.php
   
protected function protected_method() { }
    public function
is_callable($args)
    {
        return
is_callable($args);
    }
   
// Countable
   
public function count()
    {
        return
1;
    }
}

$o = new CallableTest();

// Regular function:
var_dump(is_callable('regular_function')); // true

// Magic __invoke method:
var_dump(is_callable($o)); // true if PHP >= 5.3, false otherwise

// Countable implementation (regular method really):
var_dump(is_callable(array($o, 'count'))); // true

// Protected method from outside the object's scope:
var_dump(is_callable(array($o, 'protected_method'))); // false

// Protected method from inside the object's scope via public proxy method:
var_dump($o->is_callable(array($o, 'protected_method'))); // true

// Parent's public method
var_dump(is_callable(array($o, 'public_parent_method'))); // true

// Parent's protected method
var_dump(is_callable(array($o, 'protected_parent_method'))); // false

// Parent's protected method via proxy
var_dump($o->is_callable(array($o, 'protected_parent_method'))); // true

// Parent's static public method
var_dump(is_callable('CallableTest::static_method')); // true

// Parent's static protected method
var_dump(is_callable('CallableTest::protected_static_method')); // false

// Parent's static protected method via proxy
var_dump($o->is_callable('CallableTest::protected_static_method')); // true
?>

Tested PHP versions were 5.2.9 on openSUSE 10.3 (x64) and 5.3.1 on Windows Server 2003 (x86).
juand at softwarecubes dot com
21.02.2009 20:39
Revised function with static support:

<?php
   
/**
    * The is_callable php function only considers methods declared in the class itself, and ignores the parent's.
    * This version considers all of the hierarchy.
    *
    * @param (string|Object) $class_name
    * @param string $method_name
    * @param bool $static the method being tested is static.
    */
   
public static function isCallable( $class_name, $method_name, $static = false ){
       
        if( !
is_string( $class_name ) ){
           
$class_name = get_class( $class_name );
        }
       
       
// Define Callable
       
if( $static ){
           
$callable = "{$class_name}::{$method_name}";
        }else{
           
$callable = array( $class_name, $method_name );
        }
       
       
       
// Check class itself
           
if( @is_callable( $callable ) === true ){
                if(
$method_name == 'setEmailAddressTypeHash' ) {
                   
ErrorHandler::preDump($callable);
                }
                return
true;
            }
       
       
// Check all parents
           
while( $parent_class = get_parent_class( $class_name ) ){
                if( @
is_callable( $callable ) === true ){
                    return
true;
                }
               
$class_name = $parent_class;
            }
           
        return
false;
    }
?>
Rafael M. Salvioni
20.05.2008 18:10
The PHP's function is_callable not verify the visibility of the tested method.

The following function uses the Reflection classes of the PHP5 to check it.

<?php

/**
 * Function is_callback().
 *
 * @param mixed $var Var
 * @return bool
 */
function is_callback($var)
{
    if (
is_array($var) && count($var) == 2) {
       
$var = array_values($var);
        if ((!
is_string($var[0]) && !is_object($var[0])) || (is_string($var[0]) && !class_exists($var[0]))) {
            return
false;
        }
       
$isObj = is_object($var[0]);
       
$class = new ReflectionClass($isObj ? get_class($var[0]) : $var[0]);
        if (
$class->isAbstract()) {
            return
false;
        }
        try {
           
$method = $class->getMethod($var[1]);
            if (!
$method->isPublic() || $method->isAbstract()) {
                return
false;
            }
            if (!
$isObj && !$method->isStatic()) {
                return
false;
            }
        } catch (
ReflectionException $e) {
            return
false;
        }
        return
true;
    } elseif (
is_string($var) && function_exists($var)) {
        return
true;
    }
    return
false;
}

?>
rahadotaboulfethatgmail.com
2.03.2008 1:44
is_callable generates an [E_STRICT] error if the  tested method cannot be called staticly. (and returns the good value)

I used @is_called
i'm using php 5.2.1
crestfresh at gmail dot com
17.02.2008 18:23
Furthuring mw's note [is_callable correctly takes into account scope so that is_callable(array($obj, 'privateMethod'))  correctly returns false when called from outside $obj's scope]:

It works in 5.1.6 too.
Quis strrev TA omicidio strrev TOD com
14.11.2007 0:50
is_callable() does _not_ check wheter this function is disabled by php.ini's disable_functions

use:

<?PHP
function is_disabled($function) {
 
$disabled_functions=explode(',',ini_get('disable_functions'));
  return
in_array($function, $disabled_functions);
}
?>

I`m running PHP 5.2.4
mw at NO-SPAM hire mason wolf dot com
19.10.2007 16:35
As empyone noted, early versions of php 5 incorrectly returned true if is_callable checked on a protected or private method. Later versions of php 5 will now only return true if the method is public and can be called externally. I do not know precisely when this behavior was changed, so you may have to test on your own. But sometime between 5.0.4, which empyone said he was using, and 5.2.4 where I tested it myself, the behavior was modified.
cipri at php dot net
15.06.2007 16:24
is_callable also takes the php.ini "disable_functions" setting into consideration; it will return false for functions that have been disabled by your administrator.
hcblue
24.08.2006 22:51
True that method_exists() is faster than is_callable(). However, is_callable() will be able to correctly recognize method calls handled by __call() in PHP 5, while method_exists() will not.
jphp at dsf dot org dot uk
12.02.2006 12:38
bob at theshirdshift:

"function_exists" doesn't do this, no, but "method_exists" works fine, and is still faster than is_callable:

<?php
function doTimes($start, $end)
  {
  
$start_time = explode (" ", $start);
  
$start_time = $start_time[1] + $start_time[0];
  
$end_time = explode (" ", $end);
  
$end_time = $end_time[1] + $end_time[0];
  
$time = $end_time - $start_time;
   return
$time;
  }

class
test
 
{
     function
test()
     {
         return
true;
     }
  }
 
$test = new test;

$callableIsTrue = false;
$startIsCallable = microtime();
for(
$i = 0; $i < 10000; $i++)
  {
     if(
is_callable(array('test', 'test'))) { $callableIsTrue = true; }
  }
$endIsCallable = microtime();

$existsIsTrue = false;
$startExists = microtime();
for(
$i = 0; $i < 10000; $i++)
  {
     if(
method_exists('test', 'test')) { $existsIsTrue = true; }
  }
$endExists = microtime();

$timeIsCallable = doTimes($startIsCallable, $endIsCallable);
$timeExists    = doTimes($startExists, $endExists);

echo
"<b>is_callable = ".($callableIsTrue ? "TRUE" : "FALSE")."</b>, \n";
echo
"<b>method_exists = ".($existsIsTrue ? "TRUE" : "FALSE")."</b><br>\n";

echo
"<br>Did 10000 is_callables in ".$timeIsCallable." seconds";
echo
"<br>Did 10000 method_exists in ".$timeExists." seconds";
?>

is_callable = TRUE, method_exists = TRUE

Did 10000 is_callables in 0.410346984863 seconds
Did 10000 method_exists in 0.175447940826 seconds
yetanotheruser at hotmail etc
15.12.2005 15:47
I have come across a strange oddity in versions around the 4.3.11 mark - I may have missunderstood the purpose of this function but hope this'll be helpful for some.

The point the code below is supposed to illustrate is that in some cases with

    <? $myFunc = Array( $myObj, 'myMethod' ); ?>

    <? is_callable( $myFunc, true, $callMe ); ?>

will return true, and give you $callMe set to myObj::myMethod but calling

    <? $callMe(); ?>

doesn't work... however calling

    <? $myFunc[0]->$myFunc[1](); ?>

seems to work fine..

... the reason all the code is down there is I think this oddity is due to how/the order in which I've instantiated my classes or something...

anyhow... HTH someone! :-)

Code follows:

FILE 1 :
<?
   
include('myTools');
   
   
$foo = new myClass();
   
    print
$foo->getMySource();
   
    class
myClass{
       
        var
$flibble = 'wibble';
       
        function
myClass(
           
// Initialise loads of stuff.. including..
           
$this->tools = new myTools();
        )
       
        function
getMySource(){
           
// This just returns the source.. ok, like some HTML to go into an email for example.
            // Some arguments;
           
$args   = $this->flibble;
           
// Call our Tool that returns the source..
           
$source = $this->tools->returnSource( Array ( $this, 'someHTML' ), $args );
           
// and return it..
           
return ( $source );
        }
       
        function
someHTML($args){
           
// Leave PHP
           
?>
            Here is some HTML.. that we want to build outside a PHP block,
            possibly just cos it's tidier in <B>your favourite text editor</B>..
            .. or you want this function to be elsewhere.. for your designers
            to play with etc.. ... incidentally I'd like to say "<?=$args?>" etc.
            <?
           
// .. and we're back.
       
}
    }
   
?>

FILE 2:

<?
   
/* OK - this is some other big library and a whole load more
       faff but this is the particular function in question... it
       just calls the function it's been asked to and uses an output
       buffer to grab the output and return it as a string rather than
       letting it go to terminal/browser.... useful for grabbing PHP pages
       for spidering, emailing etc. etc. etc..
    */
   
   
class myTools(){
       
        function
returnSource($func, $args){
           
            if (
is_callable ( $func, true, $callMe ){
               
// Start a buffer
               
ob_start();
               
// Calling the function like this DOESN'T seem to work:
                // ~~~~~~~~
                // "Command not found : myClass::someHTML"
                // $callMe($args);
                // ~~~~~~~~
                // But - what I've discovered is that this behaves fine..
               
if ( is_array($func) ){
                   
$func[0]->$func[1]($args);
                } else {
                   
$func($args);
                }
               
// Then we just carry on with our code..
               
$rtn =     ob_get_contents();
               
ob_clean();
                return (
$rtn );
            } else {
               
error_log("Doh!");
            }
        }
    }
   
?>
empyone at tiscalinet dot it
8.11.2005 21:41
To corey at eyewantmedia dot com:

your misunderstanding lies in passing in the naked $object parameter. It is correct for is_callable to return FALSE since you cannot 'call an object', you can only call one of its methods, but you don't specify which one. Hence:

is_callable(array($object, 'some_function'), [true or false], $callable_name)

will yield the correct result.

Notice, though, that a quick test I made (PHP 5.0.4) showed that is_callable incorrectly returns TRUE also if you specify the name of a protected/private method from outside of the context of the defining class, so, as wasti dot redl at gmx dot net pointed out, reflection is the way to go if you want to take visibility into account (which you should for true OOP, IMHO).
wasti dot redl at gmx dot net
9.10.2005 13:14
The way to discover whether a method exists in face of a __call is reflection.

It should be mentioned that although array('Test', 'func') is callable according to this function (where func is a public static method of Test), actually calling this construct as $fn() fails.
corey at eyewantmedia dot com
19.03.2005 0:39
I've been spending a month on and off trying to figure out why

is_callable($object, [true or false], $varContainingFunctionName)

returned false when it should not have (ie: $object->FunctionName() was callable), I realized I must have misunderstood its purpose. If you find yourself in the same situation, try

function_exists(string functionname)

or

method_exists ( object object, string method_name )

before you rip your hair out :)
mcroghan at digitalkeg dot com
11.02.2005 4:36
Be careful when using this function and __call (PHP5).  This function will always report true when using __call.

Need a specific function for the purpose of checking if a class method exists explicitly even when using __call.

Haven't ruled out the possibility of the existence of such a function yet.  So if someone knows of one, please point it out.
bob at thethirdshift dot net
23.06.2004 18:54
I, too, was wondering whether is_callable or function exists is faster when checking class methods.  So, I setup the following test:

<?php
function doTimes($start, $end)
  {
   
$start_time = explode (" ", $start);
   
$start_time = $start_time[1] + $start_time[0];
   
$end_time = explode (" ", $end);
   
$end_time = $end_time[1] + $end_time[0];
   
$time = $end_time - $start_time;
    return
$time;
  }

class
test
 
{
      function
test()
      {
          return
true;
      }
  }
 
$callableIsTrue = false;
$startIsCallable = microtime();
for(
$i = 0; $i < 10000; $i++)
  {
      if(
is_callable(array('test', 'test'))) { $callableIsTrue = true; }
  }
$endIsCallable = microtime();

$existsIsTrue = false;
$startExists = microtime();
for(
$i = 0; $i < 10000; $i++)
  {
      if(
function_exists('test::test')) { $existsIsTrue = true; }
  }
$endExists = microtime();

$timeIsCallable = doTimes($startIsCallable, $endIsCallable);
$timeExists     = doTimes($startExists, $endExists);

echo
"<b>is_callable = ".($callableIsTrue ? "TRUE" : "FALSE")."</b>, \n";
echo
"<b>function_exists = ".($existsIsTrue ? "TRUE" : "FALSE")."</b><br>\n";

echo
"<br>Did 10000 is_callables in ".$timeIsCallable." seconds";
echo
"<br>Did 10000 function_exists in ".$timeExists." seconds";
?>

This gives the output :

is_callable = TRUE, function_exists = FALSE

Did 10000 is_callables in 0.0640790462494 seconds
Did 10000 function_exists in 0.0304429531097 seconds

So the fact that function_exists is twice as fast is slightly over shadowed by the fact that it doesn't work on class methods, at least not as far as I can tell.
webmaster __AT__ digitalanime __DOT__ nl
4.04.2004 0:30
<?php
while(list($key,$value)=each($HTTP_POST_VARS))
{
 
$tmpVar = 'return isset($' . 'this->' . $key . ');';
  if(
is_callable($key) && eval($tmpVar) && trim($value) != "")
  {
 
$tmpSet = '$this->set' . ucfirst($key) . "('" . $value . "');";
   eval(
$tmpSet);
}
}
?>
Why do you use this?

Isn't this a better solvation (or.. Whatever :P)

<?php
foreach($_POST as $key => $value)
{
 if(
is_callable($key) && isset($this->{$key}) && trim($value != '')
 {
 
$this->{'set' . ucfirst($key)}($value);
 }
}
?>

Tada.. Variable objects, that's what they are..



PHP Powered 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",...)