Javascript-如何以特定的排序顺序混合两个对象数组？

我有两个对象数组。大概是这样的：

var arrayA=[
{
键入：“卡”，
身份证号码：1
},
{
键入：“卡”，
身份证号码：2
},
{
键入：“卡”，
身份证号码：3
},
{
键入：“卡”，
身份证号码：4
},
{
键入：“卡”，
身份证号码：5
},
];
var arrayB=[
{
键入：“专业提示”，
身份证号码：10
},
{
键入：“专业提示”，
身份证号码：11
},
];

我想合并这两个对象数组，但要按特定顺序。基本上，我想要的是，在

arrayA

中的每N个元素之后，我想要添加

arrayB

中的一个元素。如果

N==2

则最终数组如下所示：

var finalArray=[
{
键入：“卡”，
身份证号码：1
},
{
键入：“卡”，
身份证号码：2
},
{
键入：“专业提示”，
身份证号码：10
},
{
键入：“卡”，
身份证号码：3
},
{
键入：“卡”，
身份证号码：4
},
{
键入：“专业提示”，
身份证号码：11
},
{
键入：“卡”，
身份证号码：5
},
];

也许这样做并不困难，但我正在寻找一种最优雅的方法来构建一个帮助函数

---

编辑：

这是我创建的函数。这似乎是可行的，但可能有一种更简单的方法：

函数合并步骤（arrayA、arrayB、nSteps、nElementsToAdd）{
var finalArray=[]，
StepScont=0，
elementsToAddCount=0，
arrayBNumberOfElements=arrayB.length；
arrayA.forEach（功能（obj）{
最终推送（obj）；
STEPSOUNT++；
if（StepScont==nSteps&&elementsToAddCount

您可以使用插入想要的项目并从末尾迭代

arrayB

，因为每次拼接都会在插入索引之后更改索引

var arrayA=[{type:'card'，id:1}，{type:'card'，id:2}，{type:'card'，id:3}，{type:'card'，id:4}，{type:'card'，id:5}]，
arrayB=[{type:'pro-tip'，id:10}，{type:'pro-tip'，id:11}]，
地点=2，
i=阵列长度；
而(i){
拼接（i*place，0，arrayB[--i]）；
}
控制台日志（arrayA）
.as console wrapper{max height:100%！important；top:0；}
您可以用于插入想要的项并从末尾迭代
arrayB
，因为每次拼接都会在插入索引之后更改索引


var arrayA=[{type:'card'，id:1}，{type:'card'，id:2}，{type:'card'，id:3}，{type:'card'，id:4}，{type:'card'，id:5}]，
arrayB=[{type:'pro-tip'，id:10}，{type:'pro-tip'，id:11}]，
地点=2，
i=阵列长度；
而(i){
拼接（i*place，0，arrayB[--i]）；
}
控制台日志（arrayA）
.as控制台包装{max height:100%！important；top:0；}
这是我使用
for

countA = arrayA.length;
countB = arrayB.length;
merged = [];

for (var i = 0, j = 0, m = 0; i < countA; i ++, m ++) {
    if (i > 0 && i%2 == 0 && typeof arrayB[j] !== 'undefined') {
        merged[m] = arrayB[j];
        j ++;
        m ++;
    }
    merged[m] = arrayA[i];
}
// if you'd like to place all remaining arrayB elements after arrayA is exhausted
if (countB > j) {
    for (i = j; i < countB; i++, m ++) {
        merged[m] = arrayB[i];
    }
}

countA=arrayA.length；
countB=阵列长度；
合并=[]；
对于（变量i=0，j=0，m=0；i0&&i%2==0&&typeof-arrayB[j]！==‘未定义’）{
合并[m]=arrayB[j]；
j++；
m++；
}
合并[m]=arrayA[i]；
}
//如果要在arrayA耗尽后放置所有剩余的arrayB元素
如果（计数b>j）{
对于（i=j；i
这是我使用
for

countA = arrayA.length;
countB = arrayB.length;
merged = [];

for (var i = 0, j = 0, m = 0; i < countA; i ++, m ++) {
    if (i > 0 && i%2 == 0 && typeof arrayB[j] !== 'undefined') {
        merged[m] = arrayB[j];
        j ++;
        m ++;
    }
    merged[m] = arrayA[i];
}
// if you'd like to place all remaining arrayB elements after arrayA is exhausted
if (countB > j) {
    for (i = j; i < countB; i++, m ++) {
        merged[m] = arrayB[i];
    }
}

countA=arrayA.length；
countB=阵列长度；
合并=[]；
对于（变量i=0，j=0，m=0；i0&&i%2==0&&typeof-arrayB[j]！==‘未定义’）{
合并[m]=arrayB[j]；
j++；
m++；
}
合并[m]=arrayA[i]；
}
//如果要在arrayA耗尽后放置所有剩余的arrayB元素
如果（计数b>j）{
对于（i=j；i
如果不修改初始数组，则可以使用
reduce


const arrayA=[
{
键入：“卡”，
身份证号码：1
},
{
键入：“卡”，
身份证号码：2
},
{
键入：“卡”，
身份证号码：3
},
{
键入：“卡”，
身份证号码：4
},
{
键入：“卡”，
身份证号码：5
},
];
常数arrayB=[
{
键入：“专业提示”，
身份证号码：10
},
{
键入：“专业提示”，
身份证号码：11
},
];
常数res=arrayA.reduce（（acc，a，i）=>{
常数b=arrayB[（i+1）/2-1]；
返回[…acc，a，…（b？[b]：[]）]；
}, []);
控制台日志（res）
如果不修改初始数组，则可以使用
reduce


const arrayA=[
{
键入：“卡”，
身份证号码：1
},
{
键入：“卡”，
身份证号码：2
},
{
键入：“卡”，
身份证号码：3
},
{
键入：“卡”，
身份证号码：4
},
{
键入：“卡”，
身份证号码：5
},
];
常数arrayB=[
{
键入：“专业提示”，
身份证号码：10
},
{
键入：“专业提示”，
身份证号码：11
},
];
常数res=arrayA.reduce（（acc，a，i）=>{
常数b=arrayB[（i+1）/2-1]；
返回[…acc，a，…（b？[b]：[]）]；
}, []);
控制台日志（res）请在问题中添加一些不太优雅的代码，您已经尝试过了。您应该首先查找如何合并两个数组，然后查找如何根据特定对象属性对数组进行排序Hi@NinaScholz抱歉，忘记提供示例。刚才添加了我到目前为止的函数。请在问题中添加一些不太优雅的代码，您已经尝试过了。您应该首先查找如何合并两个数组，然后查找如何根据特定对象属性对数组进行排序Hi@NinaScholz抱歉，忘了提供示例。刚刚添加了我到目前为止的功能。很好！我完全忘记了可以使用
array.splice