DEV Community: Dan Jones

golang: Understanding the difference between nil pointers and nil interfaces

Dan Jones — Mon, 24 Jun 2024 16:56:35 +0000

I was thinking a bit about the different ways in which nil works in go, and how sometimes, something can be both nil and not nil at the same time.

Here is a little example of something that can be a nil pointer, but not a nil interface. Let's walk through what that means.

Interfaces

First, go has a concept of interfaces, which are similar, but not quite the same as interfaces in some object-oriented languages (go is not OOP by most definitions). In go, an interface is a type that defines functions that another type must implement to satisfy the interface. This allows us to have multiple concrete types that can satisfy an interface in different ways.

For example, error is a built-in interface that has a single method. It looks like this:

type error interface {
    Error() string
}

Any type that wants to be used as an error must have a method called Error which returns a string. For example, the following code could be used:

type ErrorMessage string

func (em ErrorMessage) Error() string {
    return string(em)
}

func DoSomething() error {
    // Try to do something, and it fails.
    if somethingFailed {
        var err ErrorMessage = "This failed"
        return err
    }
    return nil
}

func main() {
    err := DoSomething()
    if err != nil {
        panic(err)
    }
}

Notice in this example that DoSomething returns an error if something goes wrong. We can use our ErrorMessage type, because it has the Error function, which returns a string, and therefore implements the error interface.
If no error occurred, we returned nil.

Pointers

In go, pointers point to a value, but they can also point to no value, in which case the pointer is nil. For example:

var i *int = nil

func main() {
    if i == nil {
        j := 5
        i = &j
    }
    fmt.Println("i is", *i)
}

In this case, the i variable is a pointer to an int. It starts out as a nil pointer, until we create an int, and point it to that.

Pointers and interfaces

Since user-defined types can have functions (methods) attached, we can also have functions for pointers to types. This is a very common practice in go. This also means that pointers can also implement interfaces. In this way, we could have a value that is a non-nil interface, but still a nil pointer. Consider the following code:

type TruthGetter interface {
    IsTrue() bool
}

func PrintIfTrue(tg TruthGetter) {
    if tg == nil {
        fmt.Println("I can't tell if it's true")
        return
    }
    if tg.IsTrue() {
        fmt.Println("It's true")
    } else {
        fmt.Println("It's not true")
    }
}

Any type that has an IsTrue() bool method can be passed to PrintIfTrue, but so can nil. So, we can do PrintIfTrue(nil) and it will print "I can't tell if it's true".

We can also do something simple like this:

type Truthy bool

func (ty Truthy) IsTrue() bool {
    return bool(ty)
}

func main() {
    var ty Truthy = true
    PrintIfTrue(ty)
}

This will print "It's true".

Or, we can do something more complicated, like:

type TruthyNumber int

func (tn TruthyNumber) IsTrue() bool {
    return tn > 0
}

func main() {
    var tn TruthyNumber = -4
    PrintIfTrue(tn)
}

That will print "It's not true". Neither of these examples are pointers, and so there's no chance for a nil with either of these types, but consider this:

type TruthyPerson struct {
    FirstName string
    LastName string
}

func (tp *TruthyPerson) IsTrue() bool {
    return tp.FirstName != "" && tp.LastName != ""
}

In this case TruthyPerson does not implement TruthGetter, but *TruthyPerson does. So, this should work:

func main() {
    tp := &TruthyPerson{"Jon", "Grady"}
    PrintIfTrue(tp)
}

This works because tp is a pointer to a TruthyPerson. However, if the pointer is nil, we'll get a panic.

func main() {
    var tp *TruthyPerson
    PrintIfTrue(tp)
}

This will panic. However, the panic doesn't happen in PrintIfTrue. You would think it's fine, because PrintIfTrue checks for nil. But, here's the issue. It's checking nil against a TruthGetter. In other words, it's checking for a nil interface, but not a nil pointer. And in func (tp *TruthyPerson) IsTrue() bool, we don't check for a nil. In go, we can still call methods on a nil pointer, so the panic happens there. The fix is actually pretty easy.

