DEV Community

loading...

Discussion on: It's time to let go of lodash

Collapse
michaelcurrin profile image
Michael • Edited

Please don't recommend Boolean as boolean type check.

Boolean(true);
// true
Boolean(false);
// false
Enter fullscreen mode Exit fullscreen mode

With your approach, you'd incorrectly conclude that a variable of false passed to Boolean() is not a boolean.

Boolean will cast to boolean.

Boolean(1)
// true
Enter fullscreen mode Exit fullscreen mode

Since non-zero numbers are truthy, they will give you a response of true even though not boolean type.

You should use

typeof 1 === 'boolean'
// false

typeof true === 'boolean'
// true
typeof false === 'boolean'
// true
Enter fullscreen mode Exit fullscreen mode
Collapse
michaelcurrin profile image
Michael

Bonus points if use you TypeScript

function hello(greet: Boolean) {}
Enter fullscreen mode Exit fullscreen mode
Collapse
jmitchell38488 profile image
Justin Mitchell Author

Explicitly checking truthiness is better than implicitly checking, and to do that you need to use strict equality true/false, as all other checks are implicit by means of coercing a value to a bool.

Thread Thread
michaelcurrin profile image
Michael • Edited

Assuming your comment was on my previous comment and not the TypeScript one, as TypeScript will check type is a boolean for you using myVar: Boolean.

Use this to check for type boolean:

typeof myValue === 'boolean'
Enter fullscreen mode Exit fullscreen mode

Use this to check if a value is actually true and boolean, not just truthy. Because triple equals sign does a type check

myVar === true
Enter fullscreen mode Exit fullscreen mode
1 === true
// false
Enter fullscreen mode Exit fullscreen mode

Beware the double equals sign which coerces ie is checks for truthiness and also handles strings funny.

5 == "5" // true

0 == false // true
Enter fullscreen mode Exit fullscreen mode

I don't see a common reason to use Boolean().

It adds change in logic here so is verbose.

// this checks for truthiness twice 
if (Boolean(myVar)) {}

// and equivalent to just this which checks once.
if (myVar) {}
Enter fullscreen mode Exit fullscreen mode

If you want to be explicit in logic flows use triple equals and a value.

// true for 1. and false for 0 and 1000 and any non Number type
if (myVar === 1) {}

// true for true only and false for everything else.
if (myVar === true) {}
Enter fullscreen mode Exit fullscreen mode

You could use Boolean() to convert to a Boolean type but I can't remember needing to do this in JS.

var myNumber = 1 // or 1000 or 0 or -999 etc.
var myBool = Boolean(myNumber) // can be true. Or false for myNumber equal to zero

var a = Boolean("my string")
// true
var b = Boolean("")
// false
b === false
// true
Enter fullscreen mode Exit fullscreen mode

Boolean docs

Thread Thread
jmitchell38488 profile image
Justin Mitchell Author • Edited

Relying on TS to ensure type checking is fraught with danger esp with input data. TS isn't a runtime environment, it's just a transpiler.

Boolean(a) is equivalent to !!a

Explicit checking requires strict equals, in my previous comment, but you will need to test for true and false.

Thread Thread
michaelcurrin profile image
Michael

Okay thanks. I didn't understand your TS before.

Yes if you have user input you could pass non accepted type to a function. That is a risk for all types and not just boolean and there are a few ways to do that.

Like myVar as Boolean.
Or if your input can't be trusted, then add some sanitization on your form handling or use a check before or within the function as typeof myvar === 'boolean.

Thread Thread
jmitchell38488 profile image
Justin Mitchell Author • Edited

Like I said earlier, !!prop and Boolean(prop) are fundamentally the same - they determine the truthiness of a value by coercion, not if it is in fact a boolean, just that it has a value other than "", null, undefined, false and 0. Given an array and object share the same super type object, truthiness check will always return true.

typeof myvar === boolean isn't required when you can just do prop === true || prop === false and explicitly check the values, rather than the type.

Lodash explicitly checks the truthiness of the var, and some other checking for arrays and objects. My suggestion isn't a hard and fast rule, it's just one of many options and it's a useful shorthand check. Feel free to use !!var, Boolean(var) or copy+paste the lodash code.

Thread Thread
michaelcurrin profile image
Michael

Ok thanks. My original point was not on the best way to do truthiness though but the fact that these two are not interchangeable as you had suggested, so was recommending it be fixed.

_.isBoolean(true); //true
Boolean(true); //true - same as above line
Enter fullscreen mode Exit fullscreen mode
_.isBoolean(false); //true
Boolean(false); //false. But different result to above line and therefore not equivalent
Enter fullscreen mode Exit fullscreen mode