DEV Community: Liam Hammett

A Look At PHP's isset()

Liam Hammett — Sat, 08 Jun 2019 16:29:15 +0000

isset() is one of the most important tools at your disposal to validate data in PHP. Like the name implies, it is designed to verify if a variable given to it is set, returning a boolean value based on the result.

However, it has some quirks and behaviours that are very much worth knowing as they can easily catch out even experienced developers.

Let's take a look through how it behaves and what's so special about it. Even if you're a veteran PHP developer, hopefully, you'll pick up something new here.

It's a language construct, NOT a function

Despite looking like one, isset() is actually NOT a typical function as you might expect.

Just like die(), array(), print() and others, it is a "language construct", which is a fancy term that, in laymen's terms, means it's built directly into the PHP engine and can have some special behaviour that is different than typical built-in or user-defined functions, which we will go over next.

It can not be used as a callable

Any built-in or user-defined function can be used as a "callable" function pointer to be invoked dynamically and used for patterns like currying.

is_callable('strtoupper');
// true

array_map('strtoupper', ['a', 'b', null, 'd']);
// ['A', 'B', '', 'D']

As it is a language construct and not really a function, it is not callable and cannot be used in such a way.

is_callable('isset');
// false

array_map('isset', ['a', 'b', null, 'd']);
// PHP Warning:  array_map() expects parameter 1 to be a valid callback, function 'isset' not found or invalid function name…

It does not accept an expression

While regular functions and other language constructs can accept the result of any expression, due to its unique nature, isset() can only accept a variable, array key or object property as an argument.

Attempting to use it any other way will result in a fatal error.

if (isset('Hello world')) {
    // Fatal error: Cannot use isset() on the result of an expression (you can use "null !== expression" instead)
}

if (isset($a->b())) {
    // Fatal error: Cannot use isset() on the result of an expression (you can use "null !== expression" instead)
}

if (isset(! $a)) {
    // Fatal error: Cannot use isset() on the result of an expression (you can use "null !== expression" instead)
}

if (isset(CONSTANT)) {
    // Fatal error: Cannot use isset() on the result of an expression (you can use "null !== expression" instead)
}

It also checks if a value is `null`

isset() will return false if a variable is undefined OR if its value is null. This may throw you off if null is a proper value you have set and want to allow.

$value = null;

if (isset($value)) {
    // ...
}

One way to go about checking this, depending on your requirements, is to check if a variable is defined in the current scope with get_defined_vars() and examining the resulting array's keys.

$value = null;

if (array_key_exists('value', get_defined_vars())) {
    // ...
}

It can accept multiple arguments

It's very common to see people chaining calls together to check that multiple values are set one-by-one.

if (isset($a) && isset($b) && isset($c)) {
    // ...
}

However, isset() is a variadic function that can accept any number of parameters at once to achieve the same effect, confirming if all of the passed variables are set.

This can be a great way to shorten long conditionals.

if (isset($a, $b, $c)) {
    // ...
}

It does not trigger "undefined variable/index/property" notices

If you're retrieving a value nested multiple levels deep, you probably want to make sure every step of the chain exists.

if (isset($response, $response->list, $response->list['results'], $response->list['results'][0])) {
    // ...
}

if (isset($arr[$key], $otherArr[$arr[$key]], $otherArr[$arr[$key]][$otherKey])) {
    // ...
}

However, isset() will not trigger any "undefined variable", "undefined index" or "undefined property" notices, no matter how many layers you go through.

This means that instead of confirming the value at every individual step, they can all be done in a single check:

if (isset($response->list['results'][0])) {
    // ...
}

if (isset($otherArr[$arr[$key]][$otherKey])) {
    // ...
}

"Undefined method" errors do get triggered

If a chain being checked happens to include a method call halfway through it, PHP will attempt to invoke the method.

This means that if an earlier part of the chain does not exist, or the last value in the chain is an object that simply does not have this method, an error will still be triggered.

$a = new stdClass();

if (isset($a->b()->c)) {
    // Fatal error: Uncaught Error: Call to undefined method A::b()…
}

if (isset($a->b->c())) {
    // Fatal error: Uncaught Error: Call to a member function d() on null…
}

One way to deal with this is to be explicit in your conditional checks, stopping the chain and calling method_exists() to verify the method exists every time it is needed.

if (isset($a) && method_exists($a, 'b') && isset($a->b()->c)) {
    // ...
}

One way to shorten such an expression is to use the error control operator, which suppresses any errors for a single expression. If an error is triggered, the operator will make the expression return null instead and continue the execution.

if (@$a->b()->c !== null) {
    // ...
}

