# Ruby Bitwise Operators

An operator is *bitwise *when* *instead of treating integers as whole numbers, it treats them as a sequence of bits.

This is hugely used to apply a mask to an integer. For example, to verify the answers of an MCQ test.

So let’s have a look at how the bitwise operators work in Ruby.

## Before to start

Please allow me to introduce here the platform that helped me to learn a big part of my knowledge about Ruby. Indeed, **Pluralsight** is an amazing platform.

With **50+ courses** that cover various topics on **Ruby** and **Ruby on Rails**, it’s the best way to take your knowledge to the next level!

Try it for free 👇😉

Thank you for your time!

## Base 10 to Base 2

The `base 10`

is the common base that we use everyday.

The `base 2`

is the base used by your computer to make operations. This base works with 2 values that are `0`

and `1`

.

Each bit has a weight that is a multiple of 2. each value is assigned from the right to the left.

- the first bit (from the right) has a value of 1
- the second one a value of 2
- the third one a value of 4
- etc..

If the bit is set to `1`

then the value attached to this bit is counted to retrieve the number.

Let’s have a look at the following example to see how to convert a number in `base 2`

.

Here, we convert the number `34`

in `base 2`

`128 64 32 16 8 4 2 1`

| | | | | | | |

0 0 1 0 0 0 1 0

So, to convert a number in `base 2`

we move from the left to the right and we apply the following rule:

- Does 128 is included in 34 ? No
- Does 64 is included in 34 ? No
- Does 32 is included in 34 ? Yes:
`34 — 32 =`

**2** - Does 16 is included in 2 ? No
- Does 8 is included in 2 ? No
- Does 4 is included in 2 ? No
- Does 2 is included in 2 ? Yes:
`2 — 2 = 0`

So the bits attached to 32 and 2 will be set to `1`

.

## Base 2

As we’ve seen in introduction, a bitwise operator treats integers as a sequence of bits — In `base 2`

instead of `base 10`

.

So, how to see an integer as a sequence of bits ?

**$> 4.to_s(2)**

=> "100"

The `Integer#to_s(base = 10)`

can take an argument that is the `base`

where the `Integer`

will be returned. By default, it’s the `base 10`

— the common `base`

.

The `to_s(2)`

doesn’t return the ahead zeros. It’ll return a `String`

that contains the sequence of bits that starts with the first `1`

encountered from the left to the right.

## Bitwise AND (&)

The Bitwise `AND`

operator applies a `&`

operation on each bit of the sequence.

So let’s detail the following operation `7 & 5`

7 in Base 2: 0000 0111

5 in Base 2: 0000 0101 128 64 32 16 8 4 2 1

----------------------

7: 0 0 0 0 0 1 1 1

& & & & & & & &

5: 0 0 0 0 0 1 0 1

-----------------------

5: 0 0 0 0 0 1 0 1

So the result of the operation `7 & 5`

is `5`

.

Let’s make this operation in Ruby

**$> 7 & 5**

=> 5

**$> (7 & 5).to_s(2)**

=> "101"

## Bitwise OR

The Bitwise `OR`

operator applies a `|`

operation on each bit of the sequence

So let’s detail the following operation `7 | 5`

7 in Base 2: 0000 0111

5 in Base 2: 0000 0101 128 64 32 16 8 4 2 1

----------------------

7: 0 0 0 0 0 1 1 1

| | | | | | | |

5: 0 0 0 0 0 1 0 1

----------------------

7: 0 0 0 0 0 1 1 1

So the result of the operation `7 | 5`

is `7`

.

Let’s make this operation in Ruby

**$> 7 | 5**

=> 7

**$> (7 | 5).to_s(2)**

=> "111"

## Bitwise LEFT SHIFT

The `LEFT SHIFT`

operator `<<`

shifts each bit of a number to the left by `n`

positions.

So let’s detail the following operation `7 << 2`

7 in Base 2: 0000 0111 128 64 32 16 8 4 2 1

----------------------

7: 0 0 0 0 0 1 1 1

shift each bit to the left by 2 positions

----------------------

28: 0 0 0 1 1 1 0 0

So the result of the operation `7 << 2`

is `28`

.

Let’s make this operation in Ruby

**$> 7 << 2**

=> 28

**$> (7 << 2).to_s(2)**

=> "11100"

## Bitwise RIGHT SHIFT

The `RIGHT SHIFT`

operator `>>`

shifts each bit of a number to the right by `n`

positions.

So let’s detail the following operation `40 >> 2`

40 in Base 2: 0010 1000 128 64 32 16 8 4 2 1

----------------------

40: 0 0 1 0 1 0 0 0

shift each bit to the right by 2 positions

----------------------

10: 0 0 0 0 1 0 1 0

So the result of the operation `40 >> 2`

is `10`

.

Let’s make this operation in Ruby

**$> 40 >> 2**

=> 10

**$> (40 >> 2).to_s(2)**

=> "1010"

## Conclusion

Bitwise operators are not commonly used in Rails but can be pretty handy when we’ve a “multiple choices” feature as MCQ test, configs, options, etc..

Note that there is 2 other bitwise operators that we didn’t cover in this article: the `bitwise exclusive or`

and the `bitwise not`

operators. I’ll probably cover them in another article.

Voilà !

Thank you for taking the time to read this post :-)

Feel free to 👏 and share this Medium post if it has been useful for you.

Here is a link to my last medium post:

.**Ruby: class_eval vs module_eval**