Javascript 在数组元素之间插入对象最优雅的方式是什么？

我相信有很多方法可以做到这一点，但我正在寻找一些“优雅”的东西

欢迎所有建议。：）

Array.splice（）

应该这样做：

a.splice（1,0，{value:255}）

---

第一个参数是要删除或插入元素的位置，第二个是删除计数，第三个（可选）是要插入的新元素。

普通循环似乎是最好的：

function intersperse(arr, el) {
    var res = [], i=0;
    if (i < arr.length)
        res.push(arr[i++]);
    while (i < arr.length)
        res.push(el, arr[i++]);
    return res;
}

函数插入对象（arr，obj）{
var结果=[]；
函数插入（元素、索引）{
结果：推（元素）；
如果（索引+1

您可以使用flatMap完成此操作。例如，可以从

_.flatMap([1,2,3,4], (value, index, array) =>
     array.length -1 !== index // check for the last item
     ? [value, "s"]
     : value
);

输出

[1, "s", 2, "s", 3, "s", 4]

更新 Array#flatMap正在开发中，因此在将来应该可以使用：

[1, 2, 3, 4].flatMap(
    (value, index, array) =>
        array.length - 1 !== index // check for the last item
            ? [value, "s"]
            : value,
);

---

在我看来，最优雅的方法是：

ES6语法版本

const insertIntoArray = (arr, value) => {

    return arr.reduce((result, element, index, array) => {

        result.push(element);

        if (index < array.length - 1) {
            result.push(value);
        }

        return result;
    }, []);
};

不变解 减少数组时，reduce函数不应改变数组，而应返回一个新值（在本例中为新数组）。这样，更改将只应用于返回的数组，而不是原始数组，并且可以避免副作用

const insertBetween = (insertee, array) => array.reduce(
    (acc, item, i, { length }) => {
        if (i && i < length) {
            return [...acc, insertee, item];
        }
        return [...acc, item];
    },
    []
);

const insertBetween=（inserte，array）=>array.reduce(
（acc，项目，i，{length}）=>{
if（i&&i<长度）{
返回[…附件、插入物、项目]；
}
返回[…附件，项目]；
},
[]
);

您可以使用reduce实现这一点（它也是不可变的）

const insertBetween=（插入，数组）=>
array.reduce(
（新数组，成员，i，数组）=>
i//]

按照卡门的建议使用拼接，您可以执行以下操作：

const numSeparators = arr.length - 1;
for (let i = 1; i <= numSeparators; i++) {
    const index = (i * 2) - 1;
    arr.splice(index, 0, { value: 255 });
}

const numparators=arr.length-1；
对于（设i=1；iES6:

对于简单的纯功能性方法，我建议这样做：

const magicArrayJoin = (array, el) =>
  array.length ?
    array.slice(1).reduce((acc, cur) => acc.concat([el, cur]), [array[0]]) :
    []

p、 n.这种方式不是javascript中性能最好的一种，它的方法是：

创建一个新列表，在元素之间插入分隔符

代码：

结果:

[
    'one',
    {name: 'separator'},
    'two',
    {name: 'separator'},
    'three'
]

一个使用普通ES6的衬里：

const interleave=（arr，thing）=>[].concat（…arr.map（n=>[n，thing]））.slice（0，-1）

用法：

insertIntoArray([1, 2, 3], 'x'); // => [1, 'x', 2, 'x', 3]

interleave（['foo'，'bar'，'baz'，'avocado'））

印刷品：

> ["foo", "avocado", "bar", "avocado", "baz"]

使用ES6功能

const insertBetween = (ele, array) => {
  return array.flatMap((x) => [ele, x]).slice(1);
};

insertBetween('+', [1, 2, 3]);

“magicArrayJoin”到底应该做什么？它是以一定的规则间隔插入第二个参数，还是仅在每个项目之间插入第二个参数？@Pointy我认为这不是dup。OP不是问如何在某个位置将元素插入数组。他们问的是如何在每个元素之间的数组中插入元素。@cimak你是问如何不插入o插入一个对象（重复）在数组中的所有元素之间，如您的示例中所示？或者您正在询问如何在数组中的元素之间插入多个对象，如问题标题中所示？另外，是否要求您就地修改数组或创建新数组是一个选项？我想在每个项之间插入相同的对象。修改现有的或创建新的数组好的，但我需要多次调用它，每次递增索引。@cimak
for（var I=0；I
@Vidul那将是非常低效的。@Ghazgkull肯定：）我认为这是对大量中间数组的实例化。在支持尾部调用优化的引擎中，您可以使用LISPy方法来实现：
（insertee，array）=>array.length您需要
array.slice（1）
，否则
array[0]
插入两次有点奇怪，没有一个更有效的内置lodash函数来实现这一点很明显，当reduce比Bergi两年前的完美且更有效的答案有更多的投票时，使用reduce有一种非理性的偏向@Andy这就是为什么最初的问题问到了一种优雅的方法就优雅胜过性能而言，Bergi回答中的
concatMap
示例对我来说似乎很优雅，但以这种方式使用
reduce
却没有
R.intersperse({name: 'separator'}, ['one', 'two', 'three']);

[
    'one',
    {name: 'separator'},
    'two',
    {name: 'separator'},
    'three'
]

> ["foo", "avocado", "bar", "avocado", "baz"]

const insertBetween = (ele, array) => {
  return array.flatMap((x) => [ele, x]).slice(1);
};

insertBetween('+', [1, 2, 3]);