Fatal编程技术网
  • javascript/
  • Javascript 按其值之一合并数组

Javascript 按其值之一合并数组

javascript arrays

Javascript 按其值之一合并数组,javascript,arrays,Javascript,Arrays,我想根据以下名为=timeArray的数组从两个不同的数组中筛选 ["13:37", "13:36", "13:35", "13:34", "13:33", "13:32"] 第一个数组如下所示array1 [ [23323.25,23323.65,23313.25,23315.05,97,62,"13:36"], [23315.05,23315.2,23

我想根据以下名为=timeArray的数组从两个不同的数组中筛选

["13:37", "13:36", "13:35", "13:34", "13:33", "13:32"]
第一个数组如下所示array1

[
[23323.25,23323.65,23313.25,23315.05,97,62,"13:36"],
[23315.05,23315.2,23314,23315,8,9,"13:37"]
]
第二个数组看起来像这样array2

  [
 
    [23310,23310,23300,23300,0,0,"13:34"],
    [23309.75,23343.1,23305,23323.25,0,0,"13:35"],
    [23296.5,23310,23294.65,23309.8,0,0,"13:30"],
    [23308.35,23310,23301,23306.15,0,0,"13:31"],
    [23308,23309,23292.5,23299.55,0,0,"13:32"],
    [23299.55,23310,23294.15,23310,0,0,"13:33"],
    [23310,23310,23300,23300,0,0,"13:34"],
    [23309.75,23343.1,23305,23324.65,0,0,"13:35"],
    [23308,23309,23292.5,23299.55,0,0,"13:36"]
    ]
基于时间数组元素，首先应检查数组1，然后检查数组2第6个元素，预期结果如下

  [
    [23308,23309,23292.5,23299.55,0,0,"13:32"],
    [23299.55,23310,23294.15,23310,0,0,"13:33"],
    [23310,23310,23300,23300,0,0,"13:34"],
    [23309.75,23343.1,23305,23324.65,0,0,"13:35"],
    [23323.25,23323.65,23313.25,23315.05,97,62,"13:36"],
    [23315.05,23315.2,23314,23315,8,9,"13:37"]
 ]
我试过下面的方法

var finalarray = [];
for(var key in timeArray)
{
  var timer = timeArray[key];
  for(var key in array1)
  {
    arraytime1 = array1[key][6];
    if(timer == arraytime1)
    {
      finalarray.push(arraytime1);
    }
  }

  for(var key in array2)
  {
    arraytime2 = array2[key][6];
    if(timer == arraytime2)
    {
      finalarray.push(arraytime2);
    }
  }
}
但是
“13:36”
被添加了两次…如果基于timeraray的元素不存在，则它应该为空。。。还有更好的方法吗？我觉得这需要很多资源来处理。。。谢谢。

我相信这就是你想要的

const base=[“13:37”、“13:36”、“13:35”、“13:34”、“13:33”、“13:32”]
常数arrayA=[
[23323.25,23323.65,23313.25,23315.05,97,62,"13:36"],
[23315.05,23315.2,23314,23315,8,9,"13:37"]
]
常数arrayB=[
[23310,23310,23300,23300,0,0,"13:34"],
[23309.75,23343.1,23305,23323.25,0,0,"13:35"],
[23296.5,23310,23294.65,23309.8,0,0,"13:30"],
[23308.35,23310,23301,23306.15,0,0,"13:31"],
[23308,23309,23292.5,23299.55,0,0,"13:32"],
[23299.55,23310,23294.15,23310,0,0,"13:33"],
[23310,23310,23300,23300,0,0,"13:34"],
[23309.75,23343.1,23305,23324.65,0,0,"13:35"],
[23308,23309,23292.5,23299.55,0,0,"13:36"]
]
//常数expectedResult=[
//  [23308,23309,23292.5,23299.55,0,0,"13:32"],
//  [23299.55,23310,23294.15,23310,0,0,"13:33"],
//  [23310,23310,23300,23300,0,0,"13:34"],
//  [23309.75,23343.1,23305,23324.65,0,0,"13:35"],
//  [23323.25,23323.65,23313.25,23315.05,97,62,"13:36"],
//  [23315.05,23315.2,23314,23315,8,9,"13:37"]
//]
const res=base.sort（）.map（时间=>{
返回arrayA.find（subArray=>subArray[subArray.length-1]==time）
||arrayB.find（subArray=>subArray[subArray.length-1]==时间）
||空的
});

控制台日志（res）我将以以下格式修改数组，以获得更快的访问速度：


{
  "13:34": [23310,23310,23300,23300,0,0]
}


然后为每个时间项找到合适的数组

代码：



const timeArray=[“13:37”、“13:36”、“13:35”、“13:34”、“13:33”、“13:32”]
常数数组1=[
[23323.25,23323.65,23313.25,23315.05,97,62,"13:36"],
[23315.05,23315.2,23314,23315,8,9,"13:37"]
]
常数数组2=[
[23310,23310,23300,23300,0,0,"13:34"],
[23309.75,23343.1,23305,23323.25,0,0,"13:35"],
[23296.5,23310,23294.65,23309.8,0,0,"13:30"],
[23308.35,23310,23301,23306.15,0,0,"13:31"],
[23308,23309,23292.5,23299.55,0,0,"13:32"],
[23299.55,23310,23294.15,23310,0,0,"13:33"],
[23310,23310,23300,23300,0,0,"13:34"],
[23309.75,23343.1,23305,23324.65,0,0,"13:35"],
[23308,23309,23292.5,23299.55,0,0,"13:36"]
]
常量值1={}
数组1.forEach（项目=>{
值1[项目[6]]=项目
})
常量值2={}
array2.forEach（项目=>{
值2[项目[6]]=项目
})
常量结果=[]
timeArray.sort（）.forEach（时间=>{
设itemResult=[0,0,0,0,0,0，时间]
如果（值1[时间]）{
itemResult=值1[时间]
}else if（值2[时间]）{
itemResult=values2[时间]
}
结果。推送（itemResult）
})

