Javascript 在保持顺序和现有实例的同时，使用另一个数组的元素对数组进行变异

需要关于一种算法的帮助，该算法采用两个数组，并在它们之间进行特定比较，从而保持相同的顺序：

• 若_ID存在但_ID不在覆盖器中，则不在结果中包含元素
• 若_ID在覆盖器中，但_ID不在现有中，则将元素添加到结果中
• 如果_ID同时位于existing和overwriter中，则将版本/实例为_ID的元素从existing添加到result中

大写字母代表参考号 v#表示引用ID的版本/实例

一,

现有：[Av1 Bv1 Cv1 Ev1 Fv1 Gv1]

覆盖器：[Bv2 Dv1 Fv2 Hv1 Jv1]

结果：[Bv1 Dv1 Fv1 Hv1 Jv1]

二,

现有：[Bv1 Cv1 Ev1 Fv1 Gv1]

覆盖器：[Av1 Bv2 Dv1 Fv2 Hv1 Jv1]

结果：[Av1 Bv1 Dv1 Fv1 Hv1 Jv1]

三,

现有：[Av1 Bv1 Cv1 Ev1 Fv1 Gv1]

覆盖程序：[Av2 Bv2 Dv1 Fv2 Hv1 Jv1]

结果：[Av1 Bv1 Dv1 Fv1 Hv1 Jv1]

四,

现有：[Cv1 Dv1 Ev1]

覆盖器：[Av1 Bv1 Dv2 Fv1 Hv1 Jv1]

结果：[Av1 Bv1 Dv1 Fv1 Hv1 Jv1]

五,

现有：[Av1 Bv1 Cv1 Ev1 Fv1 Gv1]

覆盖程序：[Dv1]

结果：[Dv1]

我正在寻找一个log（n）函数，它在一个过程中执行这个变异操作（可能对现有的和覆盖器都使用透视索引，但我不确定）

不想使用indexOf

这是我的日志（n^2）解决方案，使用收缩尾技术：

let eIndx = 0,
    existing = [ Av1, Bv1, Cv1, Ev1, Fv1, Gv1 ],
    overwriter = [ Bv2, Dv1, Fv2, Hv1, Jv1 ];

overwriter.map( element => {

    while( element._ID !== existing[ eIndx ]._ID && 
           eIndx       !== existing.length ) {

        delete existing[ eIndx ];

        ++eIndx;
    }

    return eIndx !== existing.length ? existing[ eIndx ] : element;
});

如果覆盖器中没有现有的_ID，则此解决方案速度最慢

我不确定是应该遍历现有数组还是重写器数组

在我的扩展（更复杂）解决方案中，我解释了这篇文章，我迭代了覆盖器，我有一个哈希字典来引用数组的未来是否已经存在一个_ID/版本组合（稍后还没有迭代的索引）。我不能再使用那个全局字典了，我正在试图弄清楚是否需要为每个数组实例创建一个本地字典，或者是否有一种方法我不需要字典，只需要使用枢轴进行比较。我在log（n）解决方案中看到的一个问题是，在不遍历所有现有数组的情况下，它不知道覆盖器的第一个元素是否是新的_ID

大多数情况下，我是在寻找一些尽可能快的东西

非常感谢您提供的帮助。

您可以使用a并检查id是否存在

函数合并（现有，覆盖器）{
const getId=s=>s.split（'v'）[0]；//或任何合适的
var版本=新地图；
现有的.forEach（s=>versions.set（getId，s））；
返回overwriter.map（s=>versions.get（getId））|s）；
}
log（合并（['Av1'，'Bv1'，'Cv1'，'Ev1'，'Fv1'，'Gv1']，['Bv2'，'Dv1'，'Fv2'，'Hv1'，'Jv1']）
.as console wrapper{max height:100%！important；top:0；}
您可以使用并检查id是否存在


函数合并（现有，覆盖器）{
const getId=s=>s.split（'v'）[0]；//或任何合适的
var版本=新地图；
现有的.forEach（s=>versions.set（getId，s））；
返回overwriter.map（s=>versions.get（getId））|s）；
}
log（合并（['Av1'，'Bv1'，'Cv1'，'Ev1'，'Fv1'，'Gv1']，['Bv2'，'Dv1'，'Fv2'，'Hv1'，'Jv1']）
.as console wrapper{max height:100%！important；top:0；}
我将此答案作为讨论的基础，尽管我知道它并不完全满足您的需要

它是递归的，这在Javascript中可能仍然意味着它很慢或者可能会溢出堆栈。不过，它已经为尾部调用优化做好了准备，所以最终不会太慢。但是由于是递归的，代码非常干净。然而，这是基于我从你的例子中做出的假设，即列表已排序


const-original=[{{u-ID:2，val:“a0”}，{u-ID:3，val:“a1”}，{u-ID:5，val:“a2”}，{u-ID:7，val:“a3”}，{u-ID:11，val:“a4”}，{u-ID:13，val:“a5”}，{u-ID:17，val:“a6”}，{u-ID:19，val:“a7”}]
const overwriter=[{uid:1，“val”：“b0”}，{uid:2，“val”：“b1”}，{uid:3，“val”：“b2”}，{uid:5，“val”：“b3”}，{uid:8，“val”：“b4”}，{uid:13，“val”：“b5”}，{uid:21，“val”：“b6”}，{ID:34，“val”：“b7”}]
const mergeLists=（a，b，combined=[]）=>a.length==0
? 合并。concat（b）
：b.length==0
? 合二为一
：a[0]。\u IDlog（mergeLists（original，overwriter））
我将此答案作为讨论的基础，尽管我知道它并不完全满足您的需要

它是递归的，这在Javascript中可能仍然意味着它很慢或者可能会溢出堆栈。不过，它已经为尾部调用优化做好了准备，所以最终不会太慢。但是由于是递归的，代码非常干净。然而，这是基于我从你的例子中做出的假设，即列表已排序


const-original=[{{u-ID:2，val:“a0”}，{u-ID:3，val:“a1”}，{u-ID:5，val:“a2”}，{u-ID:7，val:“a3”}，{u-ID:11，val:“a4”}，{u-ID:13，val:“a5”}，{u-ID:17，val:“a6”}，{u-ID:19，val:“a7”}]
const overwriter=[{uid:1，“val”：“b0”}，{uid:2，“val”：“b1”}，{uid:3，“val”：“b2”}，{uid:5，“val”：“b3”}，{uid:8，“val”：“b4”}，{uid:13，“val”：“b5”}，{uid:21，“val”：“b6”}，{ID:34，“val”：“b7”}]
const mergeLists=（a，b，combined=[]）=>a.length==0
? 合并。concat（b）
：b.length==0
? 合二为一
：a[0]。\u ID