How should I properly handle a JavaScript null check in this function?

General Discussions
, ,
1

I’ve seen the following code being used:

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

As someone new to JavaScript, this seems a bit redundant to me. From what I understand, data != null already covers both null and undefined, so adding data !== undefined might not be necessary.

For example, calling the function with no arguments sets data to undefined, which data != null already catches. Similarly, passing in null is also handled by data != null. And for any non-null value, both conditions pass anyway.

Is there any practical case where data !== undefined would be useful after doing a data != null JavaScript null check? Or is this just an unnecessary safeguard?

2

You’re on the right track! As you’ve noticed, a data != null check in JavaScript already handles both null and undefined, so the data !== undefined part isn’t necessary. I’ve worked with JavaScript for a while, and in most cases, keeping it simple with just data != null is all you need. It saves you some extra typing and makes the code clearer, too. Here’s how I would write it:

function test(data) {
    if (data != null) {
        // some code here
    }
}

In this case, JavaScript null check is both concise and effective. It’s also important to note that != null is a common approach when you’re just checking for nullish values (null or undefined). By removing the redundant !== undefined, the code is cleaner without sacrificing functionality.

3

I totally get why you’re asking about this! As someone who’s been through similar situations, sometimes you want to be really explicit, especially if you’re in a codebase where the distinction between null and undefined is important. If you want to make sure that data is neither null nor undefined, you could keep both checks. It’s more about clarity and making sure you’re being absolutely thorough. Here’s an example of how you might write it:

function test(data) {
    if (data != null && typeof data !== 'undefined') {
        // some code here
    }
}

Now, as you pointed out, after doing a data != null check, data !== undefined is really redundant, but sometimes, having both checks might give you that extra layer of confidence or clarity, especially if your team prefers explicit checks. For most situations, though, the javascript null check approach of using data != null is usually enough!

4

Great point! Another approach is to rely on JavaScript’s automatic handling of undefined. In this case, you can just check for null and leave everything else to JavaScript’s default behavior. When data is undefined, JavaScript treats it as a falsy value, so you won’t run into any errors. Here’s how I usually do it:

function test(data) {
    if (data !== null) {
        // some code here
    }
}

By doing just a data !== null check, you’re simplifying things while letting JavaScript handle undefined on its own. This works well if you don’t need to differentiate between undefined and null, or if you’re comfortable with undefined being treated as falsy (like false, 0, "", etc.). It’s a clean approach for when javascript null check is enough, and you don’t need to micromanage undefined behavior.