En esta nota exploraremos el mundo de los operadores binarios en Go y las poderosas herramientas que esta tecnología nos proporciona para trabajar con operaciones binarias y aprovechar su utilidad en diferentes escenarios.

Esta funcionalidad nos permite hacer operaciones pero con números binarios, por ejemplo, teniendo una variable a con números binarios, una variable b, y vamos a realizar operaciones, utilizando Operadores Lógicos, para que me devuelva un valor x.

Operadores Lógicos

Utilizamos operadores lógicos para realizar comparaciones entre 2 valores, se usa para combinar 2 valores y obtener como resultado el valor: 1 (verdadero) o 0 (falso).

Los 3 operadores principales son AND, OR & NOT. Para los siguientes ejemplos vamos a utilizar A y B como variables de entrada y X como variable de salida

AND

Cuando A y B son 1, X es 1, en cualquier otro caso X es 0

OR

Cuando A o B son 1, X es 1, en el único caso que X puede ser 0 es cuando A y B son 0

NOT

A diferencia de los otros operadores lógicos, NOT solo recibe un valor de entrada, el valor de X será el opuesto de A.

Si A es 1, X será 0, y si A es 0, X será 1

Existen otros operadores lógicos que vamos a explicar a continuación:

XOR

Es igual que OR pero con la diferencia que si A y B son 1, X será 0. El resultado de X es 1 cuando A y B no tienen ambos el mismo valor.

Por ejemplo, si A y B son 1, X será 0, y si A y B son 0, X será 0 también, en cualquier otro caso X será 1

NAND

Es el opuesto de AND (AND + NOT), X tendrá 0 cuando A y B tengan 1, en cualquier otro caso X tendrá 1

NOR

Es el opuesto de OR (OR + NOT), si A y B son 0, X será 1, en cualquier otro caso X será 0

XNOR

Es el opuesto de XOR (XOR + NOT), el resultado de X es 1 cuando A y B tienen ambos el mismo valor.

Operadores Binarios en Go

Para los siguientes ejemplos vamos a utilizar una variable a de enteros positivos de 16 bits, le vamos a asignar un valor decimal y vamos a ver en pantalla el valor en formato decimal y en formato binario (utilizamos %b para ver su representación en números binarios)

Output:

Left shift & Right shift

Usamos estos operadores para correr n cantidad de veces los números binarios, para la derecha (right shift) o para la izquierda (left shift).

Left shift es representado por ‘<<’, por ejemplo:

Output:

El resultado es 101010000000000 en lugar de 110101010000000000. Cuando intentamos llevar a cabo la operacion left shift con 10 posiciones, el valor es truncado.
Esto sucede porque el valor final termina siendo mas grande que el tamaño de la variable (16 bits)

Right shift es representado por ‘>>’, por ejemplo:

Output:

Va a llegar un punto que no lo vamos a poder decrementar mas y va a ser siempre cero, por ejemplo cuando lo quisimos mover 10 veces.

Operadores lógicos

Vamos a declarar otra variable para realizar los ejemplos: (le agrego un formato de 10 a los números binarios al mostrarlo para que me rellene hasta 10 con ceros)

Output:

Representación de los operadores en Go:

• Si queremos hacer un AND de A y B hacemos: a & b
• Si queremos hacer un OR de A y B hacemos: a | b
• Si queremos hacer un XOR de A y B hacemos: a ^ b
• Si queremos hacer un NOT de A hacemos: ^ a

(el ^ lo usamos tanto para XOR como para NOT)

Output:

En el caso del NOT se ve un numero binario mas grande que los anteriores, esto es porque para los casos anteriores teníamos ceros a la izquierda que no representan nada, pero al hacer un NOT convierte esos ceros en uno que ya representan valores.

Va a rellenar con uno hasta la capacidad que tenga la variable, en este caso son 16 bits.

Para utilizar los operadores NAND, NOR y XNOR, hacemos lo mismo que en el ejemplo anterior pero agregando un NOT a cada uno.

Por ejemplo, si queremos hacer un NAND lo que hacemos es hacer un NOT de un AND.

Output:

Ejemplo

Vamos a realizar un pequeño ejemplo utilizando roles, vamos a tener los roles READ, WRITE, UPDATE y DELETE, los cuales cada uno van a estar representados por números binarios solo teniendo un 1 en diferentes posiciones:

Vamos a hacerlo de esta manera para poder sumarlos y en base a un numero (la sumatoria de los roles que queramos asignar a un perfil) poder identificar que roles tiene asignado el perfil.

Entonces vamos a definir esas 4 variables que van a representar a los roles:

Luego vamos a asignarle roles a un perfil, vamos a agregarle los roles para escribir, leer y borrar:

Y ahora para validar si el perfil tiene permisos para realizar la operación vamos a hacer un AND:

• Si el AND me devuelve el ROLE, entonces tiene permisos
• Si el AND me devuelve cero, entonces NO tiene permisos

Conclusión

Exploramos los fundamentos de los operadores binarios en Go y aprendimos cómo utilizarlos de manera efectiva en nuestras aplicaciones. También, revisamos  cómo estos operadores nos permiten realizar operaciones lógicas y aritméticas a nivel de bits, lo que resulta útil en escenarios específicos. Recuerda que comprender y aplicar correctamente los operadores binarios puede mejorar el rendimiento y la eficiencia de tus programas. ¡Anímate a experimentar con ellos y a explorar más a fondo el poder de los operadores binarios en tus proyectos de Go!.

Repositorio: https://github.com/digitalhouse-tech/blog-go-binary-operators