Method chaining

[nikosch]

Diskussionsbeitrag zum Wiki Eintrag: Method chaining.

Die Diskussionsplattform des PHP.de Wiki wurde ins Forum integriert. Durch Klicken des Buttons "Antwort" kannst du an diesem Thema teilnehmen.

[nikosch]

Hallo Flo. Cool, endlich mal ein neuer Autor im Wiki!
Hab bisher nur überflogen, habe aber ein paar Anmerkungen.

1/ pochenden Zeigefingers verweise ich auf unsere niegelnagelneueln Coding Standards

2/ das Argument "sondern ergibt auch einen logischen Sinn beim lesen vom Code" sehe ich durch das verwendete Codebeispiel nicht getragen:

$person->setName('Flo')->setAge(21)->displayPerson(); 

Etwas wie

$oDB->connect()->selectDB('bla')->query ('xyz'); 

wäre vielaussagekräftiger.

3/ Ich würde auf jeden Fall Negativargumente mit in den Artikel nehmen:
- es wird ständig eine Objekt herumgereicht.
- Fehlerbehandlung ist schwierig, da die Methoden nicht vorzeitig abgebrochen werden können sondern immer $this zurückgeben müssen

[robo47]

3/ Ich würde auf jeden Fall Negativargumente mit in den Artikel nehmen:
- es wird ständig eine Objekt herumgereicht.
- Fehlerbehandlung ist schwierig, da die Methoden nicht vorzeitig abgebrochen werden können sondern immer $this zurückgeben müssen

Was macht die Fehlerbehandlung denn schwerer ?
Ich denke die Fehlerbehandelung erfolgt, wenn man solche Methoden einsetzt eh über Exceptions und wo ist da dann der Unterschied ob ich

$obj = new MyClass();
try {
$obj->setX(1);
$obj->setY(2);
$obj->setZ(3);
} catch (Exception $e) {
// handle Error
} 

oder

$obj = new MyClass();
try {
$obj->setX(1)
      ->setY(2)
      ->setZ(3);
} catch (Exception $e) {
// handle Error
} 

benutzte?

[nikosch]

Ich rede von Fehlern, die innerhalb von beteiligten Methoden abgefangen werden müssen.

[Flor1an]

Ja Codingstandards hab ich schon gelesen, Text war allerdings schon fertig ... werd ihn nochmal überarbeiten wollte aber einfach mal ausprobieren wie ich den Text in die Wiki bekomme

[Manko10]

Kleine Anmerkung: vielleicht könntest du die PHP-Tags bei Code-Ausschnitten ganz weglassen. Meines Erachtens sollten die nur bei Komplett-Codes gesetzt werden. Wird nur eine einzelne Funktion oder Zeile herausgepickt, wirken sie eher störend und lenken vom eigentlich Wichtigen ab.

[nikosch]

Guter Punkt. Den werden wir mal noch in die Konventionen oder Coding Standards aufnehmen.

[Flor1an]

Ja das würde Sinn machen. Ich entferne mal alle PHP Tags. Ich war es nur gewohnt die öffnenden Tags zu schreiben da in irgend einem Board der [ php] BBTag nur dann den Code highlighted wenn ein <?php am Anfang steht.

[Manko10]

Das ist aber nur noch in einigen Boards so. vBulletin benutzt zwar auch highlight_string(), aber setzt bei Bedarf noch ein <?php davor und entfernt es anschließend wieder.
Beim Highlighter auf meiner Seite habe ich es ebenso gemacht.

[nikosch]

2 neue Fragen:

- displayPerson() sollte besser den String zurückliefern, oder? Vielleicht sollten wir im Wiki eine gewisse Konsistenz an Positivpatterns (EVA, immer valideren, auch Trivialcode) einhalten.

- Das Validierungsbeispiel würde ich so nicht umsetzen, weil i.A. ein Fehler für die Negativvalidierung ausreicht. Also entweder man sammelt auch Infos zur Fehlersituation mit oder bricht Folgefehler schon vor der Prüfung mit return $this ab.

