Вот простая функция, поддерживающая одновременную вставку нескольких значений:

function add_items_to_array_at_position(array, index, new_items)
{
    return [...array.slice(0, index), ...new_items, ...array.slice(index)];
}

Пример использования:

let old_array = [1,2,5];

let new_array = add_items_to_array_at_position(old_array, 2, [3,4]);

console.log(new_array);

//Output: [1,2,3,4,5]

Я делаю так:

const insert = (what, where, index) => 
  ([...where.slice(0, index), what , ...where.slice(index, where.length)]);

const insert = (what, where, index) =>
  ([...where.slice(0, index), what , ...where.slice(index, where.length)]);
  
const list = [1, 2, 3, 4, 5, 6];
const newList = insert('a', list, 2);

console.log(newList.indexOf('a') === 2);

Метод splice() обычно получает три параметра при добавлении элемента:

1. индекс массива, куда будет добавлен элемент.
2. количество удаляемых элементов, в данном случае 0.
3. Элемент для добавления.

let array = ['item 1', 'item 2', 'item 3'],
    insertAtIndex = 0,
    itemsToRemove = 0;
    
array.splice(insertAtIndex, itemsToRemove, 'insert this string on index 0');

console.log(array);

Использование Array.prototype.splice() — простой способ добиться этого

const numbers = ['one', 'two', 'four', 'five']
numbers.splice(2, 0, 'three');

console.log(numbers)

Подробнее о Array.prototype.splice() здесь

Вот современный (функциональный Typescript) способ:

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

Мне нравится немного безопасности, и я использую это:

   Array.prototype.Insert = function (item, before) {
        if (!item) return;
        if (before == null || before < 0 || before > this.length - 1) {
            this.push(item);
            return;
        }
        this.splice(before, 0,item );
    }
    
    
   var t = ["a","b"]
   
   t.Insert("v",1)
    
    console.log(t )

Неизменная вставка

Использование метода splice, безусловно, лучший ответ, если вам нужно вставить в массив на месте.

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

function insert(array, index) {
  const items = Array.prototype.slice.call(arguments, 2);

  return [].concat(array.slice(0, index), items, array.slice(index));
}

const list = ['one', 'two', 'three'];

const list1 = insert(list, 0, 'zero'); // Insert single item
const list2 = insert(list, 3, 'four', 'five', 'six'); // Insert multiple

console.log('Original list: ', list);
console.log('Inserted list1: ', list1);
console.log('Inserted list2: ', list2);

Примечание: Это предварительный ES6 способ сделать это, поэтому он работает как для старых, так и для новых браузеров.

Если вы используете ES6, вы также можете попробовать остальные параметры; см. этот ответ.

Решения и производительность

Сегодня (2020.04.24) я провожу тесты выбранных решений для больших и малых массивов. Я тестировал их на macOS v10.13.6 (High Sierra) в Chrome 81.0, Safari 13.1 и Firefox 75.0.

Выводы

Для всех браузеров

• неожиданно для небольших массивов нелокальные решения на основе slice и reduce (D,E,F) обычно в 10-100 раз быстрее, чем оперативные решения
• для больших массивов решения на месте на основе splice (AI, BI и CI) были быстрее (иногда ~100x - но это зависит от размера массива)
• для небольших массивов решение BI было самым медленным
• для больших массивов решение E было самым медленным

Подробности

Тесты были разделены на две группы: решения на месте (AI, BI и CI) и решения не на месте (D, E и F) и проводились для двух случаев:

• тест для массива из 10 элементов - вы можете запустить его здесь
• тест для массива из 1 000 000 элементов - вы можете запустить его здесь

Протестированный код представлен в приведенном ниже фрагменте:

jsfiddle

function AI(arr, i, el) {
  arr.splice(i, 0, el);
  return arr;
}

function BI(arr, i, el) {
  Array.prototype.splice.apply(arr, [i, 0, el]);
  return arr;
}

function CI(arr, i, el) {
  Array.prototype.splice.call(arr, i, 0, el);
  return arr;
}

function D(arr, i, el) {
  return arr.slice(0, i).concat(el, arr.slice(i));
}

function E(arr, i, el) {
  return [...arr.slice(0, i), el, ...arr.slice(i)]
}

function F(arr, i, el) {
  return arr.reduce((s, a, j)=> (j-i ? s.push(a) : s.push(el, a), s), []);
}



// -------------
// TEST
// -------------

let arr = ["a", "b", "c", "d", "e", "f"];

let log = (n, f) => {
  let a = f([...arr], 3, "NEW");
  console.log(`${n}: [${a}]`);
};

log('AI', AI);
log('BI', BI);
log('CI', CI);
log('D', D);
log('E', E);
log('F', F);

This snippet only presents tested code (it not perform tests)

Примеры результатов для небольшого массива в Google Chrome приведены ниже:

Array#splice() — это то, что вам нужно, если только вы действительно не хотите мутировать массив. Учитывая 2 массива arr1 и arr2, вот как можно вставить содержимое arr2 в arr1 после первого элемента:

const arr1 = ['a', 'd', 'e'];
const arr2 = ['b', 'c'];

arr1.splice(1, 0, ...arr2); // arr1 now contains ['a', 'b', 'c', 'd', 'e']

