ReflectionClass::hasMethod

    (PHP 5 >= 5.1.2, PHP 7, PHP 8)

    ReflectionClass::hasMethod — Checks if method is defined

    Description

    public ReflectionClass::hasMethod(string $name): bool

    Checks whether a specific method is defined in a class.

    Parameters

    name

    Name of the method being checked for.

    Return Values

    true if it has the method, otherwise false

    Examples

    Example #1 ReflectionClass::hasMethod() example

    <?php
    Class C {
    public function     publicFoo() {
    return     true;
    }

    protected function     protectedFoo() {
    return     true;
    }

    private function     privateFoo() {
    return     true;
    }

    static function     staticFoo() {
    return     true;
    }
    }

    $rc = new ReflectionClass("C");

    var_dump($rc->hasMethod('publicFoo'));

    var_dump($rc->hasMethod('protectedFoo'));

    var_dump($rc->hasMethod('privateFoo'));

    var_dump($rc->hasMethod('staticFoo'));

    // C should not have method bar
    var_dump($rc->hasMethod('bar'));

    // Method names are case insensitive
    var_dump($rc->hasMethod('PUBLICfOO'));
    ?>

    The above example will output:

    bool(true)
bool(true)
bool(true)
bool(true)
bool(false)
bool(true)

    See Also

    Improve This Page

    Learn How To Improve This Page • Submit a Pull Request • Report a Bug
    ＋add a note

    User Contributed Notes 6 notes

    up
    4
    phoenix at todofixthis dot com
    13 years ago
    Parent methods (regardless of visibility) are also available to a ReflectionObject. E.g.,

    <?php
    class ParentObject {
    public function     parentPublic( ) {
    }

    private function     parentPrivate( ) {
    }
    }

    class     ChildObject extends ParentObject {
    }

    $Instance = new ChildObject();
    $Reflector = new ReflectionObject($Instance);

    var_dump($Reflector->hasMethod('parentPublic')); // true
    var_dump($Reflector->hasMethod('parentPrivate')); // true
    ?>
    up
    1
    dn dot permyakov at gmail dot com
    5 years ago
    Trait methods can be seen by both actual and alias names

    <?php

    trait Sauce
    {
    public function     getSpicy()
    {
    return     'Cayenne';
    }
    }

    class     Sandwich
    {
    use     Sauce {
    Sauce::getSpicy as getSweet;
    }
    }

    $class = new \ReflectionClass('Sandwich');
    var_dump($class->hasMethod('getSweet'));
    var_dump($class->hasMethod('getSpicy'));
    ?>
    bool(true)
    bool(true)
    up
    0
    flancer64 at gmail dot com
    8 years ago
    Annotated methods that are implemented using PHP magic methods are not recognized by "hasMethod".

    <?php
    /**
    * @method void annotatedMethod()
    */
    class SomeClass
    {
    public function     __call($name, $arguments)
    {
    echo     "this is magic method: $name.\n";
    }

    public function     codedMethod()
    {
    echo     "this is coded method.\n";
    }
    }

    $obj = new \SomeClass();
    $obj->codedMethod();
    $obj->annotatedMethod();

    $ref = new ReflectionClass(\SomeClass::class);
    echo     "SomeClass has 'codedMethod': " . json_encode($ref->hasMethod('codedMethod')) . ".\n";
    echo     "SomeClass has 'annotatedMethod': " . json_encode($ref->hasMethod('annotatedMethod')) . ".\n";
    ?>

    Output:

    this is coded method.
    this is magic method: annotatedMethod.
    SomeClass has 'codedMethod': true.
    SomeClass has 'annotatedMethod': false.
    up
    0
    hanguofeng at gmail dot com
    13 years ago
    note that even if private method will also be 'has'.
    up
    -1
    Xorifelse
    7 years ago
    It might be interesting to know that this is the only method to determine if a trait has a specific method:

    trait a{
    function __wakeup(){}
    }

    class b{}

    class c{
    use a;
    }

    var_dump((new ReflectionClass('a'))->hasMethod('__wakeup')); // true
    var_dump((new ReflectionClass('b'))->hasMethod('__wakeup')); // false
    var_dump((new ReflectionClass('c'))->hasMethod('__wakeup')); // true
    up
    -4
    michaelgranados at gmail dot com
    12 years ago
    A way to check if you can call an method over a class:

    <?php
    function is_public_method(
    /* string */$className,
    /* string */$method
    ){
    $classInstance = new ReflectionClass($className);
    if (    $classInstance->hasMethod($method)) {
    return     false;
    }
    $methodInstance = $instance->getMethod($method);
    return     $methodInstance->isPublic();
    }
    ?>
    ＋add a note
    To Top