PHP: is_callable

Description

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

Verify that the contents of a variable can be called as a function. This can check that a simple variable contains the name of a valid function, or that an array contains a properly encoded object and function name.

The var parameter can be either the name of a function stored in a string variable, or an object and the name of a method within the object, like this:
array($SomeObject, 'MethodName')

If the syntax_only argument is TRUE the function only verifies that var might be a function or method. It will only reject simple variables that are not strings, or an array that does not have a valid structure to be used as a callback. The valid ones are supposed to have only 2 entries, the first of which is an object or a string, and the second a string.

The callable_name argument receives the "callable name". In the example below it's "someClass:someMethod". Note, however, that despite the implication that someClass::SomeMethod() is a callable static method, this is not the case.


<?php

//  How to check a variable to see if it can be called

//  as a function.



//

//  Simple variable containing a function

//



function someFunction() 

{

}



$functionVariable = 'someFunction';



var_dump(is_callable($functionVariable, false, $callable_name));  // bool(true)



echo $callable_name, "\n";  // someFunction



//

//  Array containing a method

//



class someClass {



  function someMethod() 

  {

  }



}



$anObject = new someClass();



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



var_dump(is_callable($methodVariable, true, $callable_name));  //  bool(true)



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



?>

User Contributed Notes
is_callable

corey at eyewantmedia dot com
18-Mar-2005 05: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
10-Feb-2005 09: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-Jun-2004 11: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
03-Apr-2004 04: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..

ckrack at i-z dot de
09-Mar-2004 12:19


i was wondering whether is_callable or function exists is faster when checking class methods.



is_callable(array('foo', 'bar'));

function_exists("foo::bar");



my results when doing each operation 10000 times with a simple test class were the following:



is_callable           0.28671383857727 seconds

function_exists:  0.14569997787476 seconds



(following tests have proved this to be true).



thus you can see, function_exists is twice as fast as is_callable.

kmckay at kmckay dot ca
05-Sep-2002 11:18


I'm using the function to determine if a posted variable is "callable". This is usefull when checking if posted variable names exist within a class.



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);

}

}