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

Question

我正在寻找JavaScript数组插入方法，其风格如下：

arr.insert（索引，项）

最好是在jQuery中，但此时任何JavaScript实现都可以。

Answer 1

你想要剪接函数。

arr.splice（索引，0，项）；将插入项目进入之内阿珥在指定的指数（删除0项目优先，也就是说，它只是一个插入）。

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

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

更新（2024年5月24日）

您现在可以使用到拼接方法，其行为与剪接但是，它返回一个新数组，而不改变现有数组。

您可以更新前面的示例，如下所示：

const updated=arr.toSpliced（2，0，“Lene”）；

Answer 2

您可以实施阵列插入方法：

Array.prototype.insert=函数（索引，…项）{this.splice（索引，0，…项）；};

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

var arr=['A'，'B'，'E']；arr.insert（2，“C”，“D”）；//=>arr==[“A”、“B”、“C”、“D”、“E”]

Answer 3

除了拼接之外，您还可以使用这种方法，它不会改变原始数组，但会使用添加的项创建一个新数组。当你需要避免突变时，它很有用。我正在使用欧洲标准6此处为扩展运算符。

常量项=[1,2,3,4,5]常量插入=（arr，index，newItem）=>[//指定索引之前的数组的一部分…arr.slice（0，索引），//插入的项目新项目，//指定索引后数组的一部分…arr.slice（索引）]const结果=插入（项，1，10）console.log（结果）// [1, 10, 2, 3, 4, 5]

这可以用于添加多个项目，方法是稍稍调整函数以对新项目使用rest操作符，并在返回的结果中传播该操作符：

常量项=[1,2,3,4,5]常量插入=（arr，index，…newItems）=>[//指定索引之前的数组的一部分…arr.slice（0，索引），//插入的项目…新项目，//指定索引后数组的一部分…arr.slice（索引）]常量结果=插入（项，1，10，20）console.log（结果）// [1, 10, 20, 2, 3, 4, 5]

Answer 4

使用阵列.原型.拼接（）是一种优雅的实现方式

常数=['one'，'two'，'four'，'five']编号。拼接（2，0，‘三’）；console.log（数字）

阅读更多关于阵列.原型.拼接

Answer 5

自定义数组插入方法

1.具有多个参数和链接支持

/*语法：array.insert（索引，值1，值2，…，值N）*/Array.prototype.insert=函数（索引）{this.splice.apply（this，[索引，0].concat(Array.prototype.slice.call（参数，1））；返回此；};

它可以插入多个元素（作为本机元素剪接does）并支持链接：

[“a”、“b”、“c”、“d”].插入（2，“X”、“Y”、“Z”）.切片（1，6）；//[“b”、“X”、“Y”、“Z”、“c”]

---

2.具有数组类型参数合并和链接支持

/*语法：数组.insert（索引，值1，值2，…，值N）*/Array.prototype.insert=函数（索引）{index=Math.min（index，this.length）；arguments.length>1&&this.splice.apply（this，[index，0].concat（[].pop.call（arguments））&&this.insert.apply（this，参数）；返回此；};

它可以将参数中的数组与给定数组合并，还支持链接：

[“a”，“b”，“c”，“d”].插入（2，“V”，[“W”，“X”，“Y”]，“Z”）.连接（“-”）；//“a-b-V-W-X-Y-Z-c-d”

演示： http://jsfiddle.net/UPphH/

Answer 6

如果您想一次将多个元素插入数组，请查看此堆栈溢出答案：用javascript将数组拼接成数组的更好方法

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

函数insertAt（数组，索引）{var arrayToInsert=Array.prototype.splice.apply（参数，[2]）；return insertArrayAt（数组，索引，arrayToInsert）；}函数insertArrayAt（数组，索引，arrayToInsert）{Array.prototype.splice.apply（Array，[index，0].concat（arrayToInsert））；返回数组；}

最后是一个jsFiddle，您可以自己查看它：http://jsfiddle.net/luisperezphd/Wc8aS/

以下是您如何使用这些功能：

//如果要插入特定值，无论是常量还是变量：插入At（arr，1，“x”，“y”，“z”）；//或者，如果您有一个数组：var arrToInsert=[“x”，“y”，“z”]；插入数组位置（arr，1，arrToInsert）；

Answer 7

解决方案和性能

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

结论

适用于所有浏览器

• 令人惊讶的是，对于小型阵列，基于片和减少（D、E、F）通常比就地解决方案快10x100倍
• 对于大型阵列，基于剪接（AI、BI和CI）速度最快（有时约为100倍，但这取决于阵列大小）
• 对于小型阵列，BI解决方案最慢
• 对于大型阵列，E解决方案最慢

细节

试验分为两组：原位溶液（AI、BI和CI）和非塑性溶液（D、E和F），并针对两种情况进行：

• 测试一个包含10个元素的数组-您可以运行它在这里
• 测试包含1000000个元素的数组-您可以运行它在这里

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

J小提琴

函数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）.concat（el，arr.slices（i））；}函数E（arr，i，el）{return[…arr.slice（0，i），el，…arr.scice（i）]}函数F（arr，i，el）{return 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，“新”）；控制台.log（`${n}:[${a}]`）；};log（'AI'，AI）；日志（“BI”，BI）；log（“CI”，CI）；对数（'D'，D）；对数（‘E’，E）；对数（'F'，F）；

此代码段仅显示测试过的代码（不执行测试）

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

Answer 8

你可以使用拼接（）为此

这个拼接（）方法在添加元素时通常会收到三个参数：

1. 这个指数要添加项的数组的
2. 这个要删除的项目数，在本例中是0
3. 这个要素添加

let数组=['项1'，'项2'，'项3']让insertAtIndex=0let itemsToRemove=0array.splice（insertAtIndex，itemsToRemove，'在索引0处插入此字符串'）console.log（数组）

Answer 9

为了正确的函数编程和链接目的Array.prototype.insert（）至关重要。实际上剪接如果它返回的是变异数组，而不是一个完全没有意义的空数组，那么可能会很完美。所以它是这样的：

Array.prototype.insert=函数（i，…rest）{此.拼接（i，0，…其余）把这个还给我}变量a=[3,4,8,9]；document.write（“<pre>”+JSON.stringify（a.insert（2,5,6,7））+“</pre>”）；

好吧，以上是数组.原型.拼接（）有人改变了原始数组，有些人可能会抱怨说“你不应该修改不属于你的东西”，这可能也是正确的。所以为了公共福利，我想再给一个Array.prototype.insert（）它不会改变原始数组。就这样；

Array.prototype.insert=函数（i，…rest）{返回this.slice（0，i）.concat（rest，this.slie（i））；}变量a=[3,4,8,9]，b=a.insert（2,5,6,7）；console.log（JSON.stringify（a））；console.log（JSON.stringify（b））；

Answer 10

我建议使用纯JavaScript脚本在这种情况下。JavaScript中也没有任何插入方法，但我们有一个方法内置数组为您完成工作的方法。它被称为剪接...

让我们看看是什么拼接（）...

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

好的，假设下面有一个数组：

常数arr=[1,2,3,4,5]；

我们可以删除三这样地：

arr.plice（arr.indexOf（3），1）；

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

[1, 2, 4, 5]

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

让我们把3放回arr。。。

棱缝（2，0，3）；

让我们看看我们做了什么。。。

我们使用剪接再一次，但这次对于第二个参数，我们通过了0，意味着我们不想删除任何项，但同时，我们添加了第三个参数，即将在第二个索引处添加的3。。。

你应该意识到我们可以删除和添加同时。例如，现在我们可以：

棱缝（2、2、3）；

这将删除两个项目位于索引2。然后添加三在索引2处，结果为：

[1, 2, 3, 5];

这显示了每个项目如何剪接工作：

数组.splice（start，deleteCount，item1，item2，item3…）

Answer 11

以下是两种方法：

const数组=['My'，'name'，'Hamza']；array.splice（2，0，'is'）；console.log（“方法1:”，array.join（“”））；

或者

Array.prototype.insert=函数（索引，项）{this.splice（索引，0，项）；};const数组=['My'，'name'，'Hamza']；array.insert（2，'is'）；console.log（“方法2:”，array.join（“”））；

Answer 12

在特定索引处追加单个元素：

//附加到特定位置（此处为索引1）arrName.拼接（1，0，'newName1'）；//1：索引编号，0：要删除的元素编号，newName1：新元素//附加到特定位置（此处为索引3）arrName[3]='newName1'；

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

//从索引编号1追加arrName.splice（1，0，‘newElemenet1’，‘newElemenet2’，‘newElemenet3’）；//1：从追加开始的索引编号，//0：要删除的元素数，//newElemenet1,2,3：新元素

Answer 13

阵列#拼接（）这就是方法，除非您真的想避免改变数组。给定2个阵列arr1型和棱2，下面是如何插入的内容棱2进入之内arr1型在第一个元素之后：

const arr1=[‘a’，‘d’，‘e’]；const arr2=['b'，'c']；arr1.拼接（1，0，…arr2）；//arr1现在包含['a'，'b'，'c'，'d'，'e']控制台.log（arr1）

如果您担心改变数组（例如，如果使用Immutable.js），您可以使用切片（），不要混淆拼接（）用一个“p”.

const arr3=[…arr1.切片（0，1），…arr2，…arr 1.切片（1）]；

Answer 14

另一种可能的解决方案，使用阵列减少.

const arr=[“苹果”，“桔子”，“覆盆子”]；常数arr2=[1,2,4]；常量插入=（arr，item，index）=>arr.reduce（函数（s，a，i）{i===指数？s.push（项目，a）：s.push；返回s；}, []);控制台.log（插入（arr，“香蕉”，1））；控制台.log（插入（arr2、3、2））

Answer 15

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

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

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

var jsonb_str='{“one”：{“abbr”：“”，“order”：3}，“two”：{abbr：“”；var jsonb_obj=JSON.parse（jsonb_str）；

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

var obj_length=对象.keys（jsonb_obj）.length；var sorted_array=新数组（obj_length）；

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

for（Object.keys（jsonb_obj）的var键）{变量tobj={}；tobj[key]=jsonb_obj[key]。abbr；var位置=jsonb_obj[key].order-1；sorted_array[position]=待定；}控制台.dir（sorted_array）；

Answer 16

不可变插入

使用剪接如果您需要就地插入数组，那么方法无疑是最佳解决方案。

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

函数插入（数组、索引）{const items=Array.prototype.slice.call（参数，2）；return[].concat（array.slice（0，index），items，array.slice（index））；}常量列表=['one'，'two'，'three']；const list1=插入（list，0，'zero'）；//插入单个项目const list2=插入（list，3，'four'，'five'，'sive'）；//插入多个console.log（'原始列表：'，list）；console.log（'插入的列表1:'，列表1）；console.log（'插入的列表2:'，列表2）；

注：这是一个pre-欧洲标准6这样做的方式，所以它既适用于旧的浏览器，也适用于新的浏览器。

如果你正在使用ES6，那么你可以试试rest参数同样；看见这个答案.

Answer 17

任何对这个问题仍有疑问的人，都尝试过前面答案中的所有选项，但都没有得到。我分享我的解决方案，这是为了考虑到你不想显式地声明对象与数组的属性。

功能相同（左、右）{return JSON.stringify（左）===JSON.stringify（右）；}函数包含（数组，obj）{设count＝0；array.map（（cur）=>{if（this.isIdentive（cur，obj））计数++；});返回计数>0；}

