PHP 8.1.0 Alpha 1 available for testing

is_callable

(PHP 4 >= 4.0.6, PHP 5, PHP 7, PHP 8)

is_callablePrüft, ob der Inhalt einer Variable als Funktion aufgerufen werden kann

Beschreibung

is_callable ( mixed $value , bool $syntax_only = false , string &$callable_name = null ) : bool

Prüft, ob ein Wert ein callable ist.

Parameter-Liste

value

Der zu prüfende Wert.

syntax_only

Wenn dieser Parameter auf true gesetzt wird, prüft die Funktion nur ob value eine Funktion oder Methode enthalten könnte. Nur einfache Variablen, die keinen String enthalten werden zurückgewiesen, oder Arrays, die nicht die richtige Struktur haben, um als Callback verwendet werden zu können. Gültige Arrays müssen zwei Elemente haben, 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 Beispiel weiter unten ist dies "someClass::someMethod". Es ist zu beachten, dass dies keine statische Methode ist, auch wenn die Syntax das nahelegt.

Rückgabewerte

Liefert true, wenn value aufrufbar ist, 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

?>

Beispiel #2 is_callable() und Konstructoren

Von PHP 5.3.0 an meldet is_callable() Konstruktoren als nicht aufrufbar. Dies betrifft Konstruktoren im PHP 5-Stil (__construct) wie auch Konstruktoren im PHP 4-Stil (d.h. Methoden mit demselben Namen wie die Klasse). Zuvor wurden beide Fälle als aufrufbar angesehen.

<?php

class Foo
{
    public function 
__construct() {}
    public function 
foo() {}
}

var_dump(
    
is_callable(array('Foo''__construct')),
    
is_callable(array('Foo''foo'))
);

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

bool(false)
bool(false)

Siehe auch

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

add a note add a note

User Contributed Notes 6 notes

up
31
izharaazmi at gmail dot com
5 years ago
If the target class has __call() magic function implemented, then is_callable will ALWAYS return TRUE for whatever method you call it.
is_callable does not evaluate your internal logic inside __call() implementation (and this is for good).
Therefore every method name is callable for such classes.

Hence it is WRONG to say (as someone said):
...is_callable will correctly determine the existence of methods made with __call...

Example:
<?php
class TestCallable
{
    public function
testing()
    {
          return
"I am called.";
    }

    public function
__call($name, $args)
    {
        if(
$name == 'testingOther')
        {
                return
call_user_func_array(array($this, 'testing'), $args);
        }
    }
}

$t = new TestCallable();
echo
$t->testing();      // Output: I am called.
echo $t->testingOther(); // Output: I am called.
echo $t->working();      // Output: (null)

echo is_callable(array($t, 'testing'));       // Output: TRUE
echo is_callable(array($t, 'testingOther'));  // Output: TRUE
echo is_callable(array($t, 'working'));       // Output: TRUE, expected: FALSE
?>
up
2
rahadotaboulfethatgmail.com
13 years ago
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
up
1
juand at softwarecubes dot com
12 years ago
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;
    }
?>
up
0
jlh
2 years ago
The story about __call() is a bit more complicated unfortunately. It will always return true ONLY if you pass an instance of a class, not if you pass the class name itself:

<?php
class MyClass {
    public function
method() { }
    public function
__call($name, $arguments) { }
}

is_callable([MyClass::class, 'method']); // true
is_callable([new MyClass(), 'method']); // true
is_callable([MyClass::class, 'other']); // false!!!
is_callable([new MyClass(), 'other'])); // true
up
0
fgm at osinet dot fr
9 years ago
Note that, for the purpose of this function, an abstract method, although necessarily non-callable since it does not have a body, is still considered to be callable:

<?php
abstract class Foo {
  abstract function
bar();
}

echo
is_callable(array('Foo', 'bar'));
// display: 1
?>
up
0
Quis strrev TA omicidio strrev TOD com
13 years ago
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
To Top