PHPGangsta - Der praktische PHP Blog

Gastartikel von Thomas Worm

Der Autor ist 25 Jahre alt, beschäftigt sich bereits seit der Schulzeit mit der Entwicklung von Webanwendungen auf Basis von PHP, (X)HTML, CSS, JavaScript und dem Framework des Typo3 CMS. Nach Abschluss des Bachelor-Studiums der Informatik arbeitet der Autor bei der DATEV eG im Bereich Cloud Services/ASP und studiert berufsbegleitend den Informatik-Master in Hagen.

Was sind Method Chains

Als Method Chain bezeichnet man eine Kette aneinandergehänger Methodenaufrufe auf einem Objekt. Möglich wird dies dadurch, dass die Methoden das Objekt als Rückgabewert wiederliefern. Dies kann zum Beispiel sinnvoll sein, wenn Daten gefiltert, gruppiert und sortiert werden sollen:

var untermenge = datenmenge.filter('name','[ABC]*')
                           .group('umsatz').has('sum>400')
                           .orderBy('name');

Sofern man mit Mengen arbeitet, ist dies durchaus ausreichend, weil man immer eine Menge zurückbekommt und damit auch einen Rückgabewert, der interessant ist (weil er die Ergebnismenge beinhaltet).

Rückgabewert beifügen

Operiert man auf einzelnen Objekten, so könnten einzelne Rückgabewerte interessant sein. JavaScript ermöglicht es durch einen Trick, Rückgabewerte und die Anwendungsmöglichkeit der Method Chain gleichzeitig zu liefern. Dazu wird ein Wrapper-Objekt erstellt, das gleichnamige Methoden wie das ursprüngliche Objekt und den Rückgabewert enthält. Die gleichnamigen Methoden sind wiederum Wrapper in Form einer anonymen Funktion, die auf dem ursprünglichen Objekt die Methoden aufrufen und ihnen dieses ursprüngliche Objekt als this-Scope übergeben.

Zum Erzeugen dieses Wrapper-Objekts wird eine Funktion definiert:

        function methodChainReturn(object, returnValue) {
            var returnObject = function() {
                this.returnValue = returnValue;

                for (var objectMember in object) {
                    this[objectMember] = function() {
                        return object[objectMember].apply(object, arguments);
                    }
                }
            };
            return new returnObject();
        }

Diese Funktion kann nun in den Methoden eines Objektes zum Auswerfen des Rückgabewertes verwendet werden:
Wir nehmen ein – nicht unbedingt sinnvolles – Auto-Objekt als Beispiel:

        function Car(model, color) {
            this.model = model;
            this.color = color;
            this.speed = 0;
            this.gear = 0;

            this.startCar = function(gear) {
                this.gear = gear || 1;
                return methodChainReturn(this, this.gear);
            }

            this.speedUp = function(speed) {
                var newSpeed = this.speed + speed;
                if (newSpeed <= 160 || model === 'BMW')
                    this.speed += newSpeed;
                return methodChainReturn(this, this.speed);
            }

            this.speedDown = function(speed) {
                this.speed += speed;
                return methodChainReturn(this, this.speed);
            }

            this.changeGear = function(gear) {
                this.gear = gear;
                return methodChainReturn(this, this.gear);
            }
        }

Die Methoden des Objektes können nun beliebig aneinandergereicht aufgerufen werden. An der Stelle, an der der Verwender den Rückgabewert möchte, kann er die Eigenschaft returnValue auslesen. Damit muss nicht die Methode entscheiden, ob der Verwender einen Rückgabewert oder die Möglichkeit einer Method Chain bekommt, sondern der Verwender erhält beide Möglichkeiten und kann sich eine aussuchen.

        var bmw = new Car('BMW', 'black');
        var trabi = new Car('Trabi', 'green');

        console.log(
            'BMW: ', bmw.startCar()
                        .speedUp(50)
                        .changeGear(2)
                        .speedDown(20)
                        .speedUp(180)
                        .returnValue
        );

        console.log(
            'Trabi', trabi.startCar(4)
                          .speedUp(50)
                          .speedDown(20)
                          .speedUp(180)
                          .returnValue
        );

