Home / Questions / 361119
Accepted
DAD
Asked: 2020-06-01 16:16:37 +0800 CST 2020-06-01 16:16:37 +0800 CST

How can I do the subtraction between 2 array with js?

  • 772

the problem is the following: I have 2 arraythat I get automatically, which I must do the subtraction between the first and the second but for example position:

var array1 = [9,8,7,6,5]
var array2 = [10,20,30,40,50]
     //       (9-10),(8-20).......

/* objetivo
var array_resta = [-1,-12,-23,-34,-45]*/

//lo que había hecho yo era, meter los 2 array en otro array algo así :

var receptor = new Array();
receptor.push(array1)
receptor.push(array2)

// receptor = [[9,8,7,6,5],[10,20,30,40,50]]
// para luego intentar restar algo así:

let a_resta = new Array();
for (j = 0; j < 5; j++) {
    let resta = 0;
    for (i = 0; i < receptor.length; i++) {
        // if (receptor[i][j] > 0) { //esto solo es una condicion por si uno de los array es de > length
            resta -= receptor[i][j];
        // }
    }
    a_resta.push(resta);
    }
    console.log(a_resta);

// lo unico que hace es hacer la suma y mostrar en negativo(-)

Well then, this is what I have, I'm blank, I don't know if it's a good idea to do the "put" in a array"general" to try to do what I need.

javascript

2 Answers

  1. var array1 = [9,8,7,6,5]
var array2 = [10,20,30,40,50]
 
const res = array2.map((r, i)=> array1[i] ? array1[i] - r : r);
console.log(res);

    First we iterate through any of the two arrays (since both should have the same length) and then we transform values ​​using map, being rthe current element of the array traversed and ithe numerical index, so if there are numbers to compare we subtract array1[i] - rwhich is fair what you need, in case the arrays differ in size we make sure to have a backup, making the result value the second array without subtracting.

    • 4
  2. Best Answer

    I recommend that you use the Array prototype function reduce( from the Vanilla JavaScript build-in ).

    The function reduceis a property, therefore, of each array . It takes as its first argument a callback that will be executed for each element of the array and, optionally, an initial value.

    In your case, your function must return an array with the rest of the elements. For this reason, the initial value that we will pass as an argument will be an empty array[] , to which we are going to insert the result of the subtractions.

    The callback that takes the function as argument reducewill receive the accumulated value (in our case it will be the result array ), the current element of the iteration and, optionally, the index and the original array .

    const first = [9, 8, 7, 6, 5];
const second = [10, 20, 30, 40, 50];

const substract = (first, second) =>
    first.reduce((acc, curr, i) => {
        // acc es el array resultado
        // curr es el elemento actual
        // i es el indice del elemento actual

        // Camculamos el elemento de la resta
        const sub = curr - second[i];

        // Añadimos el elemento al array resultado
        acc.push(sub);

        // Devolvemos el array resultado
        // que será el mismo que nos pasarán
        // por algumento en la siguiente
        // iteración
        return acc;
    }, []);

console.log(substract(first, second)); // [ -1, -12, -23, -34, -45 ]
console.log(substract(second, first)); // [ 1, 12, 23, 34, 45 ]

    The code can really be drastically reduced using the spread operator .

    const substract = (first, second) =>
    first.reduce((acc, curr, i) => [...acc, curr - second[i]], []);

    In the same subtraction you can add the logic of what happens when these two arrays do not have the same length. You should also take into account the order in which you pass the arrays to the same function.

    EDIT: Extend the case of two arrays with different length.

    First, let's add an abstraction layer to the function,

    const merge = (first, second, operation) =>
    first.reduce((acc, curr, i) => [...acc, operation(curr, second[i])], []);

    mergewill result in an array based on two arrays passed by argument. The parameter operationwill be in charge of the calculation and the logic of each element based on the two elements in the same position of both array .

    With that, we refactor the function from before without taking into account that two arrays can have different sizes.

    const substractSameLength = (first, second) => 
    merge(first, second, (op1, op2) => op1 - op2);

    With the abstraction, we can define several ways to get the function substract.

    const substractDiffLength = (first, second) => {
    // Definimos la operación
    // op1 nunca será undefined
    const operation = (op1, op2) => op2 ? op1 - op2 : op1;

    // Calculamos cuál es el array de mayor tamaño
    // para invocar la función merge
    // con el orden correcto de parámetros
    const max = Math.max(first.length, second.length);
    return first.length === max
            ? merge(first, second, operation)
            : merge(second, first, operation);
}

    In this case, the smallest array positions will only be filled with the largest array element at that position.

    I hope it works.

    • 4