¿Encadenar Métodos Estáticos en PHP?

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();

Pequeño código loco en php5.3... sólo por diversión.

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();

Si toValue (x) devuelve un objeto, puede hacer lo siguiente:

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

Siempre que toValue devuelva una nueva instancia del objeto, y cada método siguiente lo mute, devolviendo una instancia de this this.

Con php7 podrá usar la sintaxis deseada debido a la nueva Sintaxis Variable uniforme

<?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

Siempre se puede usar el Primer método como estático y el resto como métodos de instancia:

$value = Math::toValue(5)->add(3)->subtract(2)->add(8)->result();

O mejor aún:

 $value = Math::eval(Math::value(5)->add(3)->subtract(2)->add(8));

class Math {
     public $operation;
     public $operationValue;
     public $args;
     public $allOperations = array();

     public function __construct($aOperation, $aValue, $theArgs)
     {
       $this->operation = $aOperation;
       $this->operationValue = $aValue;
       $this->args = $theArgs;
     }

     public static function eval($math) {
       if(strcasecmp(get_class($math), "Math") == 0){
            $newValue = $math->operationValue;
            foreach ($math->allOperations as $operationKey=>$currentOperation) {
                switch($currentOperation->operation){
                    case "add":
                         $newvalue = $currentOperation->operationValue + $currentOperation->args;
                         break;
                    case "subtract":
                         $newvalue = $currentOperation->operationValue - $currentOperation->args;
                         break;
                }
            }
            return $newValue;
       }
       return null;
     }

     public function add($number){
         $math = new Math("add", null, $number);
         $this->allOperations[count($this->allOperations)] &= $math;
         return $this;
     }

     public function subtract($number){
         $math = new Math("subtract", null, $number);
         $this->allOperations[count($this->allOperations)] &= $math;
         return $this;
     }

     public static function value($number){
         return new Math("value", $number, null);
     }
 }

Solo para tu información.. Escribí esto en la parte superior de mi cabeza (justo aquí en el sitio). Por lo tanto, puede que no funcione, pero esa es la idea. También podría haber hecho una llamada al método recursivo para eval, pero pensé que esto podría ser más simple. Por favor, hágamelo saber si le gustaría que elaborara o proporcionara cualquier otra ayuda.

En pocas palabras... no. :) El operador de resolución (::) funcionaría para la parte TetsClass:: toValue (5), pero todo después de eso solo dará un error de sintaxis.

Una vez que los espacios de nombres están implementados en la versión 5.3, puede tener operadores "chained"::, pero todo lo que hará es profundizar en el árbol de espacios de nombres; no será posible tener métodos en medio de cosas como esta.

Lo mejor que se puede hacer

class S
{
    public static function  __callStatic($name,$args)
    {
        echo 'called S::'.$name . '( )<p>';
        return '_t';
    }
}

$_t='S';
${${S::X()}::F()}::C();

Esto es más preciso, más fácil y fácil de leer (permite completar el código)

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;
    }
}

Ejemplo:

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

Resultado: 0.63

No, esto no funcionará. El operador :: necesita evaluar de nuevo a una clase, por lo que después de que el TestClass::toValue(5) evalúa, el método ::add(3) solo sería capaz de evaluar en la respuesta del último.

Así que si toValue(5) devolviera el entero 5, básicamente estaría llamando a int(5)::add(3) lo que obviamente es un error.

La forma más fácil que he encontrado para el encadenamiento de métodos desde una nueva Instancia o método estático de clase es la siguiente. He utilizado Late Static Binding aquí y realmente me encantó esta solución.

He creado una utilidad para enviar notificaciones de múltiples usuarios en la siguiente página usando tostr en Laravel.

<?php

namespace App\Utils;

use Session;

use Illuminate\Support\HtmlString;