func (tp *TruthyPerson) IsTrue() bool {
    if tp == nil {
        return false
    }
    return tp.FirstName != "" && tp.LastName != ""
}

Now, we're checking for a nil interface in PrintIfTrue and for a nil pointer in func (tp *TruthyPerson) IsTrue() bool. And it will now print "It's not true". We can see all this code working here.

Bonus: Check for both nils at once with reflection

With reflection, we can make a small change to PrintIfTrue so that it can check for both nil interfaces and nil pointers. Here's the code:

func PrintIfTrue(tg TruthGetter) {
    if tg == nil {
        fmt.Println("I can't tell if it's true")
        return
    }

    val := reflect.ValueOf(tg)
    k := val.Kind()
    if (k == reflect.Pointer || k == reflect.Chan || k == reflect.Func || k == reflect.Map || k == reflect.Slice) && val.IsNil() {
        fmt.Println("I can't tell if it's true")
        return
    }

    if tg.IsTrue() {
        fmt.Println("It's true")
    } else {
        fmt.Println("It's not true")
    }
}

Here, we check for the nil interface first, as before. Next, we use reflection to get the type. chan, func, map, and slice can also be nil, in addition to pointers, so we check if the value is one of those types, and if so, check if it's nil. And if it is, we also return the "I can't tell if it's true" message. This may or may not be exactly what you want, but it's an option. With this change, we can do this:

func main() {
    var tp *TruthyPerson
    PrintIfTrue(tp)
}

You might sometimes see a suggestion to something simpler, like:

// Don't do this
if tg == nil && reflect.ValueOf(tg).IsNil() {
    fmt.Println("I can't tell if it's true")
    return
}

There are two reasons this doesn't work well. First, is that there is a performance overhead when using reflection. If you can avoid using reflection, you probably should. If we check for the nil interface first, we don't have to use reflection if it's a nil interface.

The second reason is the reflect.Value.IsNil() will panic if the type of the value isn't a type that can be nil. That's why we add in the check for the kind. If we hadn't checked the Kind, then we would've gotten a panic on the Truthy and TruthyNumber types.

So, as long as we ensure we check the kind first, this will now print "I can't tell if it's true", instead of "It's not true". Depending on your perspective, this may be an improvement. Here is the complete code with this change.

This was originally published on Dan's Musings

Accessing Private Properties in PHP without Reflection

Dan Jones — Tue, 13 Sep 2022 14:37:05 +0000

This post was originally published at Dan's Musings

I was discussing this technique during a code review recently, and I realized this cool technique might not be well known. I discovered it quite by accident a few years ago.

Sometimes, strictly for testing purposes, we might need to access a private or protected property or method. Our usual inclination is to use Reflection to do this. Reflection is a bit cumbersome, though, because there’s a lot of extra boilerplate to set it up.

But closures actually provide us with a cool way to do that much more easily. If you’ve ever used JavaScript’s bind method, we can do the same thing in PHP.

Let's start with a sample class:

class Person
{
    public string $name = 'Dan';
    protected int $age  = 40;
    private bool $cool  = true;

    protected static string $species = 'homo sapien';

    protected static function evolve(): void
    {
        static::$species = 'homo superior';
    }

    protected function birthday(): void
    {
        $this->age++;
    }

    public function howOldAmI(): int
    {
        return $this->age;
    }
}

$me = new Person();

Non-static properties

We know how to read and change $me->name. It's public, so there's no problem there.

Now, what if we need, somewhere in a test, to set the exact age. That's a protected property, so we can't just directly change it, but Closures can give us a way around that.

(fn (int $newAge) => $this->age = $newAge)->call($me, 30); // Changes $me->age to 30

So, what did we do here? Let's break it down a bit.

$changeAge = (fn (int $newAge) => $this->age = $newAge);

First, we create a closure that changes $this->age to whatever is passed to it. If we tried to do $changeAge(30), we'd get an error, though, because we defined this outside of the class. $this doesn't actually exist here, or, if we put this code in a unit test, $this would refer to the unit test class itself.

