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

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]

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/

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

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

Oto dwa sposoby:

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

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

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

Lub

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

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

Array#splice() to jest droga do zrobienia, chyba że naprawdę chcesz uniknąć mutacji tablicy. Biorąc pod uwagę 2 tablice arr1 i arr2, Oto Jak wstawić zawartość arr2 do arr1 po pierwszym elemencie:

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)

Jeśli obawiasz się mutacji tablicy (na przykład, jeśli używasz Immutable.js), można zamiast tego użyć slice(), nie mylić z splice() z 'p'.

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

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

Rozwiązania I Wydajność

Dzisiaj (2020.04.24) wykonuję testy wybranych rozwiązań dla dużych i małych macierzy . Testowałem je na MacOs High Sierra 10.13.6 na Chrome 81.0, Safari 13.1, Firefox 75.0.

Wnioski

Dla wszystkich przeglądarek

• zaskakująco dla małych macierzy rozwiązania Nie-in-place oparte na slice i reduce (D,E,F) są zwykle 10X-100X szybsze niż rozwiązania in-place
• dla dużych tablic rozwiązania oparte na splice (AI,BI,CI) były najszybszy (czasami ~100x - ale to zależy od rozmiaru tablicy)
• dla małych tablic rozwiązanie BI było najwolniejsze
• dla dużych tablic rozwiązanie E było najwolniejsze

Szczegóły

Testy zostały podzielone na dwie grupy: rozwiązania in-place (AI, BI,CI) i rozwiązania non-in-place (D, E, F) i zostały przeprowadzone dla dwóch przypadków

• test tablicy z 10 elementami - możesz ją uruchomić tutaj
• test dla tablicy z 1.000.000 elementów-ty można go uruchomić tutaj

Testowany kod jest przedstawiony w poniższym fragmencie

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)

Przykładowe wyniki dla małej tablicy w chrome są poniżej

Każdy, kto nadal ma problemy z tym i wypróbował wszystkie opcje powyżej i nigdy go nie dostał. Dzielę się moim rozwiązaniem, ma to na celu wzięcie pod uwagę, że nie chcesz jawnie podać właściwości obiektu vs tablicy.

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

Jest to kombinacja iteracji tablicy referencyjnej i porównania jej z obiektem, który chcesz sprawdzić, przekonwertowania obu z nich do łańcucha, a następnie iteracji, jeśli pasuje. Wtedy możesz po prostu liczyć. Można to poprawić, ale jest to gdzie się osiedliłem. Mam nadzieję, że to pomoże.

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

Biorąc zysk z metody redukcji w następujący sposób:

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

Tak więc w ten sposób możemy zwrócić nową tablicę (będzie fajnym funkcjonalnym sposobem-dużo lepszym niż użycie push lub splice) Z elementem wstawionym na indeksie, a jeśli indeks jest większy niż długość tablicy, zostanie on wstawiony na końcu.

Wstawianie niezmienne

Za pomocą splice metoda jest z pewnością najlepszą odpowiedzią, jeśli trzeba wstawić do tablicy in-place.

Jednakże, jeśli szukasz niezmiennej funkcji, która zwraca nową zaktualizowaną tablicę zamiast mutacji oryginalnej tablicy w insert, możesz użyć następującej funkcji.

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

Uwaga: jest to sposób przed ES2015, więc działa zarówno w starszych, jak i nowszych przeglądarkach.

Jeśli używasz ES6 to można też wypróbować parametry rest ; Zobacz to odpowiedź.

Oto działająca funkcja, której używam w jednej z moich aplikacji.

Sprawdza, czy pozycja kończy

