调用 PHP 上的链式方法

Question

I call an object that returns an array given certain chained methods:

Songs::duration('>', 2)->artist('Unknown')->genre('Metal')->stars(5)->getAllAsArray();

The problem lies that every time I want to get this array, for example, in another script, I have to chain everything again . Now imagine that in over 10 scripts.

Is there a way to recall the chained methods for later use?

Answer 1

If you can not cache your results as suggested, as I commented, here are a couple ideas. If your application allows for mixing of functions (as in you are permitted by standards of your company's development rules) and classes, you can use a function wrapper:

// The function can be as complex as you want
// You can make '>', 2 args too if they are going to be different all the time
function getArtists($array)
    {
        return \Songs::duration('>', 2)->artist($array[0])->genre($array[1])->stars($array[2])->getAllAsArray();
    }

print_r(getArtists(array('Unkown','Metal',5)));

If you are only allowed to use classes and __callStatic() is not forbidden in your development and is also available in the version of PHP you are using, you might try that:

// If you have access to the Songs class
public __callStatic($name,$args=false)
    {
        // This should explode your method name
        // so you have two important elements of your chain
        // Unknown_Metal() should produce "Unknown" and "Metal" as key 0 and 1
        $settings = explode("_",$name);
        // Args should be in an array, so if you have 1 value, should be in key 0
        $stars = (isset($args[0]))? $args[0] : 5;
        // return the contents
        return self::duration('>', 2)->artist($settings[0])->genre($settings[1])->stars($stars)->getAllAsArray();
    }

This should return the same as your chain:

print_r(\Songs::Unknown_Metal(5));

It should be noted that overloading is hard to follow because there is no concrete method called Unknown_Metal so it's harder to debug. Also note I have not tested this particular set-up out locally, but I have notated what should happen where.

If those are not allowed, I would then make a method to shorten that chain:

public function getArtists($array)
    {
        // Note, '>', 2 can be args too, I just didn't add them
        return self::duration('>', 2)->artist($array[0])->genre($array[1])->stars($array[2])->getAllAsArray();
    }

print_r(\Songs::getArtists(array('Unkown','Metal',5)));

Answer 2

Since you can't cache the result, you could cache the structure of the call chain in an array.

$chain = [
    'duration' => ['>', 2],
    'artist' => 'Unknown',
    'genre' => 'Metal', 
    'stars' => 5,
    'getAllAsArray' => null
];

You could use that with a function that emulates the chained call using the cached array:

function callChain($object, $chain) {
    foreach ($chain as $method => $params) {
        $params = is_array($params) ? $params : (array) $params;
        $object = call_user_func_array([$object, $method], $params);
    }
    return $object;
}

$result = callChain('Songs', $chain);

Answer 3

I wrote a lib doing exactly what you're looking for, implementing the principle suggested by Don't Panic in a high quality way: https://packagist.org/packages/jclaveau/php-deferred-callchain

In your case you would code

$search = DeferredCallChain::new_(Songs::class)  // or shorter: later(Songs::class)
    ->duration('>',2)   // static syntax "::" cannot handle chaining sadly
    ->artist('Unknown')
    ->genre('Metal')
    ->stars(5)
    ->getAllAsArray();

print_r( $search($myFirstDBSongs) );
print_r( $search($mySecondDBSongs) );

Hoping it will match your needs!