[Flor1an]

Okay das displayPerson() ändere ich ab. Wie würdest du das Validator Beispiel umschreiben? Da ne abbruchbedingung rein zu schieben wird schwierig. Es sollte halt möglichst kurz und knapp sein sonst liest sich keiner den Code durch!

[nikosch]

<?php

class Validator
{
 
    private $__value, 
    private $__error = false;
 
    public function value($value) 
    {
        $this->__value = $value;
        return $this;
    }
 
    public function isRequired() 
    {
        if ($this->__error != false) {
            if (empty($this->__value)) {
                $this->__error = true;
            }
        }
        return $this;
    }
 
    public function setLength($min, $max = false) 
    {
        if ($this->__error != false) {
            if ($min !== false AND strlen($this->__value) < $min) {
                $this->__error = true;
            }
            if ($max !== false AND strlen($this->__value) > $max) {
                $this->__error = true;
            }
        }
        return $this;
    }
 
    public function isDate() 
    {
        if ($this->__error != false) {
            $date = explode('.', $this->__value); // deutsches Datum Format (tt.mm.jjjj)
            if (!checkdate($date[1], $date[0], $date[2])) {
                $this->__error = true;
            }
        }
        return $this;
    }
 
    public function isNumeric()
    {
        if ($this->__error != false) {
            if (!is_numeric($this->__value)) {
                $this->__error = true;
            }
        }
        return $this;
    }
 
    public function numRange($a, $b = false)
    {
        if ($this->__error != false) {
            if ($a !== false AND $this->__value < $a) {
                $this->__error = true;
            }
            if ($b !== false AND $this->__value > $b) {
                $this->__error = true;
            }
        }
        return $this;
    }
 
    public function isValid()
    {
        return ! $this->__error;
    }
 
}

Notfalls lieber weniger Methoden benutzen. Früher ABbruch geht natürlich auch:

   public function numRange($a, $b = false)
    {
        if ($this->__error == false) {
            return $this;
        }

        if ($a !== false AND $this->__value < $a) {
            $this->__error = true;
        }
        if ($b !== false AND $this->__value > $b) {
            $this->__error = true;
        }
        return $this;
    } 

Ggf. würde ich nochmal das Erstellen eines Setups als Beispiel für Chaining ergänzen.

[Paul.Schramenko]

3/ Ich würde auf jeden Fall Negativargumente mit in den Artikel nehmen:
- es wird ständig eine Objekt herumgereicht.

Das ist wohl richtig, erhöht doch enorm die Lesbarkeit. Jetzt mal ne Frage von meiner Seite aus, macht dass denn soviel aus, wenn ein Objekt herumgereicht wird? Jetzt mal rein performancetechnisch und allgemein.

- Fehlerbehandlung ist schwierig, da die Methoden nicht vorzeitig abgebrochen werden können sondern immer $this zurückgeben müssen

Finde ich eigentich nicht. IMHO sollte Method chaining nur bei Settern verwendet werden, bzw. bei Funktionen, die im Normalfall keinen Wert zurückliefern.
Um das näher zu erläutern, ein kleines Bsp. wie in meinem Code in der Regel aussieht:

$valid = $obj->setValue($val1)
             ->setValueTwo($val2)
             ->setValueThree($val3)
             ->setValueFour($val4)
             ->save(); 

public function setValue($val)
{
    $this->_value = $val;
    return $this;
} 

public function save() 
{
    if ($this->_isValid()) {
        return $this->_save();
    }
    return false;
} 

Gerade beim verarbeiten von Formulareingaben, muss man IMHO erst alle Werte setzen, dann validieren und und am Ende je nachdem zu welchem Ergebnis die Validierung geführt hat, die Daten speichern/weiterverarbeiten oder einen Fehler ausgeben und die Werte ins Formular setzen.

Hoffe ich rede jetzt nicht am Thema vorbei...