That's where call comes in. Closure::call binds a closure to a new object, and calls it with whatever args you passed to it. In other words, the first argument passed to call become the $this within the closure. Any other arguments are passed to the function itself.

$changeAge->call($me, 30);

We can also simply access the $age and $cool properties without changing them. So, I can do:

$amICool = (fn () => $this->cool)->call($me); // true
$myAge   = (fn () => $this->age)->call($me);

Static properties

That works great for the non-static properties or methods. What about the static ones?

$mySpecies = (fn () => static::$species)->bindTo(null, Person::class)(); // homo sapien
(fn () => static::evolve())->bindTo(null, Person::class)(); // Changes to homo superior
(fn (string $newSpecies) => static::$species = $newSpecies)->bindTo(null, Person::class)('homo erectus'); // devolve to homo erectus

So, this is a little different. First, we're using Closure::bindTo which returns a new closure, which has been re-bound to the specified object or class. With bindTo, you can pass an object (like call), or you can leave that null and pass a class instead, which changes the static binding. That's what we've done here. And since it returns a new closure, you then have to call it, which is why we have an extra () after.

So, let's break this down step-by-step as well.

$getSpecies = (fn () => static::$species);

A closure which returns that $species of the current scope.

$boundGetSpecies = $getSpecies->bindTo(null, Person::class);

A new closure, which changes the scope to Person, meaning any references to static refer to Person.

$mySpecies = $boundGetSpecies();

Or, if we to change the species to an arbitrary value, as we did in the third one:

// Create species changing closure, initially bound to the current scope
$changeSpecies = (fn (string $newSpecies) => static::$species = $newSpecies);
// Create a new Closure, bound to the Person scope
$changePersonSpecies = $changeSpecies->bindTo(null, Person::class);
// Change it to whatever
$changePersonSpecies('homo erectus');

Using `bindTo` with an object

You can use bindTo in a similar way to call.

(fn () => $this->birthday())->bindTo($me)();

Let's break it down.

$haveABirthday = (fn () => $this->birthday());

Closure which calls birthday() on the object within the current scope.

$haveMyBirthday = $haveABirthday->bindTo($me);

Create a new closure with $me as the scope. This way, any reference to $this refers to $me.

$haveMyBirthday();

Since $haveMyBirthday is a closure, we have to actually call it.

Conclusion

Sure, we can use ReflectionClass and ReflectionObject to do all of this, but this technique greatly simplifies it, since calling a single private method is a single line of code.

I actually use this in a package I recently wrote that should make this even easier.

And to reiterate, I do not recommend doing this in production code. There's a reason visibility exists. We shouldn't circumvent it like this in code on our server. But, if we need to fiddle around with some objects for testing, this technique can simplify that for us.

Use Laravel Events like Wordpress Hooks

Dan Jones — Tue, 21 Jun 2022 20:06:58 +0000

This post was originally published at Dan's Musings

Many web developers have worked with Wordpress at least somewhat. If you've done any plugin or theme development, there's a good chance you've used Wordpress hooks at some point.

If you've called add_action or add_filter, you've used a Wordpress hook. If you've called do_action or appy_filters, you've created your own hook.

If you've spent some time working with Wordpress, and are now working with Laravel, you might be wondering if Laravel has a hook system as well. You're in luck, using Laravel's event system, you can do the same sort of things that Wordpress's hook system can do, and we're going go over how to do that with a few code samples.

First off, lets talk about hooks in Wordpress.

Wordpress hooks

In Wordpress, hooks are a system that allow the developer to hook into an event, and add some functionality. Hooks come in two varieties: actions, and filters. Both types do essentially the same thing: when something happens in the system (or is about to happen), the action/filter is called. A developer building a plugin or theme can add functions that run on these events.

The difference between these two types of hooks have to do with the data is passed to the function, and the data that is returned from the function.

An action, is a function that returns nothing. In fact, if you add an action that returns a value, that value is ignored, and nothing happens with it.

