Łączenie 2 tablic, sumowanie tych samych elementow, dodawanie nowych

Hej.

Mam sobie podstawowa tablice w formacie [ [cena, ilosc], [cena, ilosc],,,]
czyli powiedzmy tablice o dlugosci 1000
[ [1, 10], [1.1, 0.12], [1.11, 12]...]
i dostaje druga tablice o dlugosci powiedzmy 4 w tym samym formacie.
[ [1, 10], [1.1, 0.12], [1.11, 12]...]

I teraz chcialbym:

1. usunac z podstawowej tablicy arraye, ktore maja ta sama cene ale ilosc 0 w nowej tablicy,
**2.**Natomiast jesli w podstawowej tablicy jest array z taka sama cena to ustawic nowa ilosc z drugiej tablicy, jezeli natomiast nie ma arraya z taka sama cena, to dodac ten elemet z drugiej tablicy.1.

Jak to zrobic najszybciej? Szybsze bedzie stary dobry sposob z petla po 1 i 2 tablicy czy wykorzystac filter etc?
Pierwsza czesc zadania (to z usunieciem ilosci 0 zrobilem tak:

podstawowyArr = podstawowyArr.filter(val => drugiArr.indexOf(val[0] == -1);

Zastanawiam sie natomiast jak zrobic 2 czesc zadania bo jest troszke bardziej skaplikowana. mozna jakos porownac te 2 tablice przez reduce czy to jest bardziej do transformacji pojedynczej tablicy?

Czy taka sama cena znaczy ten sam produkt, skoro piszesz, że usunac z podstawowej tablicy arraye (liczba mnoga)? Jeśli tak, to czy można jedno zastąpć drugim:

[[1, 2], [1, 3], [1, 1]]

vs

[[1, 6]]

?

@Maciej Cąderek: nie w arrayu nigdy nie bedzie tej samej ceny. Zawsze beda rozne ceny co najwyzej ilosci moga byc te same.

Ok, to w taki razie wygląda na to, że najlepiej by było użyć Map, coś w stylu:

const input = [[1, 10], [1.1, 0.12], [1.11, 12]]
const updates = [[1, 4], [1.1, 0], [1.11, 7]]

const map = new Map(input)

// Bez usuwania, tylko updaty (w tym zerowanie):
updates.forEach(item => map.set(...item))
// Z usuwaniem:
updates.forEach(([price, amount]) => amount === 0 ? map.delete(price) : map.set(price, amount))

Forma zależy od tego jaki ma być oczekiwany wynik w zadaniu.

Napisałem po staremu:

        ordersToAddAsks.forEach(newEl => {
            let exist = false;
            objToUpdate.asks.forEach(el => {
                if(el[0] == newEl[0])
                {
                    el[0] = Number(newEl[0]);//parse from string to number
                    el[1] = Number(newEl[1]);
                    exist = true;
                }
            })
            if(!exist)
            {
                newEl[0] = Number(newEl[0]);
                newEl[1] = Number(newEl[1]);
                objToUpdate.asks.push(newEl);
            }
        })

Nie wiedziałem nawet ze jest cos takiego jak Map :> Jutro o tym poczytam i przetestuje jak to wyglada czasowo, dam znac.
Dzieki za kawalek czystego kodu :)

Tylko pytanie, orginalna tablica pozostanie tablica ze zmienionymi/usunietymi/dodanymi elemetami, nie zmieni typu z tablicy na ten obj Map?

Oryginalna tablica pozostanie bez zmian - jak chcesz po zmianach dostać z powrortem tablicę to robisz cuś takiego:

const resultArr = [...map.entries()]
// lub:
const resultArr = Array.from(map.entries())

Btw,
twoje rozwiązanie ma złożoność czasową O(n²), użycie Map pozwala na O(n), benchmark:

const b = require("benny");

const size = 10000;
const input = Array.from({ length: size }, (_, i) => [i, i + 1]);
const updates = Array.from({ length: size }, (_, i) => [i, i + 2]);

b.suite(
  "Map vs Array",

  b.add(`Array - ${size} updates on the data with ${size} items`, () => {
    updates.forEach((newEl) => {
      let exist = false;
      input.forEach((el) => {
        if (el[0] == newEl[0]) {
          el[0] = Number(newEl[0]);
          el[1] = Number(newEl[1]);
          exist = true;
        }
      });

      if (!exist) {
        newEl[0] = Number(newEl[0]);
        newEl[1] = Number(newEl[1]);
        input.push(newEl);
      }
    });
  }),

  b.add(`Map - ${size} updates on the data with ${size} items`, () => {
    const map = new Map(input);
    updates.forEach((item) => map.set(...item));
  }),

  b.cycle(),
  b.complete()
);

Running "Map vs Array" suite...
Progress: 100%

  Array - 10000 updates on the data with 10000 items:
    3 ops/s, ±1.91%     | slowest, 99.56% slower

  Map - 10000 updates on the data with 10000 items:
    689 ops/s, ±1.16%   | fastest

Finished 2 cases!
  Fastest: Map - 10000 updates on the data with 10000 items
  Slowest: Array - 10000 updates on the data with 10000 items