Forem: Steven Yung

Laravel Greatest Trick Revealed: Magic Methods

Steven Yung — Mon, 15 Apr 2019 10:51:06 +0000

Photo by Mervyn Chan on Unsplash

Laravel has leverage PHP to a whole new level, providing awesome Developer Experience (DX) to craft your next project. As a result, some people qualify it as "magic".

Today, I will reveal to you one of Laravel tricks, magic methods.

What is a magic method ?

It's important to understand that magic methods are not exclusive to Laravel but are available in any PHP application that you have. Laravel just happens to have some of the most interesting use cases for magic methods.

Magic methods are methods available in any classes that you declare in PHP which provide way to implement additional functionality in your class.

Here a good definition:

magic methods will never directly be called by the programmer – actually, PHP will call the method 'behind the scenes'. This is why they are called 'magic' methods – because they are never directly called, and they allow the programmer to do some pretty powerful things.

There are in total 15 magic methods:

class MyClass
{
    public function __construct() {}

    public function __destruct() {}

    public function __call() {}

    public function __callStatic() {}

    public function __get() {}

    public function __set() {}

    public function __isset() {}

    public function __unset() {}

    public function __sleep() {}

    public function __wakeup() {}

    public function __toString() {}

    public function __invoke() {}

    public function __set_state() {}

    public function __clone() {}

    public function __debuginfo() {}
}

If you've done some Object Oriented Programming with PHP, you will certainly recognise the __construct method which is also a magic method. So you've been using magic methods all along!

You will also notice that all the magic methods are prefixed with __ as a convention.

Today, we will not dive in all of them, but only the interesting ones used across the Laravel codebase. If you are interested by others, feel free to check the documentation below 👇

PHP: Méthodes magiques - Manual

How Laravel uses magic methods

`__get()`

The models in Laravel are really special. They don't store the attributes data as direct attributes of the class but in an attribute protected $attributes , which is an associative array of all the data the model is holding.

Let see the differences between a simple PHP class and a Laravel model accessing attributes.

<?php

/**
 * A normal user class in PHP (without Laravel) will be just a class with the said attributes
 */
class NormalUser
{
    public $firstName = 'Alice';
}

$normalUser = new NormalUser;

$normalUser->firstName; // Will return 'Alice'

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

/**
 * A user class in Laravel
 */
class LaravelUser extends Model
{
    /**
     * Note that we store all the attributes data in one and single array
     */
    protected $attributes = [
        'firstName' => 'Alice',
    ];
}

$laravelUser = new LaravelUser;

$laravelUser->firstName; // Will return 'Alice' as well

We can see that both PHP and Laravel classes above act exactly the same. Nevertheless, in the case of Laravel, the attributes are not stored like in plain PHP and instead all the attributes are centralised in one attribute named $attributes. Still we manage to access the right data but how ?

This is all possible because of the __get magic method. Let's try to implement our own simplify version of this in an example.

<?php

class NormalUser
{
    /**
     * We declare the attributes that same way as in Laravel
     */
    protected $attributes = [
        'firstName' => 'Alice',
    ];

    /**
     * The function __get receive one parameter
     * which will be the name of the attribute you want to access
     * in this case $key = "firstName"
     */
    public function __get(string $key)
    {
        return $this->attributes[$key];
    }
}

$normalUser = new NormalUser;

$normalUser->firstName; // Will return 'Alice'

We did it! 🎉

We need to note that the magic method __get will only be called when no attribute with the matching name are found in the class. It's sort of a fallback method called when PHP doesn't find the asked attribute in the class. So in the example below, the magic method __get will not be called at all.

<?php

class NormalUser
{
    public $firstName = 'Bob';

    protected $attributes = [
        'firstName' => 'Alice',
    ];

    public function __get($key)
    {
        return $this->attributes[$key];
    }
}

$normalUser = new NormalUser;

/**
 * Will return 'Bob' as the attribute exists in the class
 * so the magic method __get doesn't get call in this case
 */
$normalUser->firstName;

There is way more things happening behind the scene. If you want to dig more how exactly Laravel's models uses __get you can check the source code below.

laravel/framework

`__set()`

The magic method __set is used when the attribute trying to be set is not declared in the class. Let's see the difference again between a normal PHP class and a model in Laravel.

<?php

class NormalUser
{
    public $firstName = 'Alice';
}

$normalUser = new NormalUser;

$normalUser->firstName = 'Bob';

