如何在特定索引（JavaScript）处将项插入数组？

我正在寻找JavaScript数组插入方法，其样式为：

arr.insert(index, item)

---

最好是在jQuery中，但任何JavaScript实现都可以做到这一点。

您需要的是本机数组对象上的函数

arr.splice（索引，0，项目）

将在指定的

索引

处将

项

插入

arr

（首先删除

0

项，即，这只是插入）

在本例中，我们将创建一个数组，并将一个元素添加到索引2中：

var arr=[]；
arr[0]=“Jani”；
arr[1]=“黑格”；
arr[2]=“过时”；
arr[3]=“Kai Jim”；
arr[4]=“博尔格”；
console.log（arr.join（））；//杰尼、黑格、斯塔尔、凯·吉姆、博格
arr.拼接（2,0，“Lene”）；
console.log（arr.join（））；//Jani、Hege、Lene、Stale、Kai Jim、Borge

如果要同时将多个元素插入数组，请查看以下堆栈溢出答案：

这里还有一些函数来说明这两个示例：

function insertAt(array, index) {
    var arrayToInsert = Array.prototype.splice.apply(arguments, [2]);
    return insertArrayAt(array, index, arrayToInsert);
}

function insertArrayAt(array, index, arrayToInsert) {
    Array.prototype.splice.apply(array, [index, 0].concat(arrayToInsert));
    return array;
}

最后，这里是一个JSFIDLE，您可以自己查看它：

这就是您使用函数的方式：

// if you want to insert specific values whether constants or variables:
insertAt(arr, 1, "x", "y", "z");

// OR if you have an array:
var arrToInsert = ["x", "y", "z"];
insertArrayAt(arr, 1, arrToInsert);

---

您可以通过执行以下操作来实现

数组.insert

方法：

Array.prototype.insert = function ( index, item ) {
    this.splice( index, 0, item );
};

然后你可以像这样使用它：

var arr = [ 'A', 'B', 'D', 'E' ];
arr.insert(2, 'C');

// => arr == [ 'A', 'B', 'C', 'D', 'E' ]

自定义数组

insert

方法 1.具有多个参数和链接支持 它可以插入多个元素（与本机一样），并支持链接：

