(PHP 4, PHP 5)
method_exists — 检查类的方法是否存在
object
对象示例或者类名。
method_name
方法名。
如果 method_name
所指的方法在 object
所指的对象类中已定义,则返回 TRUE
,否则返回 FALSE
。
Note:
如果此类不是已知类,使用此函数会使用任何已注册的 autoloader。
Example #1 method_exists() 例子
<?php
$directory = new Directory('.');
var_dump(method_exists($directory,'read'));
?>
以上例程会输出:
bool(true)
Example #2 Static method_exists() 例子
<?php
var_dump(method_exists('Directory','read'));
?>
以上例程会输出:
bool(true)
konzertheld at thedomainistheusersname dot de (2013-02-15 05:32:55)
Note that prepending the namespace (if any) is required even if the calling class is in the same namespace:
<?php
namespace test;
class foo {
public function lookup() {
// will return false
return method_exists('bar', 'nonsense_method');
}
}
class bar {
public function nonsense_method() {
// will return true
return method_exists('test\foo', 'lookup');
}
}
?>
Niels (2011-05-11 12:45:50)
Just to mention it: both method_exists() and is_callable() return true for inherited methods:
<?php
class ParentClass {
function doParent() { }
}
class ChildClass extends ParentClass { }
$p = new ParentClass();
$c = new ChildClass();
// all return true
var_dump(method_exists($p, 'doParent'));
var_dump(method_exists($c, 'doParent'));
var_dump(is_callable(array($p, 'doParent')));
var_dump(is_callable(array($c, 'doParent')));
?>
mail at bartrail dot de (2011-04-25 10:06:16)
Using method_exists inside an object's __call() method can be very usefull if you want to avoid to get a fatal error because of a limit in function nesting or if you are calling methods that dont exist but need to continue in your application:
<?php
class Something
{
/**
* Call a method dynamically
*
* @param string $method
* @param array $args
* @return mixed
*/
public function __call($method, $args)
{
if(method_exists($this, $method)) {
return call_user_func_array(array($this, $method), $args);
}else{
throw new Exception(sprintf('The required method "%s" does not exist for %s', $method, get_class($this)));
}
}
}
?>
phoenix at todofixthis dot com (2010-12-21 09:13:51)
As noted [elsewhere] method_exists() does not care about the existence of __call(), whereas is_callable() does:
<?php
class Test {
public function explicit( ) {
// ...
}
public function __call( $meth, $args ) {
// ...
}
}
$Tester = new Test();
var_export(method_exists($Tester, 'anything')); // false
var_export(is_callable(array($Tester, 'anything'))); // true
?>
buggedcom (2010-08-18 23:02:04)
Be warned that the class must exist before calling method exists from an eval statement otherwise you will get a Signal Bus error.
uramihsayibok, gmail, com (2010-08-06 22:09:16)
It wasn't spelled out but could be inferred: method_exists() also works on interfaces.
<?php
var_dump(method_exists("Iterator", "current"));
// bool(true)
?>
Anonymous (2010-05-08 05:20:43)
If you want to check in a class itself if a method is known you may do so with magic variable __CLASS__
<?php
class A{
__construct($method){
return method_exists(__CLASS__,$method);
}
private function foo(){
}
}
$test = new A('foo');
//should return true
?>
You might also use the method describe below with <?php in_array() ?> trick but I consider this one here easier and more readable and well, the way it is intended toi be done ;)
admin ( at ) djokodonev dot com (2009-10-16 16:30:51)
Hi,
Here is a useful function that you can use to check classes methods access e.g whether it is public, private or static or both..
here it goes:
<?php
// Example class
class myClass {
private $private1;
static $static1;
public $public1;
public function publ() {
}
private function priv() {
}
private static function privstatic() {
}
public static function publstatic() {
}
static function mytest() {
}
}
// The function uses the reflection class that is built into PHP!!!
// The purpose is to determine the type of a certain method that exi
function is_class_method($type="public", $method, $class) {
// $type = mb_strtolower($type);
$refl = new ReflectionMethod($class, $method);
switch($type) {
case "static":
return $refl->isStatic();
break;
case "public":
return $refl->isPublic();
break;
case "private":
return $refl->isPrivate();
break;
}
}
var_dump(is_class_method("static", "privstatic", "myClass")); // true - the method is private and also static..
var_dump(is_class_method("private", "privstatic", "myClass")); // true - the method is private and also static..
var_dump(is_class_method("private", "publstatic", "myClass")); // False the methos is public and also static not private
// you get the idea.. I hope this helps someone..
?>
florin from syneto net (2009-10-07 07:34:52)
This function is case-insensitive (as is PHP) and here is the proof:
<?php
class A {
public function FUNC() { echo '*****'; }
}
$a = new A();
$a->func(); // *****
var_dump(method_exists($a, 'func')); // bool(true)
?>
jp at function dot fi (2006-04-30 02:29:48)
As mentioned before, is_callable and method_exists report all methods callable even if they are private/protected and thus actually not callable. So instead of those functions you may use following work-around which reports methods as supposed to.
<?php
class Foo1 {
public function bar() {
echo "I'm private Foo1::bar()";
}
}
class Foo2 {
private function bar() {
echo "I'm public Foo2::bar()";
}
}
$f1=new Foo1;
$f2=new Foo2;
if(is_callable(array($f1,"bar"))) {
echo "Foo1::bar() is callable";
} else {
echo "Foo1::bar() isn't callable";
}
if(is_callable(array($f2,"bar"))) {
echo "Foo2::bar() is callable";
} else {
echo "Foo2::bar() isn't callable";
}
if(in_array("bar",get_class_methods($f1))) {
echo "Foo1::bar() is callable";
} else {
echo "Foo1::bar() isn't callable";
}
if(in_array("bar",get_class_methods($f2))) {
echo "Foo2::bar() is callable";
} else {
echo "Foo2::bar() isn't callable";
}
?>
output
Foo1::bar() is callable (correct)
Foo2::bar() is callable (incorrect)
Foo1::bar() is callable (correct)
Foo2::bar() isn't callable (correct)
?>
seufert at gmail dot com (2006-04-26 18:27:47)
Just a note that the behaviour of this function changed between version 5.0.x and 5.1.x when using static member functions
Using this code:
<?php
class a {
static function test() {return "A";}
}
if(method_exists('a','test'))
print call_user_func(array('a','test'));
else
print "Nothing";
?>
PHP 5.1.x returns "A"
PHP 5.0.x returns "Nothing"
Im not sure of a workaround for PHP 5.0.x yet.
spam at majiclab dot com (2006-01-31 08:33:59)
Both method_exists() and is_callable() return private and protected functions, which, as mentioned below, causes problems for PHP5/OO programming. You can use get_class_methods() with either an $instance of a class or the 'ClassName' to get only public functions.
daniel at softel dot jp (2006-01-09 19:34:18)
Note that in PHP5, method_exists() will sucessfully find *private* methods. This has some OO/data-hiding ramifications.
jpgiot at nospam ifrance.com (2004-05-06 07:42:57)
a little difference :
to find a method of an object (instance of a class)
<?php
if (method_exists($myinstance,'themethod'))
echo 'ok';
?>
to find a method of a class (using the class name, not the instance of the class!)
<?php
if (is_callable(array('theclassname','themethod')))
echo 'ok';
?>
Thomas@ThBeckmann (2003-01-31 13:47:43)
Though, as Bejamin noted, it's not possible to use the class name in method_exists within the class definition, get_class_methods delivers the method names for a given class name even inside the class. Thus another workaround for the mentioned problem is to use in_array(<method_name>, get_class_methods(<class_name>))
benjamin_ansbach at web dot de (2002-12-27 12:49:44)
if you want to check for a method "inside" of a class use:
method_exists($this, 'function_name')
i was a bit confused 'cause i thought i'm only able to check for a method when i got an object like $object_name = new class_name() with:
method_exists($object_name, 'method_name')
small example for those who didn't understood what i mean ( maybe caused by bad english :) ):
<?php
class a {
function a() {
if(method_exists($this, 'test'))
echo 'a::test() exists!';
else
echo 'a::test() doesn\'t exists';
}
function test() {
return true;
}
}
$b = new a();
?>
the output will be: a::test() exists!
maybe this will help someone
j dot metzger at steptown dot com (2002-01-16 03:42:21)
call_user_method uses the same mechanism as a normal method call. So you can get the returned values as well in this way.
$pagetext=call_user_method($method,$object_call);
All information is then in $pagetext.