不可变插入

如果您需要插入到阵列中的适当位置，使用拼接方法无疑是最佳答案。

但是，如果您正在寻找一个不可变函数，该函数返回一个新的更新数组，而不是在插入时对原始数组进行变异，那么可以使用以下函数。

函数插入（数组，索引）{const items=Array.prototype.slice.call（arguments，2）；return[].contat（array.sslice（0，索引），items，array.sslict（索引））；}常量列表=['one'，'two'，'three']；const list1=插入（列表，0，“零”）；//插入单个项目const list2=insert（列表，3，'four'，'five'，'sive'）；//插入多个console.log（'原始列表：'，列表）；console.log（'插入的列表1:'，列表1）；console.log（'插入的列表2:'，列表2）；

注意：这是ES6之前的一种实现方式，因此它适用于较旧和较新的浏览器。

如果您使用的是ES6，那么您也可以尝试其他参数；看看这个答案。

我试过了，效果很好！

var initialArr = ["India","China","Japan","USA"];
initialArr.splice(index, 0, item);

索引是要插入或删除元素的位置。

0，即第二个参数，定义要从索引中删除的元素的数量。项包含要在数组中创建的新条目。它可以是一个或多个。

initialArr.splice(2, 0, "Nigeria");
initialArr.splice(2, 0, "Australia","UK");

以下是现代（字体功能）方式：

export const insertItemInList = <T>(
  arr: T[],
  index: number,
  newItem: T
): T[] => [...arr.slice(0, index), newItem, ...arr.slice(index)]

按以下方式计算减少方法的利润：

function insert(arr, val, index) {
    return index >= arr.length
        ? arr.concat(val)
        : arr.reduce((prev, x, i) => prev.concat(i === index ? [val, x] : x), []);
}

因此，通过这种方式，我们可以返回一个新数组（这将是一种很酷的函数方式，比使用push或splice要好得多），其中元素插入索引处，如果索引大于数组长度，则将在末尾插入。

在特定索引处附加单个元素

// Append at a specific position (here at index 1)
arrName.splice(1, 0,'newName1');
// 1: index number, 0: number of element to remove, newName1: new element


// Append at a specific position (here at index 3)
arrName[3] = 'newName1';

在特定索引处附加多个元素

// Append from index number 1
arrName.splice(1, 0, 'newElemenet1', 'newElemenet2', 'newElemenet3');
// 1: index number from where append start,
// 0: number of element to remove,
//newElemenet1,2,3: new elements

解决方案和性能

今天（2020.04.24），我为大型和小型阵列选择的解决方案进行测试。我在Chrome 81.0、Safari 13.1和Firefox 75.0上的macOS v10.13.6（High Sierra）上测试了它们。

结论

适用于所有浏览器

令人惊讶的是，对于小型阵列，基于切片和归约（D，E，F）的非就地解决方案通常比就地解决方案快10x-100倍对于大型阵列，基于拼接（AI、BI和CI）的就地解决方案是最快的（有时约为100倍，但取决于阵列大小）对于小型阵列，BI解决方案是最慢的对于大型阵列，E解决方案是最慢的

细节

测试分为两组：就地解决方案（AI、BI和CI）和非就地解决方案，分别针对两种情况进行：

测试包含10个元素的数组-可以在此处运行测试具有1000000个元素的数组-可以在此处运行

测试代码显示在以下代码段中：

小提琴演奏家

函数AI（arr，i，el）{arr.splice（i，0，el）；返回arr；}功能BI（arr，i，el）{阵列.原型.拼接.应用（arr，[i，0，el]）；返回arr；}函数CI（arr，i，el）{数组.原型.拼接.调用（arr，i，0，el）；返回arr；}函数D（arr，i，el）{返回arr.slice（0，i）.contat（el，arr.slices（i））；}函数E（arr，i，el）{return[…arr.slice（0，i），el，…arr.slime（i）]}函数F（arr，i，el）{返回arr.reduce（（s，a，j）=>（j-i？s.push（a）：s.push（el，a），s），[]）；}// -------------//测试// -------------设arr=[“a”、“b”、“c”、“d”、“e”、“f”]；设log=（n，f）=>{设a=f（[…arr]，3，“新”）；console.log（`${n}:[${a}]`）；};日志（'AI'，AI）；日志（'BI'，BI）；日志（'CI'，CI）；日志（'D'，D）；对数（'E'，E）；日志（'F'，F）；此代码段仅显示测试代码（不执行测试）

Google Chrome上一个小数组的示例结果如下：