Klassenmethoden oder Klasse neu definieren

Gibt es eine Möglichkeit, eine Klasse oder einige ihrer Methoden neu zu definieren, ohne die typische Vererbung zu verwenden? Zum Beispiel:

class third_party_library {
    function buggy_function() {
        return 'bad result';
    }
    function other_functions(){
        return 'blah';
    }
}

Was kann ich tun, um zu ersetzen buggy_function()? Das möchte ich natürlich gerne tun

class third_party_library redefines third_party_library{
    function buggy_function() {
        return 'good result';
    }
    function other_functions(){
        return 'blah';
    }
}

Das ist genau mein Dilemma: Ich habe eine Bibliothek eines Drittanbieters aktualisiert, die meinen Code bricht. Ich möchte die Bibliothek nicht direkt ändern, da zukünftige Updates den Code erneut beschädigen könnten. Ich suche nach einer nahtlosen Möglichkeit, die Klassenmethode zu ersetzen.

Ich habe das gefunden Bücherei das sagt, es kann es tun, aber ich bin vorsichtig, da es 4 Jahre alt ist.

BEARBEITEN:

Ich hätte klarstellen sollen, dass ich die Klasse nicht umbenennen kann third_party_library zu magical_third_party_library oder irgendetwas anderes aufgrund von Framework-Einschränkungen.

Wäre es für meine Zwecke möglich, der Klasse einfach eine Funktion hinzuzufügen? Ich denke, Sie können dies in C # mit einer sogenannten “partiellen Klasse” tun.

Es heißt Affen patchen. Aber PHP hat keine native Unterstützung dafür.

Obwohl, wie andere auch darauf hingewiesen haben, die Runkit-Bibliothek steht zur Unterstützung der Sprache zur Verfügung und ist der Nachfolger von Klassensatz. Und obwohl es so aussah verlassen von seinem Ersteller (nachdem angegeben wurde, dass es nicht mit PHP 5.2 und höher kompatibel war), scheint das Projekt jetzt eine zu haben neues Zuhause und Betreuer.

Ich kann immer noch nicht sagen, dass ich ein Fan seines Ansatzes bin. Das Vornehmen von Modifikationen durch Auswerten von Code-Strings schien mir immer potenziell gefährlich und schwierig zu debuggen.

Immer noch, runkit_method_redefine scheint das zu sein, wonach Sie suchen, und ein Beispiel für seine Verwendung finden Sie in /tests/runkit_method_redefine.phpt im Depot:

runkit_method_redefine('third_party_library', 'buggy_function', '',
    'return \'good result\''
);

Runkit scheint eine gute Lösung zu sein, aber es ist standardmäßig nicht aktiviert und Teile davon sind noch experimentell. Also habe ich eine kleine Klasse gehackt, die Funktionsdefinitionen in einer Klassendatei ersetzt. Beispielnutzung:

class Patch {

private $_code;

public function __construct($include_file = null) {
    if ( $include_file ) {
        $this->includeCode($include_file);
    }
}

public function setCode($code) {
    $this->_code = $code;
}

public function includeCode($path) {

    $fp = fopen($path,'r');
    $contents = fread($fp, filesize($path));
    $contents = str_replace('<?php','',$contents);
    $contents = str_replace('?>','',$contents);
    fclose($fp);        

    $this->setCode($contents);
}

function redefineFunction($new_function) {

    preg_match('/function (.+)\(/', $new_function, $aryMatches);
    $func_name = trim($aryMatches[1]);

    if ( preg_match('/((private|protected|public) function '.$func_name.'[\w\W\n]+?)(private|protected|public)/s', $this->_code, $aryMatches) ) {

        $search_code = $aryMatches[1];

        $new_code = str_replace($search_code, $new_function."\n\n", $this->_code);

        $this->setCode($new_code);

        return true;

    } else {

        return false;

    }

}

function getCode() {
    return $this->_code;
}
}

Fügen Sie dann die zu ändernde Klasse ein und definieren Sie ihre Methoden neu:

$objPatch = new Patch('path_to_class_file.php');
$objPatch->redefineFunction("
    protected function foo(\$arg1, \$arg2)
    {   
        return \$arg1+\$arg2;
    }");

Dann den neuen Code auswerten:

eval($objPatch->getCode());

Ein wenig grob, aber es funktioniert!

Für Leute, die immer noch nach dieser Antwort suchen.

Du solltest benutzen erweitert in Kombination mit Namensräume.

so was:

namespace MyCustomName;

class third_party_library extends \third_party_library {
  function buggy_function() {
      return 'good result';
  }
  function other_functions(){
      return 'blah';
  }
}

Um es dann zu verwenden, gehen Sie folgendermaßen vor:

use MyCustomName\third_party_library;

$test = new third_party_library();
$test->buggy_function();
//or static.
third_party_library::other_functions();

Der Vollständigkeit halber – Affen-Patching ist in PHP durchgängig verfügbar Runkit. Einzelheiten finden Sie unter runkit_method_redefine().

Wie wäre es, es in eine andere Klasse zu packen

class Wrapper {
 private $third_party_library;
 function __construct() { $this->third_party_library = new Third_party_library(); }
 function __call($method, $args) {
  return call_user_func_array(array($this->third_party_library, $method), $args);
 }
}

Ja, es heißt extend:

<?php
class sd_third_party_library extends third_party_library
{
    function buggy_function() {
        return 'good result';
    }
    function other_functions(){
        return 'blah';
    }
}

Ich habe “sd” vorangestellt. 😉

Denken Sie daran, dass beim Erweitern einer Klasse zum Überschreiben von Methoden die Signatur der Methode mit der des Originals übereinstimmen muss. Also zum Beispiel wenn das Original sagte buggy_function($foo, $bar)muss es mit den Parametern in der Klasse übereinstimmen, die es erweitert.

PHP ist ziemlich ausführlich darüber.

Zend Studio und PDT (Eclipse-basierte IDE) haben einige eingebaute Refraktoring-Tools. Aber es gibt keine eingebauten Methoden, um dies zu tun.

Außerdem möchten Sie überhaupt keinen schlechten Code in Ihrem System haben. Da es versehentlich aufgerufen werden könnte.