A common example of an action is the built-in init action. This action is run early on in the request lifecycle. One possible use is by theme developers when registering custom post types.

This might look like this:

add_action( 'init', function () {
    register_post_type( 'book', [ 'public' => true ] );
} );

A filter is a function that returns a value that is intended to modify whatever value is passed to it.

A good example of a filter is the body_class filter. The function is passed an array of classes that are to be used in the <body class> attribute. The filter function should add to, or remove classes in the array, and then return the array.

This might look like this:

add_filter( 'body_class', function ( array $classes ) {
    $classes[] = 'i-love-hooks';

    return $classes;
} );

Now that we've got a refresher on Wordpress hooks, let's look at Laravel Events.

Laravel Events

In Laravel, Events serve the same purpose as Wordpress hooks: when something happens, an event is triggered, and the developer can respond to that event by performing some action. One important difference to remember between Wordpress hooks and Laravel Events are that in Wordpress, a hook has a name, and that's how you add your function to that hook, is by using the name. In Laravel, an event is an actual object which is instantiated. When you listen for that event (i.e., when you hook into it), you listen for events of a particular classname. In this way, Laravel is using more object-oriented programming.

Laravel has a number of built-in events, and any developer can create their own custom events. Let's look at how one might be used.

One event provided by Laravel is the QueryExecuted event. This event is executed whenever a database query is made. The event contains the query, and the amount of time (in milliseconds) that the query took to execute.

In Wordpress, you would add your hook listener during you plugin init function, or in your theme's functions.php file, usually. In Laravel, normally, you register an event listener in a service provider. You can use any service provider, by adding the following to the boot method:

use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\Event;
use App\Listeners\LogQueries;

public function boot() {
    Event::listen(QueryExecuted::class, LogQueries::class);
}

In this example, LogQueries is a listener class that contains a method called either handle or __invoke. This method will get an instance of the QueryExecuted class. It might look something like this:

use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\Log;

class LogQueries {
    public function handle(QueryExecuted $evt) {
        Log::debug("Executed {$evt->sql} in {$evt->time}ms");
    }
}

You can also listen using a Closure, similar to the Wordpress examples I gave before. Something like this could be done in the service provider:

use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Log;

public function boot() {
    Event::listen(function (QueryExecuted $evt) {
        Log::debug("Executed {$evt->sql} in {$evt->time}ms");
    });
}

There are other variations on how to do this. We won't be going into detail in these. Feel free to consult the official documentation.

Real-life (sort of) examples

For our examples, we're going to imagine we're building an e-book store using Laravel. So, first, lets establish a few models that we'll be using.

namespace App\Models;

class Customer {
    // ...
}

class Book {
    // ...
}

class Checkout {
    public function customer(): HasOne
    {
        return $this->hasOne(Customer::class);
    }

    public function books(): BelongsToMany
    {
        return $this->belongsToMany(Book::class);
    }
}

We have customers, books, and for when they are making a purchase, checkouts. The checkout has a relationship to the customer and the books in the cart.

Actions

As we discussed earlier, Wordpress has two types of hooks: actions and filters. It should be clear by now how to use Laravel Events in the same way as Wordpress actions. But, lets go over this using our store example.

Let's suppose our customer has already picked out their books, and added it to the cart. We have our Checkout model ready, called $checkout, and the customer has just pressed the "Check out" button on the site. We go through some logic to verify payment and shipping and whatnot, and everything's fine, so once that's all done, we can fire an event to indicate that checkout has completed.

We create this event with the command:

php artisan make:even CheckoutComplete

Our event class might look like this:

use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class CheckoutComplete
{
    use Dispatchable, SerializesModels;

    public Checkout $checkout;

    public function __construct(Checkout $checkout)
    {
        $this->checkout = $checkout;
    }
}

And then, we'd dispatch it like this:

use Illuminate\Support\Facades\Event;
use App\Events\CheckoutComplete;

Event::dispatch(new CheckoutComplete($checkout));

