False Checks Table for JavaScript: Are You Doing It Right?

I want to make sure my variable is not an empty string, null, undefined, NaN, zero, or false, but I don't want to check it like this:

if (var !== null || var !== undefined || var !== '')

I have written a test in TypeScript. Here is the output table.

Now, I can ensure the input from my user is not an empty string, null, undefined or false or 0, NaN with a simple check like this:

if (!value) {
  value_is_valid_doSomething();
}

function test1(variable: any, name: string) {
    if (variable === false) {
        return "falsely"
    } else {
        return "not falsely"
    }
}

function test2(variable: any, name: string) {
    if (variable == false) {
        return "falsely"
    } else {
        return "not falsely"
    }
}

function test3(variable: any, name: string) {
    if (!variable) {
        return "falsely"
    } else {
        return "not falsely"
    }
}

const testCases = [
    { value: 0, name: '0 (zero)' },
    { value: NaN, name: 'NaN' },
    { value: false, name: 'false' },
    { value: '', name: 'empty string' },
    { value: undefined, name: 'undefined' },
]

const tableData = testCases.map((testCase) => ({
    'variable': testCase.name,
    'var === false': test1(testCase.value, testCase.name),
    'var == false': test2(testCase.value, testCase.name),
    '!var': test3(testCase.value, testCase.name),
}))

console.table(tableData)

Gemini AI explains my code like this:

I'd be glad to provide a comprehensive explanation of the code you've shared, incorporating insights from the ratings and addressing potential shortcomings:

Code Breakdown:

The code defines three functions (test1, test2, and test3) that take a variable and a name as input and log a message based on the value of the variable. The functions use different comparison operators and conditions to determine whether the variable is considered "falsely."

Here's a breakdown of each function and its behavior:

test1(variable: any, name: string):

• Uses strict equality (===) to compare the variable with false.

• Logs "falsely" if the variable is strictly equal to false, otherwise logs "not falsely."

• This function will only return "falsely" for the actual false value.

test2(variable: any, name: string):

• Uses loose equality (==) to compare the variable with false.

• Logs "falsely" if the variable is loosely equal to false, which means it's either false itself or a value that can be coerced to false.

• This function will return "falsely" for false, 0, '', null, and undefined.

test3(variable: any, name: string):

• Uses the negation operator (!) to check if the variable is falsy.

• Logs "falsely" if the variable is falsy, which means it's one of the following values: false, 0, '', null, undefined, or NaN.

• This function will return "falsely" for all falsy values.

Key Observations:

• Strict equality (===) vs. loose equality (==): The test1 function uses strict equality, which requires both the value and type to be the same. The test2 function uses loose equality, which performs type coercion before comparison.

• Falsy values: The test3 function uses the negation operator (!) to check for falsy values. Falsy values in JavaScript include false, 0, '', null, undefined, and NaN.

Additional Notes:

• The test1 function is the most strict, only considering false as truly false.

• The test2 function is less strict, considering additional values as false.

• The test3 function is the least strict, considering all falsy values as false.

The choice of function depends on your specific requirements and the values you want to consider as false in your application.