La explicación del funcionamiento de la función XOR a nivel de compuertas lógicas es bastante simple.

En principio, tenemos como mínimo una entrada de 2 bits distintos.

El circuito XOR nos devolverá un 1 como resultado siempre y cuando ambos bits sean diferentes.

En la entrada, necesitamos usar una compuerta OR de 2 entradas.

También necesitamos una compuerta AND de 2 entradas en la entrada, y frente a esta una compuerta de negación para invertir el resultado de dicha compuerta AND.

La primera pata de entrada de la compuerta OR va a la primera pata de entrada de la compuerta AND invertida, y la segunda pata de la compuerta OR de entrada va a la segunda pata de la compuerta AND invertida de entrada.

En otras palabras, queremos obtener el resultado del OR y del AND invertido para los dos bits iniciales de entrada.

Los dos bits de resultado obtenidos por la compuerta OR y AND invertida los haremos pasar por una compuerta AND final de dos entradas.

El resultado de esta última AND será el valor XOR.


La intención de este circuito es usar el OR para detectar la presencia de un 1 y devolver un 1 como resultado; y la intención de la AND invertida es detectar la presencia de un 0 y devolver un 1 como resultado.

Las compuertas OR están orientadas a devolver un 1 cuando hay por lo menos un 1 de entrada.

Las compuertas AND están orientadas a devolver un 0 cuando hay por lo menos un 0 de entrada. Con la compuerta de negación obtenemos un 1 de la AND cuando hay un 0 presente.


Así que con el OR detectamos si hay un 1 presente, y devolvemos 1.
Con el AND detectamos si hay un 0 presente, y en ese caso obtenemos un 0 que invertimos para obtener un 1 en la presencia de un 0 de entrada.

Ahora, si hay un 1 presente, el OR nos devolverá 1.
Y si hay un 0 presente, el AND invertido nos devolverá 1.


Tomemos como ejemplo 11 binario.
Cuando la compuerta OR lo procese, obtendremos 1, que significa que hay un 1 presente en la entrada.
Ahora, cuando la compuerta AND procese los dos bits de entrada originales a 1, también devolverá un 1, pero la compuerta de negación invertirá ese resultado de 1 a 0 para indicar que no había ningún 0 presente en la entrada.
Cuando el 1 del OR y el 0 del AND invertido ingresen a la compuerta AND final, obtendremos un 0 en respuesta de la entrada original 11 binario. Esto indicará que ambos bits tenían el mismo valor.

Es como si el circuito XOR fuera una pregunta.: ¿Son ambos bits de entrada diferentes? La respuesta será un 1 para indicar VERDADERO si realmente son diferentes.
Ahora podemos ver claramente que si ambos bits de entrada son iguales como en este caso con 11 binario, el resultado devuelto por la función XOR será 0.



Tomemos otro ejemplo, con 10 binario.
La compuerta OR toma ambos bits, 1 y 0, y devuelve 1 ya que hay por lo menos un 1 presente.
La compuerta AND toma ambos bits 1 y 0, y devuelve 0 ya que hay por lo menos un 0 presente.
Pero con la compuerta de negación que le sigue a esta AND obtenemos un 1, lo que indica que hay un 0 presente.

Ahora, el bit con valor 1 de resultado de la OR, y el bit con valor 1 de la AND invertida entran en la última AND, la AND de salida, y ya que ambos bits son 1, devolvemos 1.
Lo que indica esto es que la OR tomó el 1 y el 0 y detectó la presencia de un 1, devolviendo 1.
También indica que la AND invertida tomó el 1 y el 0 y detectó la presencia de un 0, devolviendo 1.
Ya que el circuito OR y AND invertido nos indican por su lado que hay tanto un 1 como un 0 presentes, devolvemos un 1 para la función XOR del circuito completo, para indicar que ambos bits eran diferentes.

Como vemos también, al nivel más fundamental siempre operamos las compuertas de 2 en 2, así que resolver será fácil. Incluso en la aritmética decimal normal operamos de 2 en 2 al nivel lógico más simple.

El siguiente código de javascript demuestra cómo se vería implementada como programa la función lógica del circuito XOR. Siempre que los 2 bits de entrada sean iguales, el programa devolverá 0. Si son diferentes, este devolverá 1.

Paso 1.: Necesitamos 2 variables de entrada de por lo menos 1 bit de tamaño.
Paso 2.: Aplicamos OR entre ambas variables de entrada.
Paso 3.: Aplicamos AND entre ambas variables, y negamos los valores de bits del resultado.
Paso 4.: Aplicamos AND al resultado del OR y del NAND. Este es el valor XOR.


La mayoría de lenguajes de programación y ensambladores tienen operadores o instrucciones XOR. Estas son especialmente útiles para generar código más breve que asigne 0 a una variable o registro al aplicarle XOR con su mismo valor. Como hemos visto, ya que todos los bits serán los mismos al usar el mismo registro del procesador o variable de memoria como primer y segundo operando para la XOR, todos los bits quedarán a cero para indicar que todos eran iguales.