这是对引用数组进行迭代，并将其与要检查的对象进行比较，将两者转换为字符串，然后在匹配时进行迭代的组合。然后你就可以数数了。这可以改进，但这是我解决的地方。

Answer 18

从中获利减少方法如下：

函数插入（arr、val、index）{返回索引>=arr.length? arr.concat（有效值）：arr.reduce（（prev，x，i）=>prev.concat（i===索引？[val，x]：x），[]）；}

因此，通过这种方式，我们可以返回一个新数组（这将是一种很酷的功能性方法，比使用推或剪接)在索引处插入元素，如果索引大于数组的长度，则将在末尾插入。

Answer 19

我试过了，效果很好！

var initialArr=[“印度”，“中国”，“日本”，“美国”]；缩写Arr.拼接（索引，0，项）；

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

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

缩写Arr.拼接（2,0，“尼日利亚”）；缩写Arr.splice（2，0，“澳大利亚”，“英国”）；

Answer 20

我不得不同意Redu的回答，因为splice（）的接口确实有点混乱。cdbajorin给出的响应是“当第二个参数为0时，它只返回一个空数组。如果它大于0，则返回从数组中删除的项“虽然准确，但证明了这一点。

该功能的目的是拼接，或如雅各布·凯勒（Jakob Keller）早些时候所说，“加入或连接，也就是改变。