$normalUser->firstName; // Will return 'Bob'

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class LaravelUser extends Model
{
    protected $attributes = [
        'firstName' => 'Alice',
    ];
}

$laravelUser = new LaravelUser;

$laravelUser->firstName = 'Bob';

$laravelUser->firstName; // Will return 'Bob' as well

As we can see, in this example we still try to affect the value Bob to an attribute that doesn't really exist in the class but lives inside the attribute $attributes . Let's try to implement that exact behaviour with the magic method __set.

<?php

class NormalUser
{
    public $attributes = [
        'firstName' => 'Alice',
    ];

    /**
     * The magic method __set receives the $name you want to affect the value on
     * and the value
     */
    public function __set($key, $value)
    {
        $this->attributes[$key] = $value;
    }
}

$normalUser = new NormalUser;

$normalUser->firstName = 'Bob';

/**
 * As we don't have the __get magic method define in this example for simplicity sake,
 * we will access the $attributes directly
 */
$normalUser->attributes['firstName']; // Will return 'Bob'

And here we go! We successfully implemented the basic usage of the __get and __set magic methods in Laravel! And all it took was a few lines of code!

Keep in mind that those magic methods are as simple as possible without entering into too much details as there is more to it than just those use cases, if you are curious about how exactly it's working I invite you to dive into the code yourself for some exploring! (also feel free to hit me up on Twitter if you have any questions)

Again, if you want to dig more, here the link to the source code

laravel/framework

Let's move on to the last and most interesting case! 🙌

`call()` & `callStatic()`

__call is executed when a method was called but not found in a specific class. In Laravel, this magic method is what is making macros possible in PHP.

I'm not going into all the details on macro but if you interested here is a good article explaining how you can use them in your Laravel application 👇

The Magic of Laravel Macros

Let's try to see how we could reproduce a simple macro example in plain PHP.

<?php

class NormalUser
{
    public $firstName = 'Alice';

    public $lastName = 'Bob';
}

$normalUser = new NormalUser;

$normalUser->fullName(); // This will throw an error as no method "fullName" has been declared.

Now with __call , we could define an array which will contain closures function that we will be able to add programmatically in our app as we go.

<?php

class NormalUser
{
    public $firstName = 'Alice';

    public $lastName = 'Bob';

    /**
     * We initialise our macros as an empty array that we will fill
     */
    public static $macros = [];

    /**
     * We define this method to add new macro as we go
     * the first argument will be the name of the macro we want to define
     * the second will be a Closure function that will be executed when calling the macro
     */
    public static function addMacro($name, $macro) {
        static::$macros[$name] = $macro;
    }

    /**
     * "__call" receives two parameters,
     * $name which will be the name of the function called in our case "fullName"
     * $arguments which will be all the arguments passed in the function in our case it'll just be an empty array as we can't pass any arguments in our function
     */
    public function __call(string $name, array $arguments) {
        /**
         * We retrieve the macro with the right name
         */
        $macro = static::$macros[$name];
        /**
         * Then we execute the macro with the arguments
         * Note: we need to bind the Closure with "$this" before calling it to allow the macro method to act in the same context
         */
        return call_user_func_array($macro->bindTo($this, static::class), $arguments);
    }
}

$normalUser = new NormalUser;

$normalUser->fullName(); // This will still break as we didn't define the macro "fullName" yet and the method "fullName" doesn't exist either

/**
 * We add the macro function "fullName"
 */
NormalUser::addMacro('fullName', function () {
    return $this->firstName.' '.$this->lastName;
});

$normalUser->fullName(); // Now, returns "Alice Bob"

Macros are a little more complex than that but again, we manage to create a simple working version of the macros by using __call magic method.

__callStatic works exactly the same as __call but for static methods.

Again if you want to dig a little bit more on your own, here is the Macroable trait source code

laravel/framework

Final take

Here you go Ladies and Gentlemen, while it is somewhat true that Laravel feels magic when you first start using it, by looking into the source code itself, you can understand how the "magic" operate behind the scene.

Like magic in real life, nothing really happens without an explanation and that's even truer in code. There is always a line of code doing the work somewhere, you just have to find it.

I encourage you to dig more into Laravel to make the magic disappear and don't forget to share your nuggets with me on Twitter!

This blog post was originally posted on my personal blog, please give it a hug 🤗

Special Thanks: Samuel, Jean-Baptiste and Jessica

Be good at one thing, not average at everything

Steven Yung — Wed, 10 Jan 2018 13:20:50 +0000

(Credit to Jessica for the photo)