However, while this may be convenient, you should be aware that the error control operator is very inefficient and can also suppress errors triggered within the called methods you call and are not intending to suppress. It is not an outright replacement for isset().

!empty() is not quite the same

[empty()](https://www.php.net/manual/en/function.empty.php) is also a language construct with similar behaviour to isset() in that it doesn’t trigger undefined notices.

$a = [];

if (empty($a['b']->c)) {
   // ...
}

It seems as if it serves as a direct inverse of isset(), but this is not the case. empty() can also accept expressions as its arguments, but more importantly, it will type juggle so that any falsey value is treated as such.

$a = '0';

if (isset($a)) {
    // It IS set
}

if (empty($a)) {
    // It IS empty
}

Null coalesce operator

It is a very common occurrence to want to provide a fallback value in case a variable is not set. This is typically done with a short conditional if statement or ternary clause.

$result = isset($value) ? $value : 'fallback';

As of PHP 7.0, this can be shortened using the null coalesce operator (??) which will return the first value if it is set, or the second value if not.

$result = $value ?? 'fallback';

If instead of returning a new value, you didn't want to set a new variable doing this, that is covered as well. As of PHP 7.4, the null coalesce assignment operator (??=) allows an even shorter way to set a variable to a fallback if it isn't already set.

$value ??= 'fallback';

It does not evaluate the `__get()` magic method

Let's assume we have a pretty typical class that can dynamically get properties by using the magic method __get() to retrieve a value.

class Person
{
    protected $attributes = [];

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

    public function __set($name, $value)
    {
        $this->attributes[$name] = $value;
    }
}

If we use this class to set a property, we can make use of it as we might normally expect. However, if we check if the value is set, it will return false

$person = new Person();
$person->name = 'Liam';

echo $person->name; // 'Liam'

isset($person->name); // false

Wait, what's going on here?!

Because isset() is a language construct and not a regular function, the expression doesn't get evaluated before it's passed to it. Because name isn't a real property on the object, it doesn't really exist.

However, when isset() gets called on a property that doesn't exist or is inaccessible to the current scope (such as being protected or private), it will invoke a magic __isset() method if the class has one defined. This allows for custom logic to be done to determine if we think the property we're checking is set according to our own rules.

class Person
{
    // ...

    public function __isset($name)
    {
        return isset($this->attributes[$name]);
    }
}

With that implemented, everything works as expected.

$person = new Person();
$person->name = 'Liam';

isset($person->name); // true
isset($person->somethingElse); // false

It is important to note that if you are checking nested properties, __isset() will be invoked as appropriate for each property in the chain.

You can pass non-existent variables to userland functions

As we have already discussed, because isset() is actually a language construct, it has special behaviour because of the PHP core, and thus does not behave like functions we define ourselves.

However, we can achieve a similar effect in userland functions, through the use of references. By doing this, we open up the possibility to expose additional functionality of our own choosing on top of the regular language construct.

One practical example of this might be to treat any objects implementing a null object pattern as falsey values.

interface NullObject {}

class Logger {
    // ...
}

class NullLogger extends Logger implements NullObject {
    // ...
}

function is_truthy(&$value)
{
    if ($value instanceof NullObject) {
        return false;
    }

    return (bool) $value;
}

is_truthy($a);
// false

$b = '';
is_truthy($b);
// false

$c = '1';
is_truthy($c);
// true

$logger = new Logger();
is_truthy($logger);
// true

$nullLogger = new NullLogger();
is_truthy($nullLogger);
// false

However, references are not always that safe to use, as simply using them can affect the original value, even if the function doesn't explicitly do it.

For example, any undefined array keys or properties will automatically be assigned and their value set to null

$a = [];

is_truthy($a['b']['c']);

// false

var_dump($a);

// [

//     'b' => [

//         'c' => null,

//     ],

// ]

Conclusion

Hopefully throughout this look at isset(), its behaviour and other related things, you will have picked something up that will help you make your code cleaner, more explicit, and not catch you out in edge cases when you need to check if a variable has been set.

Why I Prefer Discord Over Slack

Liam Hammett — Fri, 14 Sep 2018 18:39:42 +0000

I've used more than my fair share of chat apps and solutions in the past, for both personal and professional use. AIM, MSN, Skype, IRC, Pidgin, HipChat, and Mattermost - to name the few that I've used for at least a year.

But over the years, they've all mostly faded away with two standing at the forefront: Slack for professional use, and Discord for gaming and casual use.

I use both on a daily basis, but strongly prefer Discord out of these two options, for both general use and coding discussion. Here I'm going to explain why Discord is better.

Multiple servers work seamlessly

There are a ton of chat communities - and I'm certainly in more than one, and may dip in-and-out of even more every now and again.

Slack makes this a pain because of the way it tries to separate every server to be standalone. This certainly has its use in certain environments but is not ideal when you're in multiple servers. On the web app only a single server can be opened at once and every time you join a new server you essentially have to "sign up" for it again.

Discord makes it a breeze by having a single account for everything. You still get to have per-server nicknames and identities, but you can join a new server with the mere click of a link, all of your notifications get neatly handled in the same way, and you can quickly make new servers on-the-fly. It also gives you the ability to see which users are in mutual servers, create DMs and groups outside the server itself, and a bunch of other convenient features.

Working with code

I'm a programmer, so in any given day there's a good chance I'll write or paste a snippet of code to discuss it with someone.

Slack has options for doing this - using standard markdown you can write inline or multiline code snippets. Alternatively, you can insert a snippet from a modal window, selecting the programming language the code is in and having that syntax highlight it as it puts it in chat.

Discord feels a lot more natural. There's no popup window to insert code - you do it all from the chat bar. You can write GitHub Flavored Markdown to tell what language it's in and therefore the syntax highlighting. There are little things that stop you from messing up too, like when you're writing a multi-line code block, hitting the 'return' key will insert a new line instead of submitting the message.

(Writing a multi-line code block in Discord's chat)

It's free

I'm not one to pass up paying for a decent product, especially one I'll be using on a daily basis, but it certainly comes into question here.

Slack has a free plan, but it only lets you store the last 10,000 messages. Remember a discussion from a few weeks back that you need to reference or get the context of a conversation? Maybe someone posted a code snippet to help someone else and now you've run into the same problem? Tough luck getting that back. Of course, Slack will let you keep unlimited messages, *for £6.30+ per user in the server - which is not practical for community servers.

Discord on the other hand, is completely free. Unlimited messages (I still have messages and files from three years ago accessible in Discord), group calls, custom emojis and everything else you could want from a chat application. They offer a paid subscription service called Nitro, but that only gives some additional cosmetic benefits, it's not required by any means for the core application.

Uptime

It's a bit disappointing that this is even a concern but certainly is an important concern.

Slack has made me experience several hours of downtime multiple times over the last few months, which is a bit of a problem when it's a primary communication method with co-workers. Slack does offer a 99.9% uptime SLA but at double the cost of the paid plan.

Discord has also had its fair share of uptime problems over the years, especially back in 2017, but even when Discord is having problems it rarely affects the whole platform. Even if a server is down, odds are you still have access to DM the people on that server if you need to get in touch.

Privacy in DMs

Slack, simply put, allows the server owners to export the entire chat history - including direct messages you may have made in private. Want to talk about something personal in private you might not want your boss to know about? Don't do it on Slack.

Discord doesn't offer any of this - which may, of course, be less than ideal if you're in an industry that's regulating you to archive all messages, but then you probably wouldn't be using Discord in the first place.

Personality

How can an application have a personality? There are lots of ways - how things are worded, what graphics there are, the little things that make you smile and just enjoy the experience of using an application.

Slack has a personality. It's playful and friendly in some places, like in the wording when you add too many reactions to a message. It's very limited though, the application itself still feels corporate and impersonal - which is perfect for its target audience, but not for everyone.

(Slack popup upon adding too many reactions)

Discord, on the other hand, has a ton of personality. Its target market is gamers, and it plays on that well. The application is full of personality, from the random community-submitted loading messages, playful custom emoji, and colourful members lists. There are memes and jokes all around, a solid and fun art style, the changelogs are an absolute pleasure to read, and there are so many little things that are in the application that you wouldn't expect, but are nice when you come across one - like the emoji picker changes to a random emoji whenever you mouse over it.

(Discord emoji picker)

(Discord changelog excerpt from August 8 2018)

It's not perfect, though

While Slack is a pleasure to use all around, it's not got everything. The gaming vibe might not be for everyone, there's no way to white-label it or get an SLA, export everything easily, but that's not all as much as a concern for me.

However, there are some things at the top of my "want" list for Discord:

Discord has very few professional-level integrations like Slack does. There's a very vibrant bot community, but still, a lot of work to be done to get things like JIRA, Trello, GitHub and the like on the same level of integration.
Slack has neat interactive message features for bots, like question buttons and menus, which make interacting with these bots much more convenient.
Threaded messages. I don't use them often in Slack, but they really do help keep conversations in context without disrupting the main flow of conversation.
Keyboard accessibility. I admit I've not looked into this much, but you seemingly can't seem to navigate around the Discord interface easily with keyboard controls.

What're your thoughts on these chat applications? Did I miss anything that makes one any better or worse than its competitor?