Refactoring ist ein unverzichtbarer Prozess in der Softwareentwicklung, bei dem bestehender Code umstrukturiert wird, ohne seine äußere Funktionalität zu verändern. Das Ziel? „Schlechten“ Code in eine saubere, wartbare Struktur zu verwandeln, die auch von anderen Entwicklern leicht verstanden werden kann. In diesem Artikel werfen wir einen Blick auf gängige Techniken, die den PHP-Code klarer und einfacher wartbar machen.
Warum und wann ist Refactoring sinnvoll?
Refactoring optimiert die Lesbarkeit und senkt den Wartungsaufwand von Code, was langfristig Zeit und Ressourcen spart. Dabei gilt jedoch: Wenn mehr als 50 % des Codes überarbeitet werden müssten, kann ein vollständiger Rewrite kosteneffizienter sein. Kleinere, schrittweise Refactoring-Maßnahmen lassen sich hingegen leichter integrieren und haben oft eine große Wirkung auf die Codequalität.
Prinzipien des Refactorings: DRY, YAGNI und KISS
Refactoring beruht auf bewährten Prinzipien:
- DRY („Don’t Repeat Yourself“) Wiederholungen im Code sollten vermieden werden. Redundante Codeabschnitte sollten in Funktionen oder Klassen ausgelagert werden. Dadurch muss eine Anpassung nur an einer Stelle erfolgen.
- YAGNI („You Aren’t Gonna Need It“) Implementieren Sie nur aktuelle Anforderungen und vermeiden Sie es, potenzielle zukünftige Funktionen zu berücksichtigen, die möglicherweise nie benötigt werden.
- KISS („Keep It Simple, Stupid“) Halten Sie den Code so einfach wie möglich, um die Wartbarkeit zu erhöhen.
Beispiele und Techniken des Refactorings
1. Code-Duplikate vermeiden durch Vererbung Ein häufiges Refactoring-Szenario ist die Reduktion von Duplikaten in ähnlichen Klassen. Statt Code in mehreren Klassen zu wiederholen, kann eine übergeordnete Klasse erstellt werden, die gemeinsame Funktionalitäten kapselt:
abstract class Addon {
protected $settings;
protected function set_settings(array $settings): void {
$this->settings = $settings;
}
}
class AwesomeAddon extends Addon {
public function __construct($settings) {
$this->set_settings($settings);
}
}
In diesem Beispiel werden doppelte Funktionen in der Addon-Klasse zentralisiert, wodurch die Wartbarkeit und Lesbarkeit verbessert werden.
2. Zerlegen komplexer Funktionen Lange Funktionen sind schwer lesbar und pflegeintensiv. Sie sollten in kleinere, sinnvolle Methoden aufgeteilt werden:
function upload_attachment($post_id) {
$this->validate_attachment($post_id);
$s3client = $this->initialize_s3_client();
$this->upload_to_s3($s3client, $post_id);
}
Durch diese Aufteilung wird jede Methode fokussierter und der gesamte Code verständlicher.
3. Guard Clauses zur Vereinfachung verschachtelter Bedingungen Durch Guard Clauses können Sie lange if-else-Strukturen vermeiden und den Code linearer gestalten. Beispiel:
function get_setting($key, $default = '') {
$settings = $this->get_settings();
if ($this->is_legacy_setting($settings, $key)) return $default;
if ($key == 'object-versioning' && !$settings['object-versioning']) return $default;
return parent::get_setting($key, $default);
}
Guard Clauses verbessern die Lesbarkeit, da sie die Ausnahmebedingungen vorab abfangen und den Hauptfluss des Codes verdeutlichen.
4. Verwenden funktionaler Methoden wie map und reduce Funktionale Methoden wie array_map und array_reduce können die Lesbarkeit verbessern, insbesondere in der Arbeit mit Arrays:
$score = array_reduce($types, function($result, $type) use ($scores) {
return $result + ($scores[$type] ?? 1);
});
Durch solche funktionalen Methoden wird der Code komprimierter und wartbarer.
Fazit und weiterführende Ressourcen
Refactoring erfordert Disziplin und ein solides Verständnis bewährter Prinzipien. Doch der Aufwand lohnt sich: Der Code wird nicht nur lesbarer, sondern auch einfacher zu testen und zu warten.
Wir konnten Ihnen nicht weiterhelfen, dann treten Sie mit uns in Kontakt und lassen Sie sich zum Thema Refactoring beraten! Kontakt Never Code Alone
Inspiriert durch den Beitrag von Gilbert Pellegrom auf https://deliciousbrains.com/refactoring-php-code-better-readability/
