# Binary Operators in Golang

# Introduction

Welcome to my article, we are going to talk about binary operators in Go 😀

With this functionality, we can perform operations with binary numbers. For example, we can have a variable **‘A’** representing a binary number, another variable **‘B’**, and use logical operators to perform operations that will result in a value **‘X’**

# Logical Operators

We use logical operators to compare two values. They allow us to combine two values and obtain a result of either **1(one)** or **0(zero)**.

There are 3 common operators: **AND, OR** and **NOT**. In our examples, we will use variables **A** and **B** as input, and variable **X** as the output.

# AND

When **A** and **B** are both **1**, **X** is **1**. Otherwise, **X** is **0**.

# OR

When **A** or **B** is **1**, **X** is **1**.

The only case where **X** can be **0** is when **A** and **B** are both **0**

# NOT

Unlike the other logical operators, **NOT** only takes one input value, and the value of **X** will always be the opposite of **A**

If A is **1**, X will be **0**, and if **A** is **0**, **X** will be **1**

There are other Logical Operatos that we are going to explain next:

# XOR

XOR is equal to **OR**, however with a difference: if **A** and **B** are both **1**, **X** will be **0**. **X** is **1** when **A** and **B** aren’t both the same value.

For example: if **A** and **B** are both **1**, **X** will be **0**. if **A** and **B** are both **0**, **X** will be **0** too. Otherwise, **X** will be **1**

# NAND

NAND is the opposite of **AND** (AND + NOT). **X** will be **0** when **A** and **B** are both **1**. Otherwise, **X** will be **1**

# NOR

**NOR** is the opposite of OR (OR + NOT), if **A** and **B** are both **0**, **X** will be **1**. Otherwise, **X** will be **0**

# XNOR

**XNOR** is the opposite of XOR (XOR + NOT), **X** will be **1** when **A** and **B** are both the same value

# Binary Operators in Go

For the next examples, we are going to use a 16-bit positive integer value (uint). We will set it to a decimal value and display the value in both decimal and binary formats in the console.

(We will use ** %b** to see its binary representation.)

`var a uint16 = 213`

fmt.Printf("Number %d in binary is %b\n", a, a)

Output:

`Number 213 in binary is 11010101`

# Left shift & Right shift

We use those operators to shift the binary values by **n** positions.

**Left shift** is represented by **<<**, for example:

`// binary_number << n_positions_to_shift = result`

fmt.Printf("Number %d in binary is %b\n", a << 1, a << 1)

// 11010101 << 1 = 110101010 (We shift it once)

fmt.Printf("Number %d in binary is %b\n", a << 10, a << 10)

// 11010101 << 10 = 101010000000000 (We shift it 10 times)

Output:

`Number 426 in binary is 110101010`

Number 21504 in binary is 101010000000000

The result is **101010000000000** instead of **110101010000000000**. When we attempt to perform a left shift with 10 positions, the value is truncated. This happens because the value being shifted is bigger than 16 bits.

**Right shift** is represented by **>>**, for example:

`// binary_number >> n_positions_to_shift = result`

fmt.Printf("Number %d in binary is %b\n", a >> 1, a >> 1)

// 11010101 >> 1 = 1101010 (We shift it once, the number will be decreasing)

fmt.Printf("Number %d in binary is %b\n", a >> 10, a >> 10)

// 11010101 >> 10 = 0 (We shift 10 times)

fmt.Printf("Number %d in binary is %b\n", a >> 5, a >> 5)

// 11010101 >> 10 = 110 (We shift 5 times)

Output:

`Number 106 in binary is 1101010`

Number 0 in binary is 0

Number 6 in binary is 110

There will come a point where we won’t be able to decrement it anymore, and it will always be zero. For example, when we tried to shift it 10 times.

# Logical Operators

We are going to declare another variable to perform the following examples.

(We will use a 10-digit format to fill it with leading zeros)

`var b uint16 = 20`

fmt.Printf("'a': %.3d - %.10b\n", a, a) // a = 0011010101

fmt.Printf("'b': %.3d - %.10b\n\n", b, b) // b = 0000010100

Output:

`'a': 213 - 0011010101`

'b': 020 - 0000010100

Representation of the binary logical operators in Go:

- If we want to perform an AND between A and B, we use: a & b
- If we want to perform an OR between A and B, we use: a | b
- If we want to perform an XOR between A and B, we use: a ^ b
- If we want to perform a NOT operation on A, we use: ^a