Erwartungsgemäß zeigt die Konsole


BMW:   180
Trabi: 180


Wozu sinnvoll?

Bei obigem Beispiel könnte nun die Frage aufkommen: Warum brauch ich hier den Wrapper mit einem Rückgabewert. Wäre es nicht sinnvoller ein getGear(), getSpped() im Objekt anzubieten? Ja, beim Autoobjekt hätte dies durchaus Vorteile. Aber es kann auch Objekte geben, bei denen man interne Informationen nicht unbedingt generell als öffentlich verfügbar machen möchte bzw. bei denen es semantische Unterschiede gibt. Betrachtet man beispielsweise den Teil eines StringBuilder-Objekts:

        function StringBuilder(str) {

            var privateScope = {};

            privateScope.str = str;
            privateScope.pos = 0;
            privateScope.lastFuncErrored = false;

            this.find = function(str) {
                var pos = privateScope.str.indexOf(str);
                var success = !(pos < 0);
                privateScope.lastFuncErrored = !success;
                if (success)
                    privateScope.pos = pos;
                return methodChainReturn(this, success);
            }

            this.end = function() {
                var pos = privateScope.str.length;
                privateScope.pos = pos;
                privateScope.lastFuncErrored = false;
                return methodChainReturn(this, pos);
            }

            this.write = function(val) {
                if (!privateScope.lastFuncErrored) {
                    var pos = privateScope.pos;
                    var str = privateScope.str;
                    if (pos > str.length)
                        str += val;
                    else {
                        var part1 = str.slice(0,pos);
                        var part2 = val;
                        var part3 = str.slice(pos + val.length, str.length - 1);
                        str = part1 + part2 + part3;
                    }
                    privateScope.str = str;
                    return methodChainReturn(this, str);
                }
            }

        }

Hier tritt folgender Fall ein: Die Funktion find() soll zurückgeben, ob der String gefunden wird. Wenn der String gefunden wird, soll man ihn überschreiben können. Daher wird intern die Position als Verwaltungsinformation gespeichert und ob die letzte Methode auf dem Objekt erfolgreich war. Man möchte aber nicht generell öffentlich bekannt geben, ob die letzte Methode erfolgreich war. Daher gibt es hierfür keine öffentlichen Getter. Die Funktion find() lässt sich auf zwei Arten verwenden, wodurch für den Verwender die Möglichkeit entsteht gut lesbaren Code zu schreiben:

    var stringBuilder = new StringBuilder('Das');

    console.log('Kompletter String: ',
            stringBuilder.end()
                         .write(' ist ein Test!')
                         .returnValue);

    console.log('Test wurde gefunden? ',
            stringBuilder.find('Test')
                         .returnValue);

    console.log('"ist" durch "war" ersetzt: ',
            stringBuilder.find('ist')
                         .write('war')
                         .returnValue);

Das Ergebnis sieht folgendermaßen aus:

Kompletter String:         Das ist ein Test!
Test wurde gefunden?       true
"ist" durch "war" ersetzt: Das war ein Test

Diskussion erwünscht

Zugegeben, für Manche wird das ganze sehr gekünstelt aussehen und es lässt sich streiten, ob man den Overhead und die Performance-Minderung durch ein Wrapper-Objekt in Kauf nehmen sollte. Ggfs. kann der Ansatz doch an ein oder anderer Stelle sinnvoll sein, er kann aber auch stark kritisiert werden.

Eine zusätzliche Erweiterung der methodChainReturn()-Funktion wäre insofern denkbar, dass nicht nur ein returnValue übergeben wird, sondern ein Objekt-Literal, das mehrere Rückgabewerte bereitstellt. Damit liese sich noch mehr Komfort für den Verwender erzeugen und damit ggfs. der Einsatz vorteilhafter darstellen.

Ich freue mich auf jedenfall auf Eure Kommentare.