Calling member function on array

Question

I don't truly understand how chaining functions work on the values that are returned.

Let's say I have a function that returns a string or array

public static $query; 

public static function getArray($arr) {
     Database::$query = $arr;
     return Database::$query;
}

public function single() {
    return Database::$query[0];
}

Why, when I call it can I then not chain a function onto this to affect the string (In this example I was to append ' test' and how would I go about doing this?

Why can I simply not call

Database::getArray(array("test","test2"))->single();

Without getting a Call to a member function single() on array error. But instead, make it return only the first value of the array.

How would I go append doing what I'm trying to achieve here? Why is my logic wrong?

Answer 1

When you call a method, the return value is whatever that method decides to return; the return value doesn't have any automatic relationship with the object you called the method on. For instance:

class A {
    public function foo() {
        return 'Hello, World!';
    }
}
$a = new A;
echo $a->foo();

The value returned is just an ordinary string, just as if foo was a global function not attached to any object.

In PHP, strings (and other "basic types" like arrays) are not objects, so you can't call any methods on them. Even if you could, those methods would be built into the language, and you couldn't just decide that ->single() could be called on any array.

What may be confusing is that some people write methods with the convention that they return an object, known as a "fluent interface", or more generally "chained methods". This is not a feature of the language, just a natural consequence of returning an object from a method:

class A {
    public function foo() {
        return new B;
    }
}
class B {
    public function bar() {
         return 'Hello, World!';
    }
}
$a = new A;
$b = $a->foo(); // $b is a B object
echo $b->bar();
// We can combine this into one line:
echo (new A)->foo()->bar();

There is nothing special about this chaining; it's just that wherever you have an object, you can call appropriate methods on it, just as wherever you have a number, you can do maths with it. Compare with a simple addition:

function foo() {
    return 1;
}
$a = foo();
$a = $a + 2;
echo $a;
// We can combine this into one line:
echo foo() + 2;
// Or keep the assignment:
$a = foo() + 2;
echo $a;

The object doesn't know it's being chained - in fact, it shouldn't need to know anything about the code around it, and that's an important part of structured programming.

A common pattern is then to have modifying methods which return the object they just modified, so you can make a series of modifications in one go:

class A {
     private $words = [];
     public function addWord($word) {
         $this->words[] = $word;
         // $this is the current object, which is an instance of class A
         return $this;
     }
     public function getString() {
         return implode(' ', $this->words);
     }
 }
 $a = new A;
 // Calling $a->addWord(...) gives us back the same object
 $a = $a->addWord('Hello');
 $a = $a->addWord('World');
 // Calling $a->getString() gives us back a string
 echo $a->getString();

 // We can combine this into one line:
 echo (new A)->addWord('Hello')->addWord('World')->getString();

Note that you can only refer to $this if you have created an instance of the object (with the new keyword), not in a method declared as static. A static method can still have this kind of pattern, but it will need to return some other object, like new self (a new instance of the current class) or self::$foo (an object created earlier).

Answer 2

it's called fluent interface, if you want to chain methods from same class you have to return this from each of them which you want to call fluently, so your code should look like:

public static $query; 

public function getArray($arr) {
     Database::$query = $arr;
     return $this;
}

public function single() {
    return Database::$query[0];
}

after applying changes, the construct Database::getArray(array("test","test2"))->single(); will work, however you may consider renaming method getArray, because as its name suggests, it shouldn't be returning $this, but array

@EDIT

you should change the type of function getArray from public static function to public function to make it work, also your final statement will change to something like:

(new Database())->getArray(array("test","test2"))->single();

however, in this case, I would consider redesigning your class and creating some kind of singleton so that you instantiate Database class only once and store the object somewhere