console.log(arr1)

Если вас беспокоит изменение массива (например, при использовании Immutable.js), вы можете вместо этого использовать slice(), не путать с splice() с 'p'.

const arr3 = [...arr1.slice(0, 1), ...arr2, ...arr1.slice(1)];

Есть два способа:

const array = [ 'My', 'name', 'Hamza' ];

array.splice(2, 0, 'is');

console.log("Method 1: ", array.join(" "));

Или

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

const array = [ 'My', 'name', 'Hamza' ];
array.insert(2, 'is');

console.log("Method 2 : ", array.join(" "));

Я должен согласиться с ответом Реду, потому что splice() определенно имеет немного запутанный интерфейс. И ответ, данный cdbajorin, что «он возвращает пустой массив только тогда, когда второй параметр равен 0. Если он больше 0, он возвращает элементы, удаленные из массива», хотя и является точным, подтверждая точку зрения.

Назначение функции состоит в том, чтобы соединять или, как сказал ранее Джейкоб Келлер, "присоединять или соединять, а также изменять".

У вас есть установленный массив, который вы сейчас изменяете, что включает добавление или удаление элементов...." Учитывая это, возвращаемое значение элементов, если таковые имеются, которые были удалены, в лучшем случае неудобны. И я 100% согласитесь, что этот метод мог бы лучше подходить для цепочек, если бы он возвращал то, что кажется естественным, новый массив с добавленными соединенными элементами.Тогда вы могли бы делать такие вещи, как ["19", "17"].splice(1,0, "18").join("...") или что угодно с возвращаемым массивом.

Тот факт, что он возвращает то, что было удалено, является просто ерундой ИМХО. Если целью метода было «вырезать набор элементов» и это было его единственной целью, возможно. Похоже, если я уже не знаю, что я вырезаю, у меня, вероятно, нет причин вырезать эти элементы, не так ли?

Было бы лучше, если бы он вел себя как concat(), map(), reduce(), slice() и т. д., где новый массив создается из существующего массива, а не видоизменяется существующий массив. Все они связаны, и это является серьезной проблемой. Манипуляции с цепочками массивов довольно распространены.

Похоже, что язык должен двигаться в одном или другом направлении и стараться придерживаться его как можно дольше. Поскольку JavaScript функционален и менее декларативен, это кажется странным отклонением от нормы.

Вот работающая функция, которую я использую в одном из своих приложений.

Это проверяет, существует ли элемент:

let ifExist = (item, strings = [ '' ], position = 0) => {
     // Output into an array with an empty string. Important just in case their isn't any item.
    let output = [ '' ];
    // Check to see if the item that will be positioned exist.
    if (item) {
        // Output should be equal to an array of strings.
        output = strings;
       // Use splice() in order to break the array.
       // Use positional parameters to state where to put the item
       // and 0 is to not replace an index. Item is the actual item we are placing at the prescribed position.
        output.splice(position, 0, item);
    }
    // Empty string is so we do not concatenate with comma or anything else.
    return output.join("");
};

А потом я называю это ниже.

ifExist("friends", [ ' ( ', ' )' ], 1)}  // Output: ( friends )
ifExist("friends", [ ' - '], 1)}  // Output:  - friends
ifExist("friends", [ ':'], 0)}  // Output:   friends:

Фиксация прибыли по методу уменьшения следующим образом:

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) с элементом, вставленным в индекс, и если индекс больше длины массива, он будет вставлен в конец.

Все, у кого все еще есть проблемы с этим, кто перепробовал все варианты в предыдущих ответах и ​​так и не получил его. Я делюсь своим решением, и это нужно учитывать, что вы не хотите явно указывать свойства вашего объекта по сравнению с массивом.

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

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

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

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

Хорошо, представьте, что у нас есть следующий массив:

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

Мы можем удалить 3 следующим образом:

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

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

[1, 2, 4, 5]

Пока все хорошо, но как мы можем добавить новый элемент в массив с помощью соединения?

Вернем 3 в ряд...

arr.splice(2, 0, 3);

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

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

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

arr.splice(2, 2, 3);

Что удалит два элемента в индексе 2. Затем добавьте 3 в индексе 2, и результат будет:

[1, 2, 3, 5];

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

array.splice(start, deleteCount, item1, item2, item3...)

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

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

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

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

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

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

Индекс — это позиция, в которую вы хотите вставить или удалить элемент.

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

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

Помимо объединения, вы можете использовать этот подход, который не будет изменять исходный массив, но создаст новый массив с добавленным элементом. Обычно следует избегать мутаций, когда это возможно. Здесь я использую оператор распространения 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 для новых элементов, а также распространить это на возвращаемый результат:

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]

Для правильного функционального программирования и создания цепочек необходимо изобретение 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));

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

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

Сначала исходный объект, строка JSONB, полученная из PostgreSQL. Я хотел отсортировать его по свойству «порядок» в каждом дочернем объекте.

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

Пользовательский массив 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"

DEMO: http://jsfiddle.net/UPphH/

Метод 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' ]

Если вы хотите вставить несколько элементов в массив одновременно, ознакомьтесь с этим ответом Stack Overflow: Лучший способ объединить массив в массив в 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);