How to reduce the execution time of this javascript code to calculate friendly numbers?

You are doing the calculation multiple times divisorthat it is a quite heavy function.

In my solution I first create a Objetowith the calculation of all divisors. Then with the calculations done I proceed to look for friends.

    console.time();
    
    var num1 = 0;
    var num2 = 10000;
    
    
    const divisor = (x) => {
      let suma = 0;
      
      for(let k=1;k<= Math.floor(x/2) + 1; k++){
        if(x%k ==0){
          suma = suma + k;
        }
      }
      return suma;
    }
    
    /**
     * Make sure input is value
     * num1 < num2
     * num1 < 100000 
     * num2 < 100000
     */
    
    
    /**
     * Create a map with all computed divisor sums
     * {
     *  220: 284,
     *  284: 220
     * }
     */
    
    const array = [1,2,3,4]
    const map = {}
    
    for (let i = num1; i<num2; i++) {
      map[i] = divisor(i)
    }
    
    /**
     * Create new array only with values that find friends
     */
    const friends = Object.keys(map)
    .reduce((acc, curr) => {
    
      const key = parseInt(curr, 10)
      const value = map[key]
    
      if (key === map[value]) {
        delete map[key]
        delete map[value]
        acc.push([key, value])
      }
    
      return acc
    }, [] )
    .filter((friend) => {
      return friend[0] !== friend[1]
    })
    .forEach((friend) => {
      console.log(`Los numeros ${friend[0]} y ${friend[1]} són amigos`)
    })
    
    console.timeEnd()

I can think of two ways to streamline the algorithm.

1. Calculation of the sum of divisors
   We can go through the numbers of 1a Math.sqrt(x), being xthe number of which we want the sum of the divisors. We know that the largest
   divisor of will be , if it is even. So we don't need to iterate through the numbers in a .xx / 2xx / 2x

const calcSumOfDiv = x => {
    // La suma empieza en 1, porque siempre será un divisor.
    let sum = 1;
    // El loop empezará en 2 (para no repetir el 1)
    // Y llegará hasta Math.sqrt(x). Haciendo el cuadrado de i, es lo mismo.
    for (let i = 2; i * i < x; ++i) {
        if (x % i === 0) {
            sum += i;

            // Debemos también contemplar el caso de los mayores
            // por la propiedad conmutativa.
            // Siendo x par, si i = 2, i es divisor y también x / 2.
            // Así que sumamos ambos.
            // Excepto el caso de cuadrados perfectos
            if (x / i !== i) {
                sum += x / i;
            }
        }
    }

    return sum;
}

2. Calculation storage
   On the other hand, since in the algorithm we have two loops , it means that we are doing calculations of duplicate divisors.

for(let a = 2; a < LENGTH; a++) {
    for(let b = a; b < LENGTH; b++) {
        // En la primera iteración del loop interno,
        // La suma de divisores de a ya se ha calculado, pero b = a y se vuelve a calcular para a
    }
    // En la siguiente vuelta, a será a + 1, pero la suma de divisores de a + 1
    // ya la tenemos calculada cuando recorrimos el loop en b.
}

Therefore, we can store the calculations already made to reuse them the next time they are needed. So the sum of divisors of each number is only calculated once.

// Aquí guardamos los cálculos. La clave es el número y el valor su suma de divisores
const map = {
    1: 1
};

// Cuando querramos sacar el cálculo, primero vemos si lo tenemos ya.
// Si NO es el caso, lo calculamos y lo guardamos.
const sumOfDiv = x => {
    if (!map[x]) map[x] = calcSumOfDiv(x);
    return map[x];
}

This is how the entire script would look.

const LENGTH = 10000;

const map = {
    1: 1
};

const calcSumOfDiv = x => {
    let sum = 1;
    for (let i = 2; i * i < x; ++i) {
        if (x % i === 0) {
            sum += i;
            if (x / i !== i) {
                sum += x / i;
            }
        }
    }

    return sum;
}

const sumOfDiv = x => {
    if (!map[x]) map[x] = calcSumOfDiv(x);
    return map[x];
}

const areAmicable = (x, y) =>
    x !== y &&
    sumOfDiv(x) === y &&
    sumOfDiv(y) === x;

for(let a = 2; a < LENGTH; a++) {
    for(let b = a; b < LENGTH; b++) {
        if (areAmicable(a, b)) {
            console.log(`${a} and ${b} are amicables.`);
        }
    }
}

The result is a bit immediate.

220 and 284 are friendly.
1184 and 1210 are friendly.
2620 and 2924 are friendly.
5020 and 5564 are friendly.
6232 and 6368 are friendly.
algorithm: 203.038ms

In 200ms , approximately.

I hope it works.