您有一个已建立的数组，您现在正在更改它，这将涉及添加或删除元素。。。。“考虑到这一点，被删除的元素（如果有的话）的返回值充其量是尴尬的。我100%同意，如果这个方法返回看起来很自然的新数组，并添加了拼接元素，那么它本可以更适合链接。然后你可以做类似[”“19”“，”“17”“].splice（1,0，”“18”“）.join（”“…”“）的事情。”或者使用返回的数组执行任何操作。

它会返回删除的内容，这简直是胡说八道。如果该方法的目的是“删除一组元素”，那么这可能是它的唯一目的。似乎如果我不知道我已经删掉了什么，我可能没有什么理由删掉这些元素，不是吗？

如果它的行为类似于concat（）、map（），reduce（）、slice（）等，则会更好，其中新数组是从现有数组生成的，而不是对现有数组进行更改。这些都是可以链接的，而且是一个重大问题。链式数组操作很常见。

语言似乎需要朝着一个或另一个方向发展，并尽可能地坚持下去。JavaScript的功能性和较少声明性，似乎与规范有着奇怪的偏差。

Answer 21

可以使用array.splice执行此操作：

/***@param arr:数组*@param item:要插入的项*@param index:要插入的索引*@返回带有插入元素的数组*/导出函数_arrayInsertAt<T>（arr:T[]，项：T，索引：数字）{返回arr.splice（索引，0，项）；；}

