In JavaScript, you can convert a boolean `true`

or `false`

to their numeric equivalents of `1`

or `0`

(respectively), in the following ways:

- Using
`Number()`

; - Using Ternary Operator;
- Using Unary Operators;
- Using Arithmetic Operators;
- Using Bitwise Operators;
- Using Bitwise Shift Operators.

You could determine the best method for you on a per-project basis. For example, if you're working in a team environment, then you should *always* strive to use methods that are easily readable for other programmers. On the other hand, if you're developing a library of your own, etc. (where micro-optimizations might help) the best method *might* be the one that's the fastest. Therefore, by knowing different ways, you can make an informed decision.

All methods covered in the post (except for the condition in the ternary operator) can *potentially* return `NaN`

when you're unsure of the variable always having a boolean value.

## Using `Number()`

Boolean values can be converted to numbers using the `Number()`

function like so:

Number(true); // 1 Number(false); // 0

This might be a bit slower in comparison to other methods because it has the run-time complexity of a function. However, it is perhaps the *most* readable method of explicitly converting a boolean to its numeric equivalent, where the intention is immediately clear by reading the code.

## Using Ternary Operator

You can simply use the boolean in a ternary condition to return `1`

when the boolean is `true`

and `0`

otherwise:

true ? 1 : 0; // 1 false ? 1 : 0; // 0

The conditional part in the ternary can evaluate variables of *any* type and would safely return `1`

or `0`

even for variables that may have non-boolean values. This is an important distinction to make with other methods where, when an operand in an expression cannot be converted to an integer, `NaN`

is returned.

## Using Unary Operators

A unary operation is an operation with *only* one operand. In JavaScript, you can use the following unary operators to convert a boolean to an integer:

### Using Unary Plus Operator:

The unary plus operator (`+`

) converts its operand to a number. Therefore, if you use the unary operator with a boolean it would convert `true`

to `1`

and `false`

to `0`

. For example:

+true; // 1 +false; // 0

### Using Bitwise NOT Operator:

Bitwise NOT (`~`

) inverts the bits of its operand. For example inverting the bits of decimal `0`

and `1`

have the following results:

const a = 1; // 32-bit binary equivalent: 00000000000000000000000000000001 ~a; // -2 (32-bit binary equivalent: 11111111111111111111111111111110) const b = 0; // 32-bit binary equivalent: 00000000000000000000000000000000 ~b; // -1 (32-bit binary equivalent: 11111111111111111111111111111111)

And inverting the results again would give you the original number. For example:

~~a; // 1 ~~b; // 0

You can use this for converting booleans to integers:

~~true; // 1 ~~false; // 0

This works because JavaScript automatically converts the operand to a number when doing bitwise `NOT`

. This means that booleans will be converted to their numeric equivalents. For example, `true`

becomes `1`

and `false`

becomes `0`

.

The result can be visualized in terms of the following truth table for the double NOT operation:

`x` |
`~x` |
`~~x` |
---|---|---|

`true` (or `1` ) |
`0` |
`1` |

`false` (or `0` ) |
`1` |
`0` |

## Using Arithmetic Operators

When you perform an arithmetic operation on a boolean value, JavaScript internally converts `true`

to integer `1`

and `false`

to integer `0`

. Therefore, the following can be used to convert boolean to integer values:

Although, it's possible to do this, you *should* generally avoid using these *just* for the sole purpose of converting a boolean to an integer as it is *not* very readable.

### Using Addition:

You could add `0`

to `true`

or `false`

, which would coerce the value to a number first, and then return the result of the addition:

true + 0; // 1 false + 0; // 0 // equivalent to 1 + 0; // 1 0 + 0; // 0

### Using Subtraction:

You could subtract `0`

from `true`

or `false`

, which would coerce the value to a number first, and then return the result of the subtraction:

true - 0; // 1 false - 0; // 0 // equivalent to 1 - 0; // 1 0 - 0; // 0

### Using Multiplication:

You could multiply a boolean with `1`

, which would coerce it to a number first, and then return the result of the multiplication:

true * 1 // 1 false * 1 // 0 // equivalent to 1 * 1; // 1 0 * 1; // 0

### Using Division:

You could divide a boolean value with `1`

, which would coerce it to a number first and then return the result of the division:

true / 1; // 1 false / 1; // 0 // equivalent to 1 / 1; // 1 0 / 1; // 0

