Statische Methoden in PHP verketten?

Ist es möglich, statische Methoden mit einer statischen Klasse zu verketten? Angenommen, ich wollte so etwas tun:

$value = TestClass::toValue(5)::add(3)::subtract(2)::add(8)::result();

. . . und natürlich möchte ich, dass $value die Nummer 14 zugewiesen wird. Ist das möglich?

Aktualisieren: Es funktioniert nicht (Sie können “selbst” nicht zurückgeben – es ist keine Instanz!), aber meine Gedanken haben mich hierher geführt:

class TestClass {
    public static $currentValue;

    public static function toValue($value) {
        self::$currentValue = $value;
    }

    public static function add($value) {
        self::$currentValue = self::$currentValue + $value;
        return self;
    }

    public static function subtract($value) {
        self::$currentValue = self::$currentValue - $value;
        return self;
    }

    public static function result() {
        return self::$value;
    }
}

Nachdem ich das herausgefunden habe, denke ich, dass es einfach sinnvoller wäre, einfach mit einer Klasseninstanz zu arbeiten, anstatt zu versuchen, statische Funktionsaufrufe zu verketten (was nicht möglich erscheint, es sei denn, das obige Beispiel könnte irgendwie optimiert werden).

Ich mag die oben von Camilo bereitgestellte Lösung, da Sie im Wesentlichen nur den Wert eines statischen Elements ändern und da Sie eine Verkettung wünschen (obwohl es nur syntaktischer Zucker ist), ist die Instanziierung von TestClass wahrscheinlich der beste Weg .

Ich würde ein Singleton-Muster vorschlagen, wenn Sie die Instanziierung der Klasse einschränken möchten:

class TestClass
{   
    public static $currentValue;

    private static $_instance = null;

    private function __construct () { }

    public static function getInstance ()
    {
        if (self::$_instance === null) {
            self::$_instance = new self;
        }

        return self::$_instance;
    }

    public function toValue($value) {
        self::$currentValue = $value;
        return $this;
    }

    public function add($value) {
        self::$currentValue = self::$currentValue + $value;
        return $this;
    }

    public function subtract($value) {
        self::$currentValue = self::$currentValue - $value;
        return $this;
    }

    public function result() {
        return self::$currentValue;
    }
}

// Example Usage:
$result = TestClass::getInstance ()
    ->toValue(5)
    ->add(3)
    ->subtract(2)
    ->add(8)
    ->result();

class oop{
    public static $val;

    public static function add($var){
        static::$val+=$var;
        return new static;
    }

    public static function sub($var){
        static::$val-=$var;
        return new static;
    }

    public static function out(){
        return static::$val;
    }

    public static function init($var){
        static::$val=$var;
        return new static;      
    }
}

echo oop::init(5)->add(2)->out();

Kleiner verrückter Code auf php5.3 … nur zum Spaß.

namespace chaining;
class chain
    {
    static public function one()
        {return get_called_class();}

    static public function two()
        {return get_called_class();}
    }

${${${${chain::one()} = chain::two()}::one()}::two()}::one();

Mit php7 können Sie aufgrund neuer die gewünschte Syntax verwenden Einheitliche Variablensyntax

<?php

abstract class TestClass {

    public static $currentValue;

    public static function toValue($value) {
        self::$currentValue = $value;
        return __CLASS__;
    }

    public static function add($value) {
        self::$currentValue = self::$currentValue + $value;
        return __CLASS__;
    }

    public static function subtract($value) {
        self::$currentValue = self::$currentValue - $value;
        return __CLASS__;
    }

    public static function result() {
        return self::$currentValue;
    }

}

$value = TestClass::toValue(5)::add(3)::subtract(2)::add(8)::result();
echo $value;

Demo

Wenn toValue(x) ein Objekt zurückgibt, könnten Sie folgendermaßen vorgehen:

$value = TestClass::toValue(5)->add(3)->substract(2)->add(8);

Vorausgesetzt, toValue gibt eine neue Instanz des Objekts zurück, und jede nächste Methode mutiert es und gibt eine Instanz von $this zurück.

Dies ist genauer, einfacher und lesefreundlicher (ermöglicht die Code-Vervollständigung)

class Calculator
{   
    public static $value = 0;

    protected static $onlyInstance;

    protected function __construct () 
    {
        // disable creation of public instances 
    }

    protected static function getself()
    {
        if (static::$onlyInstance === null) 
        {
            static::$onlyInstance = new Calculator;
        }

        return static::$onlyInstance;
    }

    /**
     * add to value
     * @param numeric $num 
     * @return Calculator
     */
    public static function add($num) 
    {
        static::$value += $num;
        return static::getself();
    }

    /**
     * substruct
     * @param string $num
     * @return Calculator
     */
    public static function subtract($num) 
    {
        static::$value -= $num;
        return static::getself();
    }

    /**
     * multiple by
     * @param string $num
     * @return Calculator
     */
    public static function multiple($num) 
    {
        static::$value *= $num;
        return static::getself();
    }

    /**
     * devide by
     * @param string $num
     * @return Calculator
     */
    public static function devide($num) 
    {
        static::$value /= $num;
        return static::getself();
    }

    public static function result()
    {
        return static::$value;
    }
}

Beispiel:

echo Calculator::add(5)
        ->subtract(2)
        ->multiple(2.1)
        ->devide(10)
    ->result();

Ergebnis: 0,63

Die Leute verkomplizieren das wie verrückt.

Sieh dir das an:

class OopClass
{
    public $first;
    public $second;
    public $third;

    public static function make($first)
    {
        return new OopClass($first);
    }

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

    public function second($second)
    {
        $this->second = $second;
        return $this;
    }

    public function third($third)
    {
        $this->third = $third;
        return $this;
    }
}

Verwendung:

OopClass::make('Hello')->second('To')->third('World');