The web is constantly evolving and improving over time and there is already so much to learn and much more as time goes by.

For any newcomers, this is pretty scary, and it becomes quickly overwhelming.

I started as a working student in a web agency 2 years ago with no concrete experience and not a clue how real web development was done. My first day, I was excited to discover new things but mostly afraid by the daunting task ahead of me.

The worst part (or best, depending on whether you are a half-full or half-empty glass kind of person) is that the more you discover about the various aspects of web development, the more you realize how little you actually know.

Trying to learn everything

One of the most common pitfalls that new developers fall into is trying to understand and do a lot because, let's admit it, everybody seems ahead of you and the level you have to reach to be "good" seems further and further away.

As a developer, it’s pretty easy to lose focus and get caught on "The Shiny Object Syndrome". The grass is always greener on the other side of the fence and programming is no exception as there is always new ways to build stuff, one more exciting than the other.

During my first year, I started learning on my free time to improve as a Symfony developer, but I lost my focus trying to play with everything I could get my hands on. From C compiler to Node.js. I learned everything but Symfony because anything else was new and more exciting.

And I could have gone on, and on, and on, and on for as long as new trends were popping out on Github. I spent countless hours watching, reading, learning and breathing code.

In hindsight, I spread my focus too thin. Learning is never a waste of time, of course. It's always good to try out new technology and be aware of the new trending things in your ecosystem at the moment.

However, you really start pushing your limit and the limit of your tools when you focus on one thing: one framework, one language, one project, etc. And you will get deeper knowledge along the way.

From average at everything to good at one thing

"Success demands singleness of purpose. You need to be doing fewer things for more effect instead of doing more things with side effects." - The ONE Thing by Gary Keller

(I highly recommend reading The ONE Thing by Gary Keller not your usual programming book but incredibly interesting and eye-opening)

During my last year as a working student, I started shifting the way I was seeing "improvement" from "The more technologies and languages I know, the better I am" mentality to "The better I understand the technologies and languages I already know, the better I am".

So I focused on what little I already knew: back-end development in PHP. Back-end development with Laravel to be precise.

Soon after understanding the basics and getting a general feel of the framework, I focused more on building things with my current knowledge instead of learning the next trending thing on GitHub.

I started building stuff, useful stuff (at least, useful for me) and that's when I started realizing, I kept learning new things, but instead of learning to use new tools, I learned to get the best out of those I already had.

I've improved my code reusability, started using design patterns, implemented core concepts like DRY and SOLID in my codebase, learned about Test-Driven-Development, etc.

Overall, I became a better PHP back-end developer but also a better developer in general. Because, when you learn and become fluent with your tools, that's when you start learning programming beyond the framework or language and start implementing general concept which will be universal to any technology you know.

As I made my way and became an okay-ish Laravel developer, I also started my own business as a Laravel freelance developer, and to focus on what I knew and keep improving, I would work on the back-end of any project and send any front-end or not suitable work to another freelancer.

That way, I really focused my attention on one thing at a time while still moving my freelance skill forward and I wasn't limited to my own knowledge to work on a project. I could keep doing and improve what I knew while learning some valuable lessons outside of programming like project management and remote teamwork.

An incremental approach to learning

When you reach the point where you feel confident about your ability to use your current tools, you can start incrementally implementing new skill into your developer portfolio, but not a random skill, in the best case scenario a skill that will complete yours, the goal remains the same, "become better with what you already know" and you can achieve that with complementary skill.

The final goal is to always learn with the purpose of improving current knowledge to improve as a whole. And with this approach, you can easily start using your current stack and implement what your new tool is.
For me, it was learning Vue.js to work toward a more full-stack developer profile for my freelance activity.
For back-end developer, it could be adding server administration to his portfolio to understand how to implement a full web app on his own.
For a front-end developer, setup and use PostCSS to improve code quality and his workflow.

The options are endless and the goal is always the same: improve your strength toward a specific goal.

Like this article? Want to see what I'm up to? You can follow me on Twitter, Instagram and Github

Special thanks to: Abdoulaye, Samuel and Jean-Baptiste

Forem: Steven Yung

Laravel Greatest Trick Revealed: Magic Methods

What is a magic method ?

How Laravel uses magic methods

__get()

__set()

__call() & __callStatic()

Final take

Be good at one thing, not average at everything

Trying to learn everything

From average at everything to good at one thing

An incremental approach to learning

`__get()`

`__set()`

`call()` & `callStatic()`