All of this might be similar, in Wordpress to the following:

do_action( 'checkout_complete', $checkout );

Obviously the Wordpress code is much shorter, but the Laravel code gives us more type-safety, and some more flexibility, since we can easily add whatever we want to that event model.

Listening for the event

All we've done so far is create an event and dispatch it. Now we hook into it by using a listener.

Let's suppose whenever a customer makes a purchase, they get one reward point for every book they purchased, and the points are redeemable for discounts in the future.

So, we use our CheckoutComplete event and create a listener that awards these points.

So, our listener can be as simple as:

use App\Events\CheckoutComplete;
use App\Service\RewardPoints;

class GiveRewardPoints
{
    protected RewardPoints $service;

    public function __construct(RewardPoints $rewardsService)
    {
        $this->service = $rewardsService;
    }

    public function handle(CheckoutComplete $checkout)
    {
        $service->award($checkout->customer, $checkout->books()->count());
    }
}

We register this listener, as we explained above, in a service provider like:

Event::listen(CheckoutComplete::class, GiveRewardPoints::class);

You can register as many listeners for an event as you like.

All of this might be something like the following in Wordpress.

function give_reward_points( array $checkout ) {
    $rewardsService->award( $checkout['customer_id'], count( $checkout['books'] ) );
}

add_action( 'checkout_complete', 'give_reward_points' );

Filters

Actions are easy, but filters are a little less obvious. To understand how we can use events like Wordpress filters, we need to note that since an event is an object with values on it, we can modify those values on the event. This gives us much more flexibility than Wordpress filters, which only give us the option of returning a new value.

For our example, let's suppose our customer has just entered their address information during checkout. We might need to do some validation on that address. Normally in Laravel, you would probably throw a ValidationException in this sort of case, but let's try something a little different.

First, we'll create a CheckoutAddressEntered event:

class CheckoutAddressEntered
{
    public Checkout $checkout;
    public Address $address;
    public array $errors = [];
}

We'll suppose that the $address object is some sort of data transfer object that just holds the address information. The implementation isn't important for our example.

Now, in our controller, we might have some logic like this:

$addressEntered = new CheckoutAddressEntered();
$addressEntered->checkout = $checkout;
$addressEntered->address = $address;

Event::dispatch($addressEntered);

if (count($addressEntered->errors)) {
    return new JsonResponse(['errors' => $addressEntered->errors]);
}

return new JsonResponse(['data' => $checkout]);

So, what did we do here exactly? We don't have any errors on $addressEntered here. Let's check out our listener.

class ValidateAddress
{
    public function __construct(protected AddressValidator $validator) { /**/ }

    public function handle(CheckoutAddressEntered $evt)
    {
        if (!$validator->validate($evt->address)) {
            $evt->errors[] = 'Address validation failed';
        }
    }
}

So, in our listener, we validated the address, and if it failed, we appended to the errors array with a failure message. When we called Event::dispatch, our listeners were run with the same $addressEntered object being passed to the listener. Each non-queued listener is run before Event::dispatch finishes, so, any changes made to the event are carried over.

If we were to implement this in Wordpress, it might look like this:

$errors = apply_filters( 'checkout_address_entered', [], $address, $checkout );
if ( count( $errors ) ) {
    wp_send_json_error( $errors, 400 );
} else {
    wp_send_json_success( $checkout );
}

And then, our callback would be:

function validate_address( array $errors, array $address, array $checkout ) {
    if ( ! $addressValidator->validate( $address ) ) {
        $errors[] = 'Address validation failed';
    }
}

add_filter( 'checkout_address_entered', 'validate_address', 10, 3 );

We might have another listener that checks that all of the books purchased can be legally sold in the customer's country.

One very important thing to note is that for this to work properly, the listener cannot be a queued listener. If it is, the validation will happen outside of the request, after the response has already been sent to the client. If you used the make:listener artisan command to create the listener class, you'll need to remove the ShouldQueue trait from that class.

Conclusion

