Holen Sie sich alle public deklarierten Methoden in der Klasse, nicht geerbt

Was ich will ist das array aller public-Methoden, und NUR öffentliche, die, von den untersten Klassen in der vererbungsstruktur. Zum Beispiel:

class MyClass {  }

class MyExtendedClass extends MyClass {  }

class SomeOtherClass extends MyClass {  }

Ist, und von innen von MyClass möchte ich, um alle ÖFFENTLICHEN Methoden von MyExtendedClass und SomeOtherClass.

Dachte ich, ich verwenden können, Reflexion-Klasse dies zu tun, aber wenn ich das mache, bekomme ich auch Methoden aus der MyClass, und ich will nicht, um Sie zu bekommen:

$class = new ReflectionClass('MyClass');
$methods = $class->getMethods(ReflectionMethod::IS_PUBLIC);

Gibt es eine Möglichkeit, dies zu tun? Oder die einzige Lösung, die ich haben in dieser situation nur heraus zu filtern, die Ergebnisse der Reflexions-Klasse?

Ich denke, Sie müssen sich selbst eine Hilfsfunktion, bekommt alle Oberklassen und bekommt Ihre öffentlichen Methoden.
Sie sind nicht öffentlich-Methode in diese Klasse ....
Nicht direkt, aber man kann leicht filtern der Ergebnisse, da die Namen der Klassen, zu denen Sie gehören, sind da.
stackoverflow.com/questions/9471883/...
Warum nicht einfach die Kreuzung von MyClass' öffentliche Funktionen und diejenigen, die Derivate?
Sie verwenden könnten: $methods = array_filter($class->getMethods(ReflectionMethod::IS_PUBLIC), function ($o) use ($class) {return $o->class == $class->getName();});

InformationsquelleAutor user1615069 | 2012-10-10

18

Nein, ich glaube nicht, können Sie herauszufiltern, die übergeordneten Methoden auf einmal. Aber es wäre sehr einfach, zu einfach die Ergebnisse filtern, indem Sie die Klasse index.
```
$methods = [];
foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method)
    if ($method['class'] == $reflection->getName())
         $methods[] = $method['name'];
```
- Wo hast du $classname aus ????
- Es ist die "MyClass". Ich vermute, der Klassenname ist nicht hart codiert...
- Nur ein Beispiel...if ($method['class'] == __CLASS__) oder irgendwo definiert.
- bigman, __CLASS__ wird nicht funktionieren, wenn Sie dies tun, die außerhalb der selbst-Kontext.
- In (mindestens) PHP 5.4 Sie sollten auf den Namen der Methode und die Klasse, die als Eigenschaften: $method->class und $method->name
InformationsquelleAutor Daniel

Schrieb ich einfach eine Methode mit einigen zusätzlichen Funktionalität erweitert, dass auf Daniels Antwort.

Es ermöglicht Ihnen die Rückgabe statischer oder Objekt-Methoden nur.

Es erlaubt Ihnen auch, um nur zurückzukehren Methoden wurden in dieser Klasse definiert sind.

Versorgung Ihres eigenen Namensraums oder kopieren Sie einfach die Methode.

Beispiel:

$methods = Reflection::getClassMethods(__CLASS__);

Code:

<?php

namespace [Your]\[Namespace];

class Reflection {
    /**
     * Return class methods by scope
     * 
     * @param string $class
     * @param bool $inherit 
     * @static bool|null $static returns static methods | object methods | both
     * @param array $scope ['public', 'protected', 'private']
     * @return array
     */
    public static function getClassMethods($class, $inherit = false, $static = null, $scope = ['public', 'protected', 'private'])
    {
        $return = [
            'public' => [],
            'protected' => [],
            'private' => []
        ];
        $reflection = new \ReflectionClass($class);
        foreach ($scope as $key) {
            $pass = false;
            switch ($key) {
                case 'public': $pass = \ReflectionMethod::IS_PUBLIC;
                    break;
                case 'protected': $pass = \ReflectionMethod::IS_PROTECTED;
                    break;
                case 'private': $pass = \ReflectionMethod::IS_PRIVATE;
                    break;
            }
            if ($pass) {
                $methods = $reflection->getMethods($pass);
                foreach ($methods as $method) {
                    $isStatic = $method->isStatic();
                    if (!is_null($static) && $static && !$isStatic) {
                        continue;
                    } elseif (!is_null($static) && !$static && $isStatic) {
                        continue;
                    }
                    if (!$inherit && $method->class === $reflection->getName()) {
                        $return[$key][] = $method->name;
                    } elseif ($inherit) {
                        $return[$key][] = $method->name;
                    }
                }
            }
        }
        return $return;
    }
}

InformationsquelleAutor Dieter Gribnitz

Hatte ich das Bedürfnis, das gleiche zu tun und kam mit der folgenden Funktion:

function getMethods($class, $visibility = "")
{

    $reflect = new ReflectionClass($class);
    $methods = [];
    //Iterate the methods
    foreach ($reflect->getMethods() as $value){

        /*
         * $value->getFileName() returns actual file name a method was set in.
         * if it does not match the current filename it is a inherited method assuming a file contains only one class
         */
        if ($value->getFileName() == $reflect->getFileName()) {
            if ($value->isPublic() === true) {
                $methods['public'][] = $value->name;
            }
            elseif ($value->isPrivate() === true) {
                $methods['private'][] = $value->name;
            }
            elseif ($value->isProtected() === true) {
                $methods['protected'][] = $value->name;
            }
        }
    }
    switch ($visibility) {
        case "private":
        case "public":
        case "protected":
            return $methods[$visibility];
            break;
        default:
            return $methods;
            break;
    }
}

Anhand der folgenden test-code in Father.php und Child.php

class Father{
    public function parentTest() { }
}
class Child extends Father {
    public function __construct() { }
    private function test() { }
    protected function test2() { }
}

Gibt die folgenden:

   array (size=3)
  'public' => 
    array (size=1)
      0 => string '__construct' (length=11)
  'private' => 
    array (size=1)
      0 => string 'test' (length=4)
  'protected' => 
    array (size=1)
      0 => string 'test2' (length=5)

InformationsquelleAutor Jelmergu

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.