webentwicklung-frage-antwort-db.com.de

Javascript - Ein Array in ein anderes Array einfügen

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.

66
ic3

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

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

http://jsfiddle.net/f3cae/ </ s>

11
user113716

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.

8
Elmer

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
}
2
jfriend00

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

1
Hek mat

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!

1
RangerMauve

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]);
       }
    }
}
0
Gabriel Kohen

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.

0

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;
}
0
arlomedia
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);
0
Bhesh Gurung