let ifExist = (item, strings = [ '' ], position = 0) => {
     // output into an array with empty string. Important just in case their is no item. 
    let output = [ '' ];
    // check to see if the item that will be positioned exist.
    if (item) {
        // output should equal to array of strings. 
        output = strings;
       // use splice in order to break the array. 
       // use positition param 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: 

Trochę starszy wątek, ale muszę się zgodzić z Redu powyżej, bo splice zdecydowanie ma trochę mylący interfejs. I Odpowiedź udzielona przez cdbajorin, że " zwraca pustą tablicę tylko wtedy, gdy drugim parametrem jest 0. Jeśli jest większa niż 0, zwraca Elementy usunięte z tablicy " is, while accurate, proving the point. Intencją funkcji jest łączenie lub, jak powiedział wcześniej Jakob Keller, " łączenie lub łączenie, również zmiana. Masz ustaloną tablicę, którą teraz jesteś zmiana polegająca na dodawaniu lub usuwaniu elementów...."Biorąc pod uwagę, że wartość zwrotu elementów, jeśli w ogóle, które zostały usunięte, jest w najlepszym razie niewygodna. I w 100% zgadzam się, że ta metoda mogłaby być lepiej dostosowana do łączenia, gdyby zwróciła to, co wydaje się naturalne, nową tablicę z dodanymi elementami łączonymi. Wtedy możesz robić takie rzeczy jak ["19", "17"].splice (1,0,"18").join("...") lub co tylko zechcesz z zwróconą tablicą. Fakt, że zwraca to, co zostało usunięte, jest po prostu nonsensem. IMHO. Jeśli intencją metody było "wyciąć zestaw elementów" i to było tylko intencją, może. Wygląda na to, że jeśli już Nie wiem, co wycinam, prawdopodobnie nie mam powodu, aby wyciąć te elementy, prawda? Byłoby lepiej, gdyby zachowywała się jak concat, map, reduce, slice, itd., gdzie nowa tablica jest tworzona z istniejącej tablicy, zamiast mutować istniejącą tablicę. Wszystkie są łańcuchowe, a to jest istotna kwestia. Jest to dość powszechne w łańcuchach manipulacja. Wydaje się, że język musi iść w jednym lub drugim kierunku i starać się trzymać go tak bardzo, jak to możliwe. Javascript jest funkcjonalny i mniej deklaratywny, po prostu wydaje się dziwnym odchyleniem od normy.

Lubię małe Bezpieczeństwo i używam tego

   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 )

Aby dodać element do konkretnego indeksu nie ma metody dostępnej w obiekcie Array. W tym celu możemy jednak użyć już dostępnej metody splice w obiekcie Array.

Tablica zaczyna się od indeksu 0, więc jeśli chcemy dodać element jako pierwszy element tablicy, wtedy indeks elementu wynosi 0. Jeśli chcemy dodać element do n-tej pozycji, wtedy indeksem jest (n-1) nth index.

Zgodnie z oficjalną dokumentacją, splice() metoda zmienia zawartość tablicy poprzez usunięcie lub zastąpienie istniejących elementów i / lub dodanie nowych elementów w oryginalnej tablicy (co oznacza, że tablica źródłowa jest modyfikowana).

Metoda splice() przyjmuje trzy argumenty:

1. start → Indeks, od którego należy zacząć zmieniać tablicę.
2. deleteCount (opcjonalne) → liczba całkowita wskazująca liczbę elementów tablicy do usunięcia od początku.
3. (elem1, elem2 ...) → Elementy, które należy dodać do tablicy, począwszy od początku. Jeśli nie podasz żadnych elementów, splice() usunie tylko elementy z tablicy.

Aby wstawić element do konkretnego indeksu, musimy podać argumenty jako:

1. start → index gdzie wstawić element
2. deleteCount → 0 (ponieważ nie musimy usuwać elementu)
3. elem → elements aby wstawić

Możemy wykonać tę funkcję:

function insertAt(array, index, ...elementsArray) {
        array.splice(index, 0, ...elements);
}

Teraz zadzwońmy funkcja

var num = [1,2,3,6,7,8];
insertAt(num, 3, 4, 5); // [1,2,3,4,5,6,7,8]

Teraz możemy zmienić indeks:

var num = [1,2,3,6,7,8];
insertAt(numbers, 2, 4,5); // [1,2,4,5,3,6,7,8]