(The caret symbol (^) is indeed used for both XOR and NOT operations.)

`// AND`

fmt.Printf("Bitwise AND: %d - %.10b\n", a & b, a & b)

// 0011010101 AND 0000010100 = 0000010100

// OR

fmt.Printf("Bitwise OR: %d - %.10b\n", a | b, a | b)

// 0011010101 OR 0000010100 = 0011010101

// XOR

fmt.Printf("Bitwise XOR: %d - %.10b\n", a ^ b, a ^ b)

// 0011010101 OR 0000010100 = 0011000001

fmt.Printf("Bitwise NOT: %d - %.10b\n", ^a, ^a)

// NOT 0011010101 = 1111111100101010

Output:

`Bitwise AND: 20 - 0000010100`

Bitwise OR: 213 - 0011010101

Bitwise XOR: 193 - 0011000001

Bitwise NOT: 65322 - 1111111100101010

In the case of **NOT**, a larger binary number is seen compared to the previous ones. This is because for the previous cases, we had leading zeros that didn’t represent anything, but when performing a NOT operation, those zeros are converted to ones that now represent values.

It will fill with ones up to the capacity of the variable, in this case, 16 bits.

To use the **NAND, NOR**, and **XNOR** operators, we do the same as in the previous example but add a **NOT** to each one.

For example, if we want to perform a **NAND** operation, we take the **NOT** of an **AND** operation.

`// NAND`

fmt.Printf("Bitwise NAND: %d - %.10b\n", ^(a & b), ^(a & b))

// NOT (0011010101 AND 0000010100) = 1111111111101011

// 0011010101 NAND 0000010100 = 1111111111101011

// NOR

fmt.Printf("Bitwise NOR: %d - %.10b\n", ^(a | b), ^(a | b))

// NOT (0011010101 OR 0000010100) = 1111111100101010

// 0011010101 NOR 0000010100 = 1111111100101010

// XNOR

fmt.Printf("Bitwise XNOR: %d - %.10b\n", ^(a ^ b), ^(a ^ b))

// NOT (0011010101 XOR 0000010100) = 1111111100111110

// 0011010101 XNOR 0000010100 = 1111111100111110

Output:

`Bitwise NAND: 65515 - 1111111111101011`

Bitwise NOR: 65322 - 1111111100101010

Bitwise XNOR: 65342 - 1111111100111110

# Example

We are going to perform a small example using roles. We will have the roles **READ, WRITE, UPDATE**, and **DELETE**, each of which will be represented by binary numbers with only a **1** in different positions:

We are going to do it this way so that we can add them up and based on a number (the sum of the roles we want to assign to a profile), we can identify which roles the profile has assigned.

So let’s define those 4 variables that will represent the roles:

`READ_ROLE := 1 // 0001`

WRITE_ROLE := 1 << 1 // 0010

UPDATE_ROLE := 1 << 2 // 0100

DELETE_ROLE := 1 << 3 // 1000

Then we are going to assign roles to a profile. We will add the roles for writing, reading, and deleting:

`myProfile := READ_ROLE + WRITE_ROLE + DELETE_ROLE `

// Profile: 1011

And now, to validate if the profile has permissions to perform an operation, we will use the bitwise **AND** operator:

- If the result of the
**AND**operation is equal to the**ROLE**, then**it has permissions**. - If the result of the
**AND**operation is zero, then**it does NOT have permissions**.

`// Validating for the update role, it does not have permissions.`

fmt.Println("Does the user have permissions to perform the operation?")

if (0 != (myProfile & UPDATE_ROLE)) {

fmt.Println("Yes! :D")

}else{

fmt.Println("No :(")

}

`// Validating for the read role, it has permissions.`

fmt.Println("Does the user have permissions to perform the operation?")

if (0 != (myProfile & READ_ROLE)) {

fmt.Println("Yes! :D")

}else{

fmt.Println("No :(")

}

# Conclusion

In this article, we have explored the fundamentals of binary operators in Golang and learned how to effectively use them in our applications. We have seen how these operators allow us to perform logical and arithmetic operations at the bit level, which is useful in specific scenarios. Remember that understanding and correctly applying binary operators can improve the performance and efficiency of your programs. Feel free to experiment with them and further explore the power of binary operators in your Go projects!

resource: blog_go_binary_operators