Edit Report a Bug

    ReflectionClass::hasMethod

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

    ReflectionClass::hasMethod — Checks if method is defined

    Descrizione

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

    Checks whether a specific method is defined in a class.

    Elenco dei parametri

    name

    Name of the method being checked for.

    Valori restituiti

    true if it has the method, otherwise false

    Esempi

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

    Il precedente esempio visualizzerà:

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

    Vedere anche:

    add a note add a note

    User Contributed Notes 6 notes

    up
    4
    phoenix at todofixthis dot com
    14 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
    14 years ago
    note that even if private method will also be 'has'.
    up
    -1
    Xorifelse
    8 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 add a note
    To Top