## Using Bitwise Operators

You can perform boolean to integer conversion by using bitwise operators as well, for example, in the following ways:

When performing bitwise operations with boolean values, JavaScript internally converts `true`

to `1`

and `false`

to `0`

.

Although, it's possible to do this, you *should* generally avoid using these *just* for the sole purpose of converting a boolean to an integer as it is *not* very readable.

### Bitwise AND:

The bitwise AND operator (`&`

) returns `1`

when the corresponding bits of both operands are `1`

and returns `0`

otherwise. The following truth table demonstrates this:

x | y | x & y |
---|---|---|

`0` |
`0` |
`0` |

`0` |
`1` |
`0` |

`1` |
`0` |
`0` |

`1` |
`1` |
`1` |

From the table above you can see that:

1 & 1; // 1 0 & 1; // 0

If you replace the first operand with a boolean, you would get the same result as above because JavaScript converts booleans to their numeric equivalents when performing bitwise operations:

true & 1; // 1 false & 1; // 0

### Bitwise OR:

The bitwise OR operator (`|`

) returns `1`

when bits of one of the operands is `1`

, which means it returns `0`

*only* when both operands are `0`

. The following truth table demonstrates this:

x | y | x | y |
---|---|---|

`0` |
`0` |
`0` |

`0` |
`1` |
`1` |

`1` |
`0` |
`1` |

`1` |
`1` |
`1` |

From the table above you can see that:

1 | 0; // 1 0 | 0; // 0

If you replace the first operand with a boolean, you would get the same result as above because JavaScript converts booleans to their numeric equivalents when performing bitwise operations:

true | 0; // 1 false | 0; // 0

### Bitwise XOR:

The bitwise XOR operator (`^`

) returns `1`

when the corresponding bits are different and `0`

when the corresponding bits are the same. The following truth table demonstrates this:

x | y | x ^ y |
---|---|---|

`0` |
`0` |
`0` |

`0` |
`1` |
`1` |

`1` |
`0` |
`1` |

`1` |
`1` |
`0` |

From the table above you can see that:

1 ^ 0; // 1 0 ^ 0; // 0

If you replace the first operand with a boolean, you would get the same result as above because JavaScript converts booleans to their numeric equivalents when performing bitwise operations:

true ^ 0; // 1 false ^ 0; // 0

## Using Bitwise Shift Operators

You can shift bits to convert booleans to integers in the following ways:

- Using Right Shift Operator (
`>>`

); - Using Left Shift Operator (
`<<`

).

Either of these would move the binary bits of the first operand the specified number of bits either to the left or the right.

Although, it's possible to do this, you *should* generally avoid using these *just* for the sole purpose of converting a boolean to an integer as it is *not* very readable.

### Using Right Shift Operator:

Shifting `101`

(which is equivalent to decimal `5`

), for example, one times to the right would give you binary `10`

, which equals decimal `2`

:

const a = 5; a >> 1; // 2

If instead of shifting the bits one time, suppose you shift it two times to the right, you would be left with `1`

which is equivalent to decimal `1`

:

a >> 2; // 1

And, if you shift bits zero times, then you're simply left with the number itself:

a >> 0; // 5

That's something you can use to convert a boolean to an integer with bit shifting:

true >> 0; // 1 false >> 0; // 0

This works because JavaScript internally converts boolean to their numeric equivalents. This particular case would work with `>>>`

(unsigned right shift) all the same as `>>`

(signed right shift):

true >>> 0; // 1 false >>> 0; // 0

### Using Left Shift Operator:

If you were to shift bits to the left, specified number of zero bits are added to the right hand side. For example, shifting `101`

(which is equivalent to decimal `5`

) one times to the left would give you binary `1010`

, which equals to decimal `10`

:

const a = 5; a << 1; // 10

And shifting two bits to the left of decimal five would give you the binary number `10100`

, which is equivalent to decimal `20`

:

a << 2; // 20

Similarly, if you shift bits zero times, then you're simply left with the number itself:

a << 0; // 5

That's something you can use to convert a boolean to an integer with bit shifting:

true << 0; // 1 false << 0; // 0

This post was published (and was last revised ) by Daniyal Hamid. Daniyal currently works as the Head of Engineering in Germany and has 20+ years of experience in software engineering, design and marketing. Please show your love and support by sharing this post.