Klasy PHP: uzyskaj dostęp do wywołującej instancji z wywołanej metody

Question

Przykro mi z tego dziwnego tematu, ale nie wiem, jak wyrazić to w inny sposób.

Próbuję uzyskać dostęp do metody z klasy wywołującej. Podobnie jak w tym przykładzie:

 
class normalClass { 
    public function someMethod() { 
      [...] 
      //this method shall access the doSomething method from superClass 
    } 
} 

class superClass { 
    public function __construct() { 
      $inst = new normalClass; 
      $inst->someMethod(); 
    } 
    public function doSomething() { 
      //this method shall be be accessed by domeMethod form normalClass 
    } 
} 

Obie klasy nie są powiązane przez dziedziczenie i nie chcę ustawić tej funkcji na statyczną.

Czy jest jakiś sposób, aby to osiągnąć?

Dzięki za pomoc!

Answer 1

można przekazać odniesienie do pierwszego obiektu w taki sposób:

class normalClass { 
    protected $superObject; 
    public function __construct(superClass $obj) { 
     $this->superObject = $obj; 
    } 

    public function someMethod() { 
     //this method shall access the doSomething method from superClass 
     $this->superObject->doSomething(); 
    } 
} 

class superClass { 
    public function __construct() { 
      //provide normalClass with a reference to ourself 
      $inst = new normalClass($this); 
      $inst->someMethod(); 
    } 
    public function doSomething() { 
      //this method shall be be accessed by domeMethod form normalClass 
    } 
} 

Answer 2

masz kilka opcji. Można użyć agregacji jak tak

class normalClass 
{ 
    protected $superClass; 

    public function __construct(superClass $superClass) 
    { 
    $this->superClass = $superClass; 
    } 

    public function someMethod() 
    { 
    $this->superClass->doSomething(); 
    } 
} 

class superClass 
{ 
    public function __construct() 
    { 
    $inst = new normalClass($this); 
    $inst->someMethod(); 
    } 

    public function doSomething() 
    { //this method shall be be accessed by domeMethod form normalClass 
    } 
} 

czy tylko prostej-up seter

class normalClass 
{ 
    protected $superClass; 

    public function setSuperClass(superClass $superClass) 
    { 
    $this->superClass = $superClass; 
    } 

    public function someMethod() 
    { 
    if (!isset($this->superClass)) 
    { 
     throw new Exception('you must set a superclass'); 
    } 
    $this->superClass->doSomething(); 
    } 
} 

class superClass 
{ 
    public function __construct() 
    { 
    $inst = new normalClass(); 
    $inst->setSuperClass($this); 
    $inst->someMethod(); 
    } 

    public function doSomething() 
    { //this method shall be be accessed by domeMethod form normalClass 
    } 
} 

Answer 3

Zależnie od przypadku użycia, może chcesz przekazać instancję tylko do funkcji:

class normalClass { 
    public function someMethod($object) { 
     $object->doSomething(); 
    } 
} 

Jeśli normalClass::someMethod() może być wywołany przez wiele różnych odrębnych $object s, może to być lepszym wyborem (zamiast dostarczania $object do cała instancja normalClass).

Ale niezależnie od tego, że można rozważyć stworzenie interfejsu użyć do type hinting:

interface ISomethingDoer { 
    public function doSomething(); 
} 

class normalClass { 
    public function someMethod(ISomethingDoer $object) { 
     # Now PHP will generate an error if an $object is passed 
     # to this function which does not implement the above interface. 
     // ... 

class superClass implements ISomethingDoer { 
    // ... 

Answer 4

można użyć debug_backtrace() dla tego. Jest trochę niepewny, ale do celów debugowania jest użyteczny.

class normalClass { 
public function someMethod() { 
     $trace = debug_backtrace(); 
     $trace[1]->object->doSomething(); 
} 

}

Answer 5

woah miałem ten sam problem niż ty, ale zamiast iść z tak prostym przejściu odniesienie do obiektu, udałem się z menedżerem zdarzeń Zasadniczo, jeśli coś by się stało w normalna klasa, wywołałaby zdarzenie, które było słuchane przez klasę i że ta klasa (słuchacz) wywoła super-klasę, aby wykonać tę funkcję i, jeśli to konieczne, przekaże jej nowe argumenty.

Niezależnie od tego, czy przekazujesz go jako parametr do obiektu, czy też używasz podejścia opartego na zdarzeniu, oba rozwiązania działają. Wybierz ten, który preferujesz.

Aby uzyskać więcej informacji na temat wydarzeń, sympony wyjaśnia to całkiem dobrze. http://symfony.com/doc/current/components/event_dispatcher/introduction.html