class Toaster
{
    private static $options = [

        "closeButton" => false,

        "debug" => false,

        "newestOnTop" => false,

        "progressBar" => false,

        "positionClass" => "toast-top-right",

        "preventDuplicates" => false,

        "onclick" => null,

        "showDuration" => "3000",

        "hideDuration" => "1000",

        "timeOut" => "5000",

        "extendedTimeOut" => "1000",

        "showEasing" => "swing",

        "hideEasing" => "linear",

        "showMethod" => "fadeIn",

        "hideMethod" => "fadeOut"
    ];

    private static $toastType = "success";

    private static $instance;

    private static $title;

    private static $message;

    private static $toastTypes = ["success", "info", "warning", "error"];

    public function __construct($options = [])
    {
        self::$options = array_merge(self::$options, $options);
    }

    public static function setOptions(array $options = [])
    {
        self::$options = array_merge(self::$options, $options);

        return self::getInstance();
    }

    public static function setOption($option, $value)
    {
        self::$options[$option] = $value;

        return self::getInstance();
    }

    private static function getInstance()
    {
        if(empty(self::$instance) || self::$instance === null)
        {
            self::setInstance();
        }

        return self::$instance;
    }

    private static function setInstance()
    {
        self::$instance = new static();
    }

    public static function __callStatic($method, $args)
    {
        if(in_array($method, self::$toastTypes))
        {
            self::$toastType = $method;

            return self::getInstance()->initToast($method, $args);
        }

        throw new \Exception("Ohh my god. That toast doesn't exists.");
    }

    public function __call($method, $args)
    {
        return self::__callStatic($method, $args);
    }

    private function initToast($method, $params=[])
    {
        if(count($params)==2)
        {
            self::$title = $params[0];

            self::$message = $params[1];
        }
        elseif(count($params)==1)
        {
            self::$title = ucfirst($method);

            self::$message = $params[0];
        }

        $toasters = [];

        if(Session::has('toasters'))
        {
            $toasters = Session::get('toasters');
        }

        $toast = [

            "options" => self::$options,

            "type" => self::$toastType,

            "title" => self::$title,

            "message" => self::$message
        ];

        $toasters[] = $toast;

        Session::forget('toasters');

        Session::put('toasters', $toasters);

        return $this;
    }

    public static function renderToasters()
    {
        $toasters = Session::get('toasters');

        $string = '';

        if(!empty($toasters))
        {
            $string .= '<script type="application/javascript">';

            $string .= "$(function() {\n";

            foreach ($toasters as $toast)
            {
                $string .= "\n toastr.options = " . json_encode($toast['options'], JSON_PRETTY_PRINT) . ";";

                $string .= "\n toastr['{$toast['type']}']('{$toast['message']}', '{$toast['title']}');";
            }

            $string .= "\n});";

            $string .= '</script>';
        }

        Session::forget('toasters');

        return new HtmlString($string);
    }
}

Esto funcionará como se muestra a continuación.

Toaster::success("Success Message", "Success Title")

    ->setOption('showDuration', 5000)

    ->warning("Warning Message", "Warning Title")

    ->error("Error Message");

Use PHP 7 ! Si su proveedor web no puede change > cambiar de proveedor ! No te quedes en el pasado.

class sAB
{
  static private $sep = '-';    
  static public function A()
  {
    echo 'A';
    return __CLASS__;
  }
  static public function B()
  {
    echo 'B';
    return __CLASS__;
  }
  static public function SEP()
  { 
    $argv = func_get_args();
    $argc = func_num_args();
    if( $argc == 1 ) self::$sep = $argv[0];
    echo self::$sep;
    return __CLASS__;
  }
  static public function success()
  {
    return self::$sep == ' ';
  }
}

Y uso muy simple:

if( sAB::B()::SEP()::A()::SEP(' - ')::B()::A()::SEP(' ')::success() )
{
  echo "That all.\n";
}

Retorno (o error de lanzamiento):

B-A - BA That all.

Contrato completado.

Regla uno : más evolucionado y mantenible es siempre mejor.