In today's post, I'm going to show you how to get a random truthy/falsy value in JavaScript. This can be helpful when you want to run some conditional statements in a randomized way. It can be done with a really simple helper function:

`/**`

* Get a random truthy/falsy value

* {@link https://gist.github.com/kieranbarker/25b1b4b4cef14c65b10dcefdc462f6ee}

* @returns {Number} 1 (truthy) or 0 (falsy)

*/

function fiftyFifty () {

return Math.round(Math.random());

}

You would use it like so:

`if (fiftyFifty()) {`

// This will run 50% of the time...

}

Let's see how it works.

## Math.random()

The first thing we do is make a call to the static `Math.random()`

method. This returns a pseudo-random number between `0`

(inclusive) and `1`

(exclusive). This means that it could return `0`

, or anything *between* `0`

and `1`

, but **not** `1`

.

Here are some examples. I just ran `Math.random()`

in the console five times:

`0.8424333633138914`

`0.6708640956019702`

`0.29226591753427367`

`0.9309103559864624`

`0.9709222745438715`

## Math.round()

Once we've got our random number, we pass it to the static `Math.round()`

method. This does what you'd expect: it returns the number after rounding it to the nearest integer. If the fractional part of the number is less than `0.5`

, the number will be rounded down. If it's greater than or equal to `0.5`

, the number will be rounded up.

Because `Math.random()`

always returns a number between `0`

and `1`

, our helper function will always return `0`

(rounded down) or `1`

(rounded up).

## Truthiness and falsiness

In most (if not all) programming languages, a value is either truthy or falsy. Because `1`

is truthy and `0`

is falsy, this means you can call our helper function and use the returned value as a condition, as I demonstrated before:

`if (fiftyFifty()) {`

// This will run 50% of the time...

}

## Returning an explicit boolean value

**It's not necessary,** but if you really wanted to return an explicit boolean value for some reason, you could force the conversion using a double NOT (`!`

) operator:

`/**`

* Get a random boolean value

* {@link https://gist.github.com/kieranbarker/25b1b4b4cef14c65b10dcefdc462f6ee}

* @returns {Boolean} True or false

*/

function fiftyFifty () {

return !!Math.round(Math.random());

}

The MDN Web Docs explain:

The logical NOT (

`!`

) operator ... takes truth to falsity and vice versa. It is typically used with`Boolean`

(logical) values. When used with non-Boolean values, it returns`false`

if its single operand can be converted to`true`

; otherwise, returns`true`

.

If `Math.round(Math.random())`

returns `0`

, then the first NOT (`!`

) operator will convert it to `true`

, since `!0`

is true. The second NOT (`!`

) operator then turns it back to `false`

, since `!true`

is false.

If `Math.round(Math.random())`

returns `1`

, then the first NOT (`!`

) operator will convert it to `false`

, since `!1`

is false. The second NOT (`!`

) operator then turns it back to `true`

, since `!false`

is true.

I first saw Steve Griffith use the `Math.round(Math.random())`

technique in one of his videos called Efficient ES6 async await with fetch, so credit to him for that.