## Introduction

Logical operators are built within programming languages to allow the creation of different possible logic that drives algorithms. Other than this, there are other types of operators called `bitwise`

operator. With them, we are allowed to manipulate the path of the algorithm based on the corresponding bits' position. One such logical operator is the XOR operator. In this article, we will discuss the XOR operator in JavaScript.

## Getting started with XOR (^) operator

The bitwise `XOR`

operator in JavaScript is a bitwise operator that takes two operands and returns a one in the corresponding bit position if the operands are different, and a zero if they are the same. This operator is typically used for bitwise operations, such as setting or clearing individual bits in a byte or word.

The bitwise XOR operator is represented by the symbol `^`

. The bitwise XOR operator is a binary operator, meaning it operates on two operands. The operands can be of any type, but they will be converted to 32-bit signed integers before the operation is performed.

Here is the truth table for Bitwise XOR:

BIT FROM FIRST NUMBER |
BIT FROM SECOND NUMBER |
RESULT |

1 | 1 | Â 0 |

1 | Â 0 | 1 |

Â 0 | 1 | 1 |

Â 0 | Â 0 | Â 0 |

BitwiseÂ XORÂ is different from bitwise OR in that it returns 1 only when exactly one bit has a value of 1 (if both bits contain 1, it returns 0).

ToÂ XORÂ the numbers 25 and 3 together, use the following code:

```
let result = 25 ^ 3;
console.log(result); // 26
```

The result of a bitwiseÂ XORÂ between 25 and 3 is 26, as shown here:

```
25 = 0000 0000 0000 0000 0000 0000 0001 1001
3 = 0000 0000 0000 0000 0000 0000 0000 0011
---------------------------------------------
XOR = 0000 0000 0000 0000 0000 0000 0001 1010
```

Four bits in each number are set to 1; however, the first bit in both numbers is 1, so that becomes 0 in the result. All of the other 1s have no corresponding 1 in the other number, so they are passed directly through to the result. The binary code 11010 is equal to 26. (Note that this is one less than when performing bitwise OR on these numbers.)

## Example - Set or clear individual bits in a byte

The bitwise XOR operator is not typically used in JavaScript programs, but it can be used for bitwise operations on integers. The following example shows how the bitwise XOR operator can be used to set or clear individual bits in a byte. In this example, we use the bitwise XOR operator to toggle the state of a bit. If the bit is 0, it will be set to 1. If the bit is 1, it will be cleared to 0.

```
let byte = 0xff; // byte with all bits set
// toggle the state of the first bit
byte ^= 0x01;
console.log(byte)
// toggle the state of the third bit
byte ^= 0x04;
console.log(byte);
console.log(byte);
console.log(byte.toString(2)); // "11110101"
```

Output

```
254
250
250
11111010
```

Using another example, we can apply the `XOR`

operator on two integer numbers (`5`

and `3`

) to give a result of `6`

because there are two-bit positions where the corresponding bits of either integer number is `1`

, and the last bit position has both `1`

s so, therefore, `0`

. All of the comparison is done in binary, and converted back to the base that the integer numbers were supplied (here, base 10).

```
const a = 5; // 101
const b = 3; // 011
console.log(a ^ b); // 110
```

Output

```
6
```

## Example - Get a Value of Differing Bits in Each Operand

You have a number that youâ€™d like to coerce into a 32-bit integer and compare against another coerced 32-bit integer, where every differing bit in either operand creates a new integer with matching positive bits. This can be very useful for checking assigning a flag to a bit field or bit mask.

The bitwiseÂ XORÂ operator (`^`

) compares 32-bit integers for their bit values and returns a new 32-bit integer, which is a summation of all of the differing bits (where one operand has aÂ 0Â and the other aÂ 1) in the expression.

```
14 ^ 9; // 7
92 ^ 46; // 114
92 ^ 0; // 92
0 ^ 0; // 0
96 ^ -1; // -97
```

The bitwise XOR operator first coerces the left and right hand operands into signed 32-bit binary integers. It then looks at each bit between the left and right hand operands and sets each bit in the resulting integer based on the results. The resulting bit in each position is 1 if the left hand or right hand bits in that position equal 1. If they are both 1 or both 0, then the resulting bit will be 0.

## Summary

The bitwise XOR operator in JavaScript takes two numbers and returns a new number where the bits of the first number are turned on if the bits of the second number are turned off and vice versa. In addition, it is important to note that the two operands are converted to 32-bit integers and expressed by a series of bits for the bitwise `XOR`

operation to occur.

## References

Bitwise XOR (^) - JavaScript | MDN (mozilla.org)

Bitwise XOR assignment (^=) - JavaScript | MDN (mozilla.org)