Method Chaining in PHP: A Complete Guide

When writing PHP applications, clean and readable code is just as important as performance. One powerful design pattern that makes code elegant is method chaining. This pattern is widely used in frameworks like Laravel, CodeIgniter, Symfony, and even in modern libraries.

In this article, we’ll explore what method chaining is, how it works in PHP, and why you should use it.

🧐 What is Method Chaining?

Method chaining is a technique where you call multiple methods on the same object in a single line. Each method returns the object itself ($this), allowing another method to be called immediately.

Instead of:

$user = new User();
$user->setName("John");
$user->setAge(25);
$user->setCountry("India");

You can write:

$user = (new User())->setName("John")->setAge(25)->setCountry("India");

This approach is cleaner and more readable.

⚙️ How Does It Work?

The secret lies in returning $this (the current object) from every method you want to chain.

🧑‍💻 Example 1: Simple Method Chaining

class Person {
    private $name;
    private $age;
    private $country;

    public function setName($name) {
        $this->name = $name;
        return $this; // return current object
    }

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

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

    public function getDetails() {
        return "Name: {$this->name}, Age: {$this->age}, Country: {$this->country}";
    }
}

// Usage
echo (new Person())->setName("John")->setAge(25)->setCountry("India")->getDetails();

👉 Output:

Name: John, Age: 25, Country: India

🧑‍💻 Example 2: Query Builder Style

This is how frameworks like Laravel implement method chaining for database queries.

class QueryBuilder {
    private $table;
    private $columns = "*";
    private $conditions = "";

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

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

    public function where($condition) {
        $this->conditions = "WHERE " . $condition;
        return $this;
    }

    public function get() {
        return "SELECT {$this->columns} FROM {$this->table} {$this->conditions}";
    }
}

// Usage
$sql = (new QueryBuilder())
        ->table("users")
        ->select("id, name, email")
        ->where("id = 5")
        ->get();

echo $sql;

👉 Output:

SELECT id, name, email FROM users WHERE id = 5

🔗 Static Method Chaining

Static method chaining is also possible by returning an instance of the class inside a static method.

class Calculator {
    private $value;

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

    public static function start($value = 0) {
        return new static($value);
    }

    public function add($num) {
        $this->value += $num;
        return $this;
    }

    public function get() {
        return $this->value;
    }
}

// Usage
echo Calculator::start(10)->add(5)->get(); // Output: 15

✅ Advantages of Method Chaining

1. Cleaner Code – Removes repetition of the object variable.

2. Readability – Looks like natural language.

3. Fluent Interface – Lets you design APIs that are intuitive.

⚠️ Things to Watch Out For

• Debugging is harder if one method in the chain fails.

• Not all methods should return $this (e.g., a get() method usually returns data instead).

• Overusing chaining may make code harder to maintain if logic is too complex.

⚡ Real-World Usage

If you’ve ever written Laravel code, you’ve already used method chaining:

$users = User::where("status", "active")
             ->orderBy("name")
             ->get();

Here:

• where() and orderBy() return the query builder object.

• get() finally executes the query and returns the result.

🎯 Conclusion

Method chaining is a simple but powerful design pattern in PHP. It makes your code more concise, readable, and elegant. Whether you’re designing a class for configuration, a query builder, or even a calculator, method chaining will give your code a fluent interface style.

If you’re working with frameworks like Laravel, CodeIgniter, or Symfony, understanding method chaining will make your development experience much smoother.