阵列文件切片

Answer 22

这是我在一个应用程序中使用的一个工作函数。

这将检查项目是否存在：

让ifExist=（item，strings=[“”]，position=0）=>{//输出到带有空字符串的数组中。重要的是以防它们不是任何项。让输出=[“”]；//检查要定位的项目是否存在。if（项目）{//输出应等于字符串数组。输出=字符串；//使用splice（）可以断开数组。//使用位置参数来说明放置项目的位置//0表示不替换索引。物品是我们放置在指定位置的实际物品。输出。拼接（位置，0，项）；}//空字符串是为了不与逗号或其他任何东西连接。返回output.join（“”）；};

然后我在下面这样称呼它。

ifExist（“好友”，['（'，'）']，1）}//输出：（好友）ifExist（“friends”，['-']，1）}//输出：-friendsifExist（“好友”，['：']，0）}//输出：好友：

Answer 23

我喜欢一点安全感，我使用这个：

阵列原型。插入=函数（项，前面）{if（！item）返回；if（before==null||before<0||bevere>this.length-1）{this.push（项目）；回报；}this.splice（前，0，项）；}var t=[“a”，“b”]t.插入（“v”，1）控制台.log（t）

Answer 24

如果要保持原始数组不变，但返回一个新数组，其中元素插入到特定索引中，则可以使用.to拼接（）方法：

这样可以避免改变数组到位:

//                0    1    2常量字母=[“A”、“B”、“D”]；const insertIndex=2；//数组中要插入的位置const correctLetters=字母.to拼接（insertIndex，0，“C”）；//0表示不删除任何项目，只插入即可。“C”是要插入的项。console.log（correctLetters）；//[“A”，“B”，“C”，“D”]（新数组包含新字符）console.log（字母）；//[“A”、“B”、“D”]（未修改）

如果需要向数组中插入多个项，就像它的同级项一样.拼接（），您可以使用.to拼接（）具有多个参数：

.to拼接（插入索引，0，“C”，“D”，“E”）；

例如，上面将插入“C”,“D”、和“E”在插入索引不修改数组，而是返回一个新数组。

Answer 25

现在有ToSpliced方法。

const months=[“一月”，“三月”，“四月”，“五月”]；//在索引1处插入元素const months2=months.toSpliced（1，0，“Feb”）；

Answer 26

//假设我们有一个数组让myArray=[2,4,6,8,10]；//要插入项目的索引让indexToInsert=3；//我们要插入的项让itemToInsert=174；//现在我们使用splice（）方法在指定索引处插入项myArray.splice（indexToInsert，0，itemToInsert）；//具有新值的输出console.log（myArray）；

Answer 27

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

导出常量insertItemInList=<T>(arr:T[]，索引：数字，新项目：T)：T[]=>[…arr.slice（0，索引），newItem，…arr.scice（索引）]

Answer 28

我这样做：

常量插入=（what，where，index）=>（[…where.slice（0，index），what，…where.slice（index，where.length）]）；

常量插入=（what，where，index）=>（[…where.slice（0，index），what，…where.slice（index，where.length）]）；常数列表=[1,2,3,4,5,6]；const newList=插入（'a'，list，2）；console.log（newList.indexOf（'a'）===2）；

Answer 29

下面是一个支持同时插入多个值的简单函数：

函数add_items_to_array_atposition（数组、索引、新项）{return[…array.slice（0，index），…new_items，…array-slice（index）]；}

用法示例：

设old_array=[1,2,5]；设new_array=add_items_to_array_at_position（old_array，2，[3,4]）；console.log（new_array）；//输出：[1,2,3,4,5]

Answer 30

var数组=[10,20,30,40]变量i；变量pos=2//pos=索引+1/*pos是我们要插入的位置，它是索引+1。数组中的位置2是索引1*/var值=5//要插入的值//从最后一个数组元素初始化对于（i=数组长度-1；i>=位置-1；i--）{数组[i+1]=数组[i]}数组[pos-1]=值console.log（数组）