log（result）
您可以获取一个对象，用于每次保留第一个数组并映射结果



const
时间数组=[“13:37”、“13:36”、“13:35”、“13:34”、“13:33”、“13:32”]，
数组1=[[23323.2523323.6523313.2523315.05,97,62，“13:36”]，[23315.0523315.2231423315,8,9，“13:37”]，
[23309.75、23343.0、0、0、0、0、0、0、0、0、0、10、23305、23305、23323.25、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、0、1、5、0、0、0、0、0、10、5、0、0、0、0、0、0、23305、0、0、0、0、5、0、5、0、0、5、0、0、5、0、0、0、0、0、5、0、0、0、0、0、0、10、13:31、13:31、13:31“，"13:34"], [23309.75, 23343.1, 23305, 23324.65, 0, 0, "13:35"], [23308, 23309, 23292.5, 23299.55, 0, 0, "13:36"]],
times=[array1，array2]。reduce（（r，array）=>{
array.forEach（a=>r[a[6]]？？=a）
返回r；
}, {}),
结果=时间数组
.sort（）
.map（time=>times[time]|[0,0,0,0,0,0，time]）；
console.log（结果）；


.as控制台包装{max height:100%！important；top:0；}
在我看来，您可以这样做



var finalarray=[]；
for（时间数组中的var键）
{
var timer=timeArray[key]；
for（阵列中的var键2）
{
arraytime2=array2[key][6]；
如果（计时器==arraytime2）
{
最终数组[arraytime2]=array2[key]；
}
}
for（阵列1中的var键）
{
arraytime1=array1[key][6]；
如果（计时器==arraytime1）
{
最终数组[arraytime1]=array1[key]；
}
}
}
在映射项目时，可以使用集合来拥有
O（1）
。因此，我们可以对
timeArray
进行排序，然后只需
map（）
项目：


const unique_1 = new Map(array1.map(s => [s[6], s]));
const unique_2 = new Map(array2.map(s => [s[6], s]));

const result = timeArray
                  .sort()
                  .map(time => unique_1.get(time) || unique_2.get(time));


例如：



const timeArray=[“13:37”、“13:36”、“13:35”、“13:34”、“13:33”、“13:32”]
常数数组1=[
[23323.25, 23323.65, 23313.25, 23315.05, 97, 62, "13:36"],
[23315.05, 23315.2, 23314, 23315, 8, 9, "13:37"]
]
常数数组2=[
[23310, 23310, 23300, 23300, 0, 0, "13:34"],
[23309.75, 23343.1, 23305, 23323.25, 0, 0, "13:35"],
[23296.5, 23310, 23294.65, 23309.8, 0, 0, "13:30"],
[23308.35, 23310, 23301, 23306.15, 0, 0, "13:31"],
[23308, 23309, 23292.5, 23299.55, 0, 0, "13:32"],
[23299.55, 23310, 23294.15, 23310, 0, 0, "13:33"],
[23310, 23310, 23300, 23300, 0, 0, "13:34"],
[23309.75, 23343.1, 23305, 23324.65, 0, 0, "13:35"],
[23308, 23309, 23292.5, 23299.55, 0, 0, "13:36"]
]
const unique_1=新映射（array1.Map（s=>[s[6]，s]）；
const unique_2=新映射（array2.Map（s=>[s[6]，s]）；
常量结果=时间数组
.sort（）
.map（time=>unique_1.get（time）| | unique_2.get（time））；

console.log（result）
您没有解释如何从前两个数组计算结果数组。如果array1和array2中都有匹配项，那么