If you're coming from Wordpress to Laravel, there are a lot of new things to learn. With hooks being such an integral part of Wordpress, hopefully learning how Laravel events work will help make that transition.

nave vs nvm for node version management

Dan Jones — Fri, 09 Aug 2019 16:46:08 +0000

I recently discovered nave. I found it on npm's installation page.

It's a node version manager, which means that it allows you to install and use multiple versions of node on your machine.

It's similar to nvm, which I've been using for quite a while, and I imagine many of you have as well.

The main difference is that nvm generally requires you to modify your current shell. You have to modify your .bashrc file to ensure that it loads properly. nave doesn't require you to add anything to your shell. You just download the script and put it anywhere in your current $PATH and it's ready to use.

To use it, you do nave use <version>, and it opens a new shell with the path for <version> added to $PATH. When you're done, you just exit, and you're back to your regular shell without that node version.

If you'd like, nave can work more like nvm, and you can add it to your .bashrc and it can be used to modify your current shell, but it's not required.

nvm also has issues when used when $PREFIX is set. However nave creates a subshell which adds the node version you need to your $PATH. I've been unable to use nvm in Termux on my phone because of the issue with $PREFIX. Others have had issues using nvm on MacOS when also using brew for the same reason.

I installed nave on my desktop, and manually set a PREFIX in my shell, and nave still worked with no problems.

I've still been unable to use nave on my phone, because, due to the fact that Termux is based on Busybox, the precompiled binaries can't be used in Termux, so node must be compiled. Unfortunately, another dependency issue causes the compilation to fail, but I'm hopeful that issue can get resolved and I'll be able to use nave for node development on my phone.

Speaking of Busybox, nvm states that on Alpine Linux, which is based on Busybox, you have to specify nvm install -s version to tell it to compile from source, since, as I mentioned, the precompiled binaries won't work.

On my phone under Termux,nave automatically saw that it needed to download the source and compile, so I just did nave install latest and it fetched the source for the latest version and attempted to compile, while on my desktop, it fetched the binaries. So, nave seems a bit smarter than nvm in that regard.

However, with regards to Alpine, I did try to use nave under Alpine. I spun up an Alpine docker container. It took a while to install the necessary packages for it to work. I needed bash, curl, and perl-utils, and maybe a couple more. I also had to change my shell to bash. After that, I did nave install latest, thinking that it would download the source and compile, like it did under Termux. It didn't. It downloaded the binary. And after that, doing nave use latest opened a new shell, but node --version wouldn't work, because of the aforementioned reasons. nave doesn't provide a flag to force source install like nvm, so I had to run env NAVE_SRC_ONLY=1 nave install latest. I then had to install a few more packages so that compilation would work, like g++, make, linux-headers, and python(?). After (finally) compiling, it worked as expected.

However, it would be nice for it to detect that the precompiled binaries didn't actually work. This leads me to believe that it was something other than nave being smarter that it compiled on Android under Termux. It could just be that it just didn't realize that an aarch64 architecture is the same as arm64.

In any case, on the desktop in a traditional Linux distro, I'm finding nave really nice so far, and I'll be using it for a little while to see if I like it better than nvm.

P.S. Since I have both nvm and nave installed now, to avoid clashes, I modified my .bashrc so that it doesn't use nvm if I'm in a nave-launched subshell.

Here's my code:

# No point using two different node installers
if [[ -z "$NAVE" ]]; then
    export NVM_DIR="$HOME/.nvm"
    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
    [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion
fi

DEV Community: Dan Jones

golang: Understanding the difference between nil pointers and nil interfaces

Interfaces

Pointers

Pointers and interfaces

Bonus: Check for both nils at once with reflection

Accessing Private Properties in PHP without Reflection

Non-static properties

Static properties

Using bindTo with an object

Conclusion

Use Laravel Events like Wordpress Hooks

Wordpress hooks

Laravel Events

Real-life (sort of) examples

Actions

Listening for the event

Filters

Conclusion

nave vs nvm for node version management

Using `bindTo` with an object