Verificare se esiste un metodo in una classe estesa ma non nella classe padre

Question

Con method_exists, controlla tutti i metodi, inclusa la classe padre.

Esempio:

class Toot { 
    function Good() {} 
} 

class Tootsie extends Toot { 
    function Bad() {} 
} 

function testMethodExists() { 
    // true 
    var_dump(method_exists('Toot', 'Good')); 

    // false 
    var_dump(method_exists('Toot', 'Bad')); 

    // true 
    var_dump(method_exists('Tootsie', 'Good')); 

    // true 
    var_dump(method_exists('Tootsie', 'Bad')); 
} 

Come posso verificare che il metodo esiste solo sulla classe corrente e non classe genitore (cioè Tootsie.)?

Answer 1

è possibile utilizzare la riflessione

$refl = new ReflectionClass($class_name); 

if($refl->hasMethod($method_name)){ 
     //do your stuff here 
} 

per ulteriori informazioni ReflectionClass

Answer 2

Poiché v. 4.0.5 di PHP ha get_parent_class() metodo, che restituisce classe genitrice. Così si può gestire senza relflection:

class A 
{ 
    function a() { /* ... */}  
    function b() { /* ... */}  
} 
class B extends A 
{ 
    function b() { /* ... */}  
    function c() { /* ... */}  
} 

function own_method($class_name, $method_name) 
{  
    if (method_exists($class_name, $method_name)) 
    { 
     $parent_class = get_parent_class($class_name); 
     if ($parent_class !== false) return !method_exists($parent_class, $method_name); 
     return true; 
    } 
    else return false; 
} 

var_dump(own_method('B', 'a')); // false 
var_dump(own_method('B', 'b')); // false 
var_dump(own_method('B', 'c')); // true 

Answer 3

Per me la questione era Verificare se un metodo esiste in una classe estesa ma non classe genitoredalla classe padre

Prendendo l'esempio di cui sopra da Elantcev Mikhail, sarebbe più simile a questo: -

class A 
{ 
     function a() { /* ... */}  
     function b() { /* ... */}  
     public function own_method($method_name) 
     {  
      if (method_exists($this, $method_name)) 
      { 
       return true; 
      } 
      else return false; 
     } 
} 
class B extends A 
{ 
    function b() { /* ... */}  
    function c() { /* ... */}  
} 

$b = new B; 

var_dump($b->own_method('c')); // true 

Perché vuoi farlo?

Ho un BaseModel classe in cui I suggerimenti di formato per attributi nel modello esteso:

class BaseModel 
{ 
    public function attributeHelp($attributeName) 
    { 
     if (method_exists($this, 'hints') && array_key_exists($attributeName, $this->hints())) 
     { 
      return '<i html for nicely formatted hint' 
       . $this->hints()[$attributeName] 
       . '"></i>'; 
     } 
     return false; 
    } 
} 

E poi nel mio modello di dati

class Customer extends BaseModel 
{ 
    public function hints() 
    { 
     return [ 
      'customer_name' => 'please use your fullname ...', 
      'some other attribute' => 'some other description' 
     ]; 
    } 
} 

Answer 4

Se avete bisogno di sapere se il metodo esiste in un dato bambino, indipendentemente dall'esistenza in una classe genitore, puoi farlo in questo modo:

$reflectionClass = new ReflectionClass($class_name); 
if ($reflectionClass->getMethod($method_name)->class == $class_name) { 
    // do something 
}