Możesz zaimplementować metodę Array.insert wykonując to:

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

Wtedy możesz go użyć w następujący sposób:

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

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

Custom array insert methods

1. Z wieloma argumentami i obsługą łańcuchów

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

Może wstawiać wiele elementów (jako natywne splice does) i obsługuje łańcuchowanie:

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

2. Z obsługą łączenia i łączenia argumentów typu array

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

Może scalić tablice z argumentów z podaną tablicą, a także wspiera łańcuchowanie:

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

Inne niż splice, można użyć tego podejścia, które nie zmutuje oryginalnej tablicy, ale utworzy nową tablicę z dodanym elementem. W miarę możliwości należy unikać mutacji. Używam tu operatora spreadu 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]

To może być użyte do dodania więcej niż jednego elementu, poprawiając nieco funkcję, aby użyć operatora rest dla nowych elementów i rozprzestrzeniać to w zwracanym wyniku

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]

Jeśli chcesz wstawić wiele elementów do tablicy jednocześnie sprawdź tę odpowiedź przepełnienia stosu: lepszy sposób łączenia tablicy w tablicę w javascript

Oto także kilka funkcji do zilustrowania obu przykładów:

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

W końcu tutaj jest jsFiddle, więc możesz go zobaczyć dla siebie: http://jsfiddle.net/luisperezphd/Wc8aS/

I tak korzystasz z funkcji:

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

Dla prawidłowego programowania funkcyjnego i celów łańcuchowych wynalazek {[2] } jest niezbędny. Właściwie splice mógłby być idealny, gdyby zwrócił zmutowaną tablicę zamiast całkowicie bezsensownej pustej tablicy. So here it goes

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

Dobrze ok powyższe z Array.prototype.splice() jeden mutuje oryginalną tablicę i niektórzy mogą narzekać, jak "nie powinieneś modyfikować tego, co nie należy do Ciebie" i to może okazać się również słuszne. Więc dla dobra publicznego chciałbym chcę dać inną Array.prototype.insert(), która nie mutuje oryginalnej tablicy. Here it goes;

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

Zalecam użycie czystego JavaScript w tym przypadku również nie ma metody insert w JavaScript, ale mamy metodę, która jest wbudowaną w tablicę metodą, która wykonuje zadanie za Ciebie, nazywa się splice...

Zobaczmy co to jest splice () ...

Metoda splice() zmienia zawartość tablicy poprzez usunięcie istniejące elementy i / lub dodawanie nowych elementów.

Ok, wyobraź sobie, że mamy tę tablicę poniżej:

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

Możemy usunąć 3 w następujący sposób:

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

Zwróci 3, ale jeśli sprawdzimy teraz arr, mamy:

[1, 2, 4, 5]

Jak na razie dobrze, ale jak możemy dodać nowy element do tablicy używając splice? Włóżmy z powrotem 3 w arr...

arr.splice(2, 0, 3);

Ponownie używamy splice , ale tym razem dla drugiego argumentu przekazujemy 0, oznacza, że nie chcemy usuwać żadnego elementu, ale jednocześnie dodajemy trzeci argument, który jest 3 to zostanie dodane w drugim indeksie...

Powinieneś być świadomy, że możemy usunąć i dodać w tym samym czasie, na przykład teraz możemy zrobić:

arr.splice(2, 2, 3);

Który usunie 2 pozycje w indeksie 2, a następnie doda 3 w indeksie 2 i wynik będzie:

[1, 2, 3, 5];

To pokazuje, jak działa każdy element w splice:

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

Inne możliwe rozwiązanie, z użyciem 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);

Mimo, że już na to odpowiedziałam, dodaję tę notkę dla alternatywnego podejścia.

Chciałem umieścić znaną liczbę elementów w tablicy, w określonych pozycjach, ponieważ pochodzą one z "tablicy asocjacyjnej" (tj. obiektu), który z definicji nie jest gwarantowany w porządku posortowanym. Chciałem, aby wynikowa tablica była tablicą obiektów, ale obiekty mają być w określonej kolejności w tablicy, ponieważ tablica gwarantuje ich kolejność. Więc zrobiłem to. to.

Najpierw obiekt źródłowy, łańcuch JSONB pobrany z PostgreSQL. Chciałem posortować je według właściwości "order" w każdym obiekcie potomnym.

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

Ponieważ ilość węzłów w obiekcie jest znana, najpierw tworzę tablicę o podanej długości:

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

A następnie iterację obiektu, umieszczając nowo utworzone obiekty tymczasowe w żądanych miejscach w tablicy bez żadnego "sortowania".

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

Próbowałem tego i działa dobrze!

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

Index to pozycja, w której chcesz wstawić lub usunąć element. 0 tzn. drugi parametr określa ilość elementu z indeksu do usunięcia item są nowymi wpisami, które chcesz wprowadzić w tablicy. Może to być jeden lub więcej niż jeden.

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

Dołączanie pojedynczego elementu do określonego indeksu

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

Dołączanie wielu elementów do określonego indeksu

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