["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(1, 6);
// ["b", "X", "Y", "Z", "c"]

["a", "b", "c", "d"].insert(2, "V", ["W", "X", "Y"], "Z").join("-");
// "a-b-V-W-X-Y-Z-c-d"

---

2.具有数组类型参数合并和链接支持 它可以将参数中的数组与给定数组合并，还支持链接：

["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(1, 6);
// ["b", "X", "Y", "Z", "c"]

["a", "b", "c", "d"].insert(2, "V", ["W", "X", "Y"], "Z").join("-");
// "a-b-V-W-X-Y-Z-c-d"

---

演示：

尽管已经回答了这个问题，我还是添加了这个注释作为替代方法

我想把一个已知数量的项目放到一个数组中，放到特定的位置，因为它们来自一个“关联数组”（即一个对象），根据定义，这个数组不能保证按排序顺序排列。我希望得到的数组是一个对象数组，但对象在数组中的顺序是特定的，因为数组保证了它们的顺序。所以我做了这个

首先是源对象，一个从PostgreSQL检索的JSONB字符串。我想让它在每个子对象中按“order”属性排序

var jsonb_str = '{"one": {"abbr": "", "order": 3}, "two": {"abbr": "", "order": 4}, "three": {"abbr": "", "order": 5}, "initialize": {"abbr": "init", "order": 1}, "start": {"abbr": "", "order": 2}}';

var jsonb_obj = JSON.parse(jsonb_str);

由于对象中的节点数已知，我首先创建一个具有指定长度的数组：

var obj_length = Object.keys(jsonb_obj).length;
var sorted_array = new Array(obj_length);

然后迭代对象，将新创建的临时对象放置到数组中所需的位置，而不进行任何“排序”

for (var key of Object.keys(jsonb_obj)) {
  var tobj = {};
  tobj[key] = jsonb_obj[key].abbr;

  var position = jsonb_obj[key].order - 1;
  sorted_array[position] = tobj;
}

console.dir(sorted_array);

---

为了实现正确的函数编程和链接，必须发明

Array.prototype.insert（）

。实际上，如果splice返回的是突变的数组，而不是一个完全没有意义的空数组，那么它可能是完美的。就这样了

Array.prototype.insert=函数（i，…rest）{
此.拼接（i，0，…剩余）
还这个
}
var a=[3,4,8,9]；
document.write（“+JSON.stringify（a.insert（2,5,6,7））+”）除了splice，您可以使用这种方法，这种方法不会改变原始数组，而是使用添加的项创建一个新数组。你通常应该尽可能避免突变。我在这里使用ES6扩展运算符

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


const items=[1,2,3,4,5]
常量插入=（arr、索引、新项）=>[
//指定索引之前的数组的一部分
…arr.slice（0，索引），
//插入项
新项目，
//指定索引后数组的一部分
…arr.slice（索引）
]
常量结果=插入（项目1、10）
console.log（结果）
//[1,10,2,3,4,5]
我试过这个，效果很好

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

索引是要插入或删除元素的位置。
0，即第二个参数定义要从索引中删除的元素数
项是要在数组中创建的新项。它可以是一个或多个

const arr = [1, 2, 3, 4, 5];

另一种可能的解决方案是使用
数组#reduce


const arr=[“苹果”、“橘子”、“覆盆子”]；
常数arr2=[1,2,4]；
常量插入=（arr、项目、索引）=>
arr.reduce（函数s、a、i）{
i==索引？s.push（项目，a）：s.push（a）；
返回s；
}, []); 
控制台日志（插入（arr，“香蕉”，1））；
log（insert（arr2，3，2））
我建议使用纯JavaScript在这种情况下，JavaScript中也没有insert方法，但我们有一种方法是内置数组方法，它为您完成这项工作，称为拼接

让我们看看什么是splice（）

splice（）方法通过删除
现有元素和/或添加新元素

好的，假设我们有下面这个数组：

arr.splice(arr.indexOf(3), 1);

我们可以像这样删除
3
：

[1, 2, 4, 5]

它将返回3，但如果我们现在检查arr，我们有：

arr.splice(2, 0, 3);

到目前为止还不错，但我们如何使用splice向数组添加新元素呢？
让我们把3放回arr

arr.splice(2, 2, 3);

让我们看看我们做了什么

我们再次使用了拼接，但是这次对于第二个参数，我们传递了0，这意味着我们不想删除任何项目，但同时，我们添加了第三个参数，即3，它将添加到第二个索引中

您应该知道，我们可以同时删除和添加，例如，现在我们可以执行以下操作：

[1, 2, 3, 5];

它将删除索引2处的2项，然后在索引2处添加3项，结果将为：

//Append at 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 specific position (here at index 3)
arrName[3] = 'newName1';

这显示了拼接中的每个项目是如何工作的：

数组.拼接（开始、删除计数、项1、项2、项3…）

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

//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

function isIdentical(left, right){
    return JSON.stringify(left) === JSON.stringify(right);
}

function contains(array, obj){
    let count = 0;
    array.map((cur) => {
          if(this.isIdentical(cur, obj)) count++;
    });
    return count > 0;
}

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

//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

function isIdentical(left, right){
    return JSON.stringify(left) === JSON.stringify(right);
}

function contains(array, obj){
    let count = 0;
    array.map((cur) => {
          if(this.isIdentical(cur, obj)) count++;
    });
    return count > 0;
}

任何人谁仍然有这个问题，并尝试了以上所有选项，但从来没有得到它。我正在分享我的解决方案，这是考虑到您不想显式地声明对象与数组的属性

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

这是一个组合o