можно использовать тег Array.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. С несколькими аргументами и поддержкой цепочки

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    this.splice.apply(this, [index, 0].concat(
        Array.prototype.slice.call(arguments, 1)));
    return this;
};

он может вставлять несколько элементов (как родной splice делает) и поддерживает:

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

2. С поддержкой слияния и цепочки аргументов типа массива

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    index = Math.min(index, this.length);
    arguments.length > 1
        && this.splice.apply(this, [index, 0].concat([].pop.call(arguments)))
        && this.insert.apply(this, arguments);
    return this;
};

он может объединять массивы из аргументов с заданным массивом, а также поддерживает цепь:

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

демо: http://jsfiddle.net/UPphH/

кроме splice, вы можете использовать этот подход, который не будет мутировать исходный массив, но создаст новый массив с добавленным элементом. Обычно следует избегать мутаций, когда это возможно. Я использую оператор распространения ES6 здесь.

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, newItem) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted item
  newItem,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10)

console.log(result)
// [1, 10, 2, 3, 4, 5]

Это можно использовать для добавления более одного элемента путем настройки функции немного, чтобы использовать оператор rest для новых элементов, и распространить это в возвращаемом результате как ну!--3-->

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, ...newItems) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted items
  ...newItems,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10, 20)

console.log(result)
// [1, 10, 20, 2, 3, 4, 5]

Если вы хотите вставить несколько элементов в массив сразу проверить это переполнение стека ответ: лучший способ объединить массив в массив в javascript

также Вот некоторые функции, чтобы проиллюстрировать оба примера:

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;
}

наконец, вот jsFiddle, чтобы вы могли увидеть его для себя:http://jsfiddle.net/luisperezphd/Wc8aS/

и вот как вы используете функции:

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

для правильного функционального программирования и цепных целей изобретение Array.prototype.insert() имеет важное значение. На самом деле splice мог бы быть идеальным, если бы он вернул мутированный массив вместо совершенно бессмысленного пустого массива. Так вот он идет

Array.prototype.insert = function(i,...rest){
  this.splice(i,0,...rest)
  return this
}

var a = [3,4,8,9];
document.write("<pre>" + JSON.stringify(a.insert(2,5,6,7)) + "</pre>");

Ну ладно выше с Array.prototype.splice() один мутирует исходный массив, и некоторые могут жаловаться, как "вы не должны изменять то, что вам не принадлежит", и это может оказаться правильным. Так общественное благосостояние я хотел бы дать еще Array.prototype.insert(), который не изменяет исходный массив. Вот оно;

Array.prototype.insert = function(i,...rest){
  return this.slice(0,i).concat(rest,this.slice(i));
}

var a = [3,4,8,9],
    b = a.insert(2,5,6,7);
console.log(JSON.stringify(a));
console.log(JSON.stringify(b));

Я рекомендую использовать pure JavaScript в этом случае также нет метода insert в JavaScript, но у нас есть метод, который является встроенный массив метод, который делает работу за вас, он называется соединение...

давайте посмотрим, что splice ()...

метод splice() изменяет содержимое массива путем удаления существующие элементы и / или добавление новых элементов.

OK, представьте, что у нас есть этот массив ниже:

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

мы можем удалить 3 такой:

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

он вернет 3, но если мы проверим arr сейчас, у нас есть:

[1, 2, 4, 5]

пока все хорошо, но как мы можем добавить новый элемент в массив, используя соединения? Давайте вернем 3 в arr...

arr.splice(2, 0, 3);

давайте посмотрим, что мы сделали...

мы используем:соединение снова, но на этот раз для второго аргумента мы передаем 0, значит мы не хотим удалять элемент, но в то же время мы добавляем третий аргумент, который равен 3, который будет добавлен во втором индексе...

вы должны знать, что мы можем удалить и добавить в то же время, например, сейчас мы можем сделать:

arr.splice(2, 2, 3);

при этом будут удалены 2 шт в индексе 2, затем добавьте 3 при индексе 2 и результат будет:

[1, 2, 3, 5];

это показывает, как работает каждый элемент в сращивании:

массив.соединения(пуск, deleteCount, место № 1, место № 2, item3 ...)

другое возможное решение, с использованием Array#reduce.

var arr = ["apple", "orange", "raspberry"],
    arr2 = [1, 2, 4];

function insert(arr, item, index) {
    arr = arr.reduce(function(s, a, i) {
      i == index ? s.push(item, a) : s.push(a);
      return s;
    }, []);   
    console.log(arr);
}

insert(arr, "banana", 1);
insert(arr2, 3, 2);

хотя на это уже был дан ответ, я добавляю эту заметку для альтернативного подхода.

Я хотел поставить известное число элементов в массив, в определенные позиции, поскольку они выходят из "ассоциативного массива" (т. е. объекта), который по определению не гарантируется в отсортированном порядке. Я хотел, чтобы результирующий массив был массивом объектов, но объекты должны быть в определенном порядке в массиве, поскольку массив гарантирует их порядок. Так Что Я ... сделать это.

сначала исходный объект, строка JSONB, полученная из PostgreSQL. Я хотел, чтобы он был отсортирован по свойству "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);

Я попытался это и он работает нормально!

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

Index-это позиция, в которую вы хотите вставить или удалить элемент. 0 т. е. вторые параметры определяют количество элементов из удаляемого индекса изделия новые записи, которые вы хотите сделать в массиве. Это может быть один или несколько.

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

добавить один элемент с определенным индексом

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

добавить несколько элементов с определенным индексом

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