Atomics.xor() en JavaScript

¿Qué es la atómica?

• Atomics es un objeto en JavaScript que brinda la capacidad de realizar operaciones atómicas como métodos estáticos.
• Al igual que el objeto Math en JavaScript, todas las propiedades y métodos de Atomics también son estáticos.
• Los elementos atómicos se utilizan con objetos SharedArrayBuffer (búfer genérico de datos binarios de longitud fija).
• Los átomos no son constructores como otros objetos globales.
• Atomics no se puede usar con un nuevo operador o se puede invocar como una función.

Operaciones atómicas en JavaScript
Múltiples subprocesos pueden leer y escribir los mismos datos en la memoria cuando hay memoria compartida. Para garantizar que los valores predichos se escriban y lean con precisión, no se puede iniciar otra operación hasta que finalice la actual. Las operaciones atómicas tampoco se pueden interrumpir.

Método Atomics.xor()

• Entre las operaciones atómicas, hay una operación incorporada Atomics.xor() en JavaScript que se usa para calcular un XOR bit a bit con un valor dado en una posición dada en la array.
• La operación Atomics.xor() devuelve el valor anterior en esa posición.
• El tipo enterodarray, el índice y el valor se pasan como argumento a la función y devuelve el valor que se ha almacenado en la array respectiva.

Sintaxis:

Atomics.xor(typedArray, index, value)

Parámetros utilizados:

1. typedarray: es la array de tipo entero compartida Int8Array , Uint8Array , Int16Array , etc.
2. index: es la posición en typedArray para calcular XOR bit a bit.
3. valor: El número con el que calcular XOR bit a bit.

Valor devuelto:
Atomics.xor() devuelve el valor anterior en la posición dada (typedArray[index]).

A continuación se dan ejemplos de la función anterior:

Ejemplos:

Input : arr[0] = 7
        Atomics.xor(arr, 0, 2)
Output : 5

Input : arr[0] = 4
        Atomics.xor(arr, 0, 3)
Output : 7

El código para la función anterior se proporciona a continuación:

Código 1:

<script>
    // creating a SharedArrayBuffer
    var buf = new SharedArrayBuffer(16);
var arr = new Uint8Array(buf);
  
// Initialising element at zeroth position of array with 7
arr[0] = 7;
  
// Displaying the SharedArrayBuffer
console.log(Atomics.load(arr, 0));
  
// Displaying the return value of the Atomics.xor() method
console.log(Atomics.xor(arr, 0, 2));
  
// Displaying the updated SharedArrayBuffer
console.log(Atomics.load(arr, 0));

PRODUCCIÓN:

7
5
5

Código 2:

<script>
    // creating a SharedArrayBuffer
    var buf = new SharedArrayBuffer(25);
var arr = new Uint8Array(buf);
  
// Initialising element at zeroth position of array with 3
arr[0] = 3
  
         // Displaying the SharedArrayBuffer
         console.log(Atomics.load(arr, 0));
  
// Displaying the return value of the Atomics.xor() method
console.log(Atomics.xor(arr, 0, 5));
  
// Displaying the updated SharedArrayBuffer
console.log(Atomics.load(arr, 0));

PRODUCCIÓN:

3
6
6

Aplicación:
Cada vez que queremos calcular XOR bit a bit con cualquier valor y queremos devolver el valor calculado, usamos la operación Atomics.xor() en JavaScript.

Veamos un programa JavaScript:

<script>
    // creating a SharedArrayBuffer
    var mybuffer = new SharedArrayBuffer(25);
var myarray = new Uint8Array(mybuffer);
  
// Initialising the element at zeroth position of array
myarray[0] = 15;
  
// Displaying the return value of the Atomics.xor() method
console.log(Atomics.xor(myarray, 0, 10));
  
// Displaying the updated SharedArrayBuffer
console.log(Atomics.load(myarray, 0));

PRODUCCIÓN:

5
5

Excepciones:

• Si typedArray no es uno de los tipos de enteros permitidos, la operación Atomics.xor() genera un TypeError.
• Si typedArray no es una array tipificada compartida, la operación Atomics.xor() genera un TypeError.
• Si el índice utilizado como argumento para la operación Atomics.xor() está fuera del límite en typedArray, entonces la operación Atomics.store() arroja un RangeError.