javascript - remove - Wie füge ich ein Element an einem bestimmten Index in ein Array ein?




js array pop (8)

Benutzerdefinierte Array- insert

1. Mit mehreren Argumenten und Verkettungsunterstützung

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

Es kann mehrere Elemente einfügen (wie der native splice ) und die Verkettung unterstützen:

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

2. Mit Argumenten vom Array-Typ, die Unterstützung zusammenführen und verketten

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

Es kann Arrays aus den Argumenten mit dem angegebenen Array zusammenführen und unterstützt auch die Verkettung:

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

Ich suche eine Javascript-Array-Einfügemethode im Stil von:

arr.insert(index, item)

Vorzugsweise in jQuery, aber an diesem Punkt ist jede Javascript-Implementierung erforderlich.


Anders als beim Spleißen können Sie diesen Ansatz verwenden, der das ursprüngliche Array nicht verändert, sondern ein neues Array mit dem hinzugefügten Element erstellt. Mutationen sollten Sie in der Regel möglichst vermeiden. Ich verwende hier den ES6-Spread-Operator.

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]

Dies kann verwendet werden, um mehrere Elemente hinzuzufügen, indem Sie die Funktion etwas anpassen, um den Rest-Operator für die neuen Elemente zu verwenden, und dies auch im zurückgegebenen Ergebnis verbreiten

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]


Für eine korrekte Funktionsprogrammierung und Verkettung ist eine Erfindung von Array.prototype.insert() unerlässlich. Tatsächlich hätte der Splice perfekt sein können, wenn er das mutierte Array anstelle eines völlig bedeutungslosen leeren Arrays zurückgegeben hätte. Also hier geht es

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() das obige mit dem Array.prototype.splice() mutiert das ursprüngliche Array und einige beschweren sich wie "Sie sollten nicht das ändern, was Ihnen nicht gehört" und das könnte sich als richtig herausstellen. Für das Gemeinwohl möchte ich ein anderes Array.prototype.insert() das das ursprüngliche Array nicht verändert. Hier kommt's;

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


Ich empfehle in diesem Fall die Verwendung von reinem JavaScript . Außerdem gibt es keine JavaScript-Einfügungsmethode, aber wir haben eine Methode, die eine eingebaute Array- Methode ist, die die Aufgabe für Sie erledigt. Sie wird Splice genannt .

Mal sehen, was Splice () ist ...

Die splice () -Methode ändert den Inhalt eines Arrays, indem vorhandene Elemente entfernt und / oder neue Elemente hinzugefügt werden.

OK, stellen Sie sich vor, wir haben dieses Array unten:

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

Wir können 3 so entfernen:

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

Es wird 3 zurückgegeben, aber wenn wir jetzt den Arr überprüfen, haben wir:

[1, 2, 4, 5]

So weit, so gut, aber wie können wir mit Splice ein neues Element zu Array hinzufügen? Lassen Sie uns 3 in der Arr ...

arr.splice(2, 0, 3);

Mal sehen was wir gemacht haben ...

Wir verwenden erneut Splice , aber diesmal für das zweite Argument, wir übergeben 0 , bedeutet, dass wir kein Element löschen möchten. Gleichzeitig fügen wir jedoch das dritte Argument hinzu, das 3 ist und am zweiten Index hinzugefügt wird.

Sie sollten wissen, dass wir gleichzeitig löschen und hinzufügen können. Zum Beispiel können wir jetzt Folgendes tun:

arr.splice(2, 2, 3);

Dadurch werden 2 Elemente bei Index 2 gelöscht, dann werden bei Index 2 3 hinzugefügt. Das Ergebnis lautet:

[1, 2, 3, 5];

Dies zeigt, wie jedes Element in der Verbindung funktioniert:

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


Obwohl dies bereits beantwortet wurde, füge ich diese Anmerkung für einen alternativen Ansatz hinzu.

Ich wollte eine bekannte Anzahl von Elementen in einem Array an bestimmten Positionen platzieren, da sie aus einem "assoziativen Array" (dh einem Objekt) stammen, das definitionsgemäß nicht in einer sortierten Reihenfolge garantiert ist. Ich wollte, dass das resultierende Array ein Array von Objekten ist, die Objekte jedoch in einer bestimmten Reihenfolge im Array sind, da ein Array deren Reihenfolge garantiert. Also habe ich das gemacht.

Zuerst das Quellobjekt, eine von PostgreSQL abgerufene JSONB-Zeichenfolge. Ich wollte, dass es nach der "order" -Eigenschaft in jedem untergeordneten Objekt sortiert wird.

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

Da die Anzahl der Knoten im Objekt bekannt ist, erstelle ich zunächst ein Array mit der angegebenen Länge:

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

Dann iterieren Sie das Objekt und platzieren Sie die neu erstellten temporären Objekte an den gewünschten Positionen im Array, ohne dass wirklich "Sortieren" stattfindet.

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

Sie können die Array.insert Methode folgendermaßen implementieren:

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

Dann können Sie es wie folgt verwenden:

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

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

Wenn Sie mehrere Elemente gleichzeitig in ein Array einfügen möchten, überprüfen Sie diese Antwort des s: Eine bessere Möglichkeit, ein Array in einem Array in Javascript zu verbinden

Hier sind auch einige Funktionen, um beide Beispiele zu veranschaulichen:

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

Zum Schluss noch ein jsFiddle, damit Sie es selbst sehen können: http://jsfiddle.net/luisperezphd/Wc8aS/

Und so nutzen Sie die Funktionen:

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

Einzelne Elemente an einen bestimmten Index anhängen

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

Mehrere Elemente an einen bestimmten Index anhängen

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






insert