Was ist der effizientere Weg, um ein Array in ein anderes Array einzufügen.
a1 = [1,2,3,4,5];
a2 = [21,22];
newArray - a1.insertAt(2,a2) -> [1,2, 21,22, 3,4,5];
Wenn Sie das a2-Array mit einem Splice iterieren, ist dies aus Performance-Sicht etwas unpassend, wenn das Array a2 groß ist.
Vielen Dank.
Sie können splice
kombiniert mit einigen apply
-Tricks verwenden:
a1 = [1,2,3,4,5];
a2 = [21,22];
a1.splice.apply(a1, [2, 0].concat(a2));
console.log(a1); // [1, 2, 21, 22, 3, 4, 5];
In ES2015 + können Sie stattdessen den Spread-Operator verwenden, um dies etwas schöner zu gestalten
a1.splice(2, 0, ...a2);
Hatte es zuerst falsch gemacht. Sollte stattdessen concat()
verwendet haben.
var a1 = [1,2,3,4,5];
var a2 = [21,22];
var result = a1.slice( 0, 2 ).concat( a2 ).concat( a1.slice( 2 ) );
Beispiel:http://jsfiddle.net/f3cae/1/
Dies erfordert eine slice()
[docs] von a1
bis zum Index, dann eine concat()
[docs] um a2
zu diesem Array hinzuzufügen, verwendet .concat()
erneut, wobei eine weitere .slice()
von a1
genommen wird, diesmal jedoch vom selben Index bis zum Ende.
Und fügen Sie es zu Array.prototype
hinzu, wenn Sie möchten:
Beispiel:http://jsfiddle.net/f3cae/2/
Array.prototype.injectArray = function( idx, arr ) {
return this.slice( 0, idx ).concat( arr ).concat( this.slice( idx ) );
};
var a1 = [1,2,3,4,5];
var a2 = [21,22];
var result = a1.injectArray( 2, a2 );
Sie können die splice()
verwenden.[docs] Methode ohne zu iterieren.
a1.splice( 2, 0, a2 );
Sie können dies jetzt tun, wenn Sie ES2015 oder höher verwenden:
var a1 = [1,2,3,4,5];
var a2 = [21,22];
a1.splice(2, 0, ...a2);
console.log(a1) // => [1,2,21,22,3,4,5]
Weitere Informationen zum Spread-Operator (...) https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator finden Sie hier.
Ich wollte einen Weg finden, dies mit splice()
und ohne Iteration zu tun: http://jsfiddle.net/jfriend00/W9n27/ .
a1 = [1,2,3,4,5];
a2 = [21,22];
a2.unshift(2, 0); // put first two params to splice onto front of array
a1.splice.apply(a1, a2); // pass array as arguments parameter to splice
console.log(a1); // [1, 2, 21, 22, 3, 4, 5];
Im allgemeinen Funktionsformular:
function arrayInsertAt(destArray, pos, arrayToInsert) {
var args = [];
args.Push(pos); // where to insert
args.Push(0); // nothing to remove
args = args.concat(arrayToInsert); // add on array to insert
destArray.splice.apply(destArray, args); // splice it in
}
Der Operator spread ermöglicht die Erweiterung eines Ausdrucks an Stellen, an denen mehrere Argumente (für Funktionsaufrufe) oder mehrere Elemente (für Array-Literale) erwartet werden.
a2 = [21,22];
a1 = [1,2,...a2,3,4,5];//...a2 is use of spread operator
console.log(a1);
Wenn Sie ein anderes Array in ein Array einfügen möchten, ohne ein neues zu erstellen, verwenden Sie am besten entweder Push
oder unshift
mit apply
.
Z.B:
a1 = [1,2,3,4,5];
a2 = [21,22];
// Insert a1 at beginning of a2
a2.unshift.apply(a2,a1);
// Insert a1 at end of a2
a2.Push.apply(a2,a1);
Dies funktioniert, weil sowohl Push
als auch unshift
eine variable Anzahl von Argumenten haben . Ein Bonus: Sie können ganz einfach auswählen, von welchem Ende aus das Array angehängt werden soll!
Wie bereits in einem anderen Thread erwähnt, funktionieren die obigen Antworten nicht in sehr großen Arrays (200K-Elementen). Eine alternative Antwort finden Sie hier, einschließlich Spleiß und manuellem Push: https://stackoverflow.com/a/41465578/1038326
Array.prototype.spliceArray = function(index, insertedArray) {
var postArray = this.splice(index);
inPlacePush(this, insertedArray);
inPlacePush(this, postArray);
function inPlacePush(targetArray, pushedArray) {
// Not using forEach for browser compatability
var pushedArrayLength = pushedArray.length;
for (var index = 0; index < pushedArrayLength; index++) {
targetArray.Push(pushedArray[index]);
}
}
}
Auf diese Frage gibt es hier einige wirklich kreative Antworten. Hier ist eine einfache Lösung für diejenigen, die gerade erst mit Arrays beginnen. Falls gewünscht, kann es bis hinunter zu ECMAScript 3-kompatiblen Browsern verwendet werden.
Bevor Sie beginnen, sollten Sie sich mit Spleißen vertraut machen.
Mozilla Developer Network: Array.prototype.splice ()
Verstehen Sie zunächst zwei wichtige Formen von .splice()
.
let a1 = [1,2,3,4],
a2 = [1,2];
Methode 1) Entfernen Sie x (deleteCount) -Elemente ausgehend von einem gewünschten Index.
let startIndex = 0,
deleteCount = 2;
a1.splice(startIndex, deleteCount); // returns [1,2], a1 would be [3,4]
Methode 2) Entfernen Sie Elemente nach einem gewünschten Startindex bis zum Ende des Arrays.
a1.splice(2); // returns [3,4], a1 would be [1,2]
Mit .splice()
könnte ein Ziel darin bestehen, a1
mithilfe einer der beiden obigen Formen in Head- und Tail-Arrays aufzuteilen.
Bei Verwendung von Methode 1 wird der Rückgabewert zum head und der a1
zum tail.
let head = a1.splice(startIndex, deleteCount); // returns [1,2], a1 would be [3,4]
Verknüpfen Sie nun auf einen Schlag Kopf, Körper (a2
) und Schwanz
[].concat(head, a2, a1);
Somit ähnelt diese Lösung mehr der realen Welt als jede andere, die bisher vorgestellt wurde. Würden Sie das nicht mit Legos machen? ;-) Hier ist eine Funktion, die mit Methode 2 durchgeführt wurde.
/**
*@param target Array The array to be split up into a head and tail.
*@param body Array The array to be inserted between the head and tail.
*@param startIndex Integer Where to split the target array.
*/
function insertArray(target, body, startIndex)
{
let tail = target.splice(startIndex); // target is now [1,2] and the head
return [].concat(target, body, tail);
}
let newArray = insertArray([1, 2, 3, 4], ["a", "b"], 2); // [1, 2, "a", "b", 3, 4]
Kürzer:
/**
*@param target Array The array to be split up into a head and tail.
*@param body Array The array to be inserted between the head and tail.
*@param startIndex Integer Where to split the target array.
*/
function insertArray(target, body, startIndex)
{
return [].concat(target, body, target.splice(startIndex));
}
Sicherer:
/**
*@param target Array The array to be split up into a head and tail.
*@param body Array The array to be inserted between the head and tail.
*@param startIndex Integer Where to split the target array.
*@throws Error The value for startIndex must fall between the first and last index, exclusive.
*/
function insertArray(target, body, startIndex)
{
const ARRAY_START = 0,
ARRAY_END = target.length - 1,
ARRAY_NEG_END = -1,
START_INDEX_MAGNITUDE = Math.abs(startIndex);
if (startIndex === ARRAY_START) {
throw new Error("The value for startIndex cannot be zero (0).");
}
if (startIndex === ARRAY_END || startIndex === ARRAY_NEG_END) {
throw new Error("The startIndex cannot be equal to the last index in target, or -1.");
}
if (START_INDEX_MAGNITUDE >= ARRAY_END) {
throw new Error("The absolute value of startIndex must be less than the last index.");
}
return [].concat(target, body, target.splice(startIndex));
}
Die Vorteile dieser Lösung umfassen:
1) Eine einfache Voraussetzung dominiert die Lösung - füllen Sie ein leeres Array.
2) Die Nomenklatur für Kopf, Körper und Schwanz fühlt sich natürlich an.
3) Kein Doppelanruf an .slice()
. Überhaupt kein Schneiden.
4) Nein .apply()
. Sehr unnötig.
5) Methodenverkettung wird vermieden.
6) Funktioniert in ECMAScript 3 und 5 einfach mit var
anstelle von let
oder const
.
** 7) Stellt sicher, dass im Gegensatz zu vielen anderen vorgestellten Lösungen Kopf und Schwanz auf den Körper geschlagen werden können. Wenn Sie ein Array vor oder nach den Grenzen hinzufügen, sollten Sie mindestens .concat()
verwenden !!!!
Hinweis: Die Verwendung des Spread Opearator ...
macht all dies viel einfacher zu bewerkstelligen.
Hier ist meine Version ohne besondere Tricks:
function insert_array(original_array, new_values, insert_index) {
for (var i=0; i<new_values.length; i++) {
original_array.splice((insert_index + i), 0, new_values[i]);
}
return original_array;
}
var a1 = [1,2,3,4,5];
var a2 = [21,22];
function injectAt(d, a1, a2) {
for(var i=a1.length-1; i>=d; i--) {
a1[i + a2.length] = a1[i];
}
for(var i=0; i<a2.length; i++) {
a1[i+d] = a2[i];
}
}
injectAt(2, a1, a2);
alert(a1);