Hier gibt es einige wirklich kreative Antworten auf diese Frage. Hier ist eine einfache Lösung für diejenigen, die gerade erst mit Arrays beginnen. Auf Wunsch kann es bis zu ECMAScript 3-kompatiblen Browsern verwendet werden.
Wissen Sie etwas über Spleißen, bevor Sie beginnen.
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 Hilfe .splice()könnte ein Ziel zu spalten sein a1oben , indem Sie eine der beiden Formen in Kopf und Schwanz - Arrays.
Bei Verwendung der Methode 1 wird der Rückgabewert zum Kopf und a1zum Schwanz.
let head = a1.splice(startIndex, deleteCount); // returns [1,2], a1 would be [3,4]
Verketten 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ürzere:
/**
*@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 Prämisse dominiert die Lösung - füllen Sie ein leeres Array.
2) Die Nomenklatur von Kopf, Körper und Schwanz fühlt sich natürlich an.
3) Kein doppelter Anruf bei .slice(). Überhaupt kein Schneiden.
4) Nein .apply(). Sehr unnötig.
5) Methodenverkettung wird vermieden.
6) Funktioniert in ECMAScript 3 und 5 einfach mit oder varanstelle von letoder 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 zumindest .concat()!!!!
Hinweis: Die Verwendung des Spread-Opearators ...erleichtert dies erheblich.