Wie füge ich ein Element an einem bestimmten Index (JavaScript) in ein Array ein?

2931

Ich suche nach einer JavaScript-Array-Einfügemethode im Stil von:

arr.insert(index, item)

Am besten in jQuery, aber jede JavaScript-Implementierung reicht an dieser Stelle aus.

tags2k
quelle
96
Beachten Sie, dass JQuery eine DOM- und Ereignismanipulationsbibliothek ist, keine eigene Sprache. Es hat nichts mit Array-Manipulation zu tun.
Domino
25
api.jquery.com/jQuery.inArray hat nichts mit dem DOM oder Ereignissen zu tun. jQuery hat sich zu einem gemischten Toolkit für die JS-Entwicklung in Browsern entwickelt, was dazu führt, dass die Leute erwarten, dass es für alles eine Methode gibt.
Tim
4
@ Tim, aber es ist immer noch keine eigene Sprache (immer noch gibt es einige Fragen wie "Wie man zwei Zahlen in jQuery summiert" hier auf SO)
Victor
3
@ Victor Nein, und wird es nie sein. jQuery war nützlich und relevant, aber es hat ausgedient.
Tim
1
Siehe auch diese für eine verdrehte Überraschung (:
noobie

Antworten:

4756

Was Sie wollen, ist die spliceFunktion für das native Array-Objekt.

arr.splice(index, 0, item);einfügen wird itemin arram angegebenen Index (Löschen 0Artikel zuerst, das heißt, es ist nur ein Einsatz).

In diesem Beispiel erstellen wir ein Array und fügen ihm ein Element in Index 2 hinzu:

var arr = [];
arr[0] = "Jani";
arr[1] = "Hege";
arr[2] = "Stale";
arr[3] = "Kai Jim";
arr[4] = "Borge";

console.log(arr.join());
arr.splice(2, 0, "Lene");
console.log(arr.join());

Tvanfosson
quelle
168
Danke, ich dachte, ich würde mich dumm fühlen zu fragen, aber jetzt, wo ich die Antwort kenne, weiß ich es nicht! Warum um alles in der Welt haben sie beschlossen, es Spleiß zu nennen, wenn ein durchsuchbarer Begriff für dieselbe Funktion gebräuchlich war?!
Tags2k
83
@ tags2k: weil die Funktion mehr kann als nur Elemente einzufügen und ihr Name bereits in Perl festgelegt wurde?
Christoph
55
Spleiß kann einfügen, aber genauso häufig nicht . Beispiel: arr.splice(2,3)Entfernt 3 Elemente ab Index 2. Ohne Übergabe des 3. .... N-ten Parameters wird nichts eingefügt. Der Name wird dem insert()also auch nicht gerecht.
EBarr
14
Ich denke, der Begriff "Spleiß" macht Sinn. Spleißen bedeutet verbinden oder verbinden, auch ändern. Sie haben ein etabliertes Array, das Sie jetzt "ändern", was das Hinzufügen oder Entfernen von Elementen beinhalten würde. Sie geben an, wo im Array begonnen werden soll, wie viele alte Elemente entfernt werden sollen (falls vorhanden) und zuletzt optional eine Liste neuer Elemente, die hinzugefügt werden sollen. Splice ist natürlich auch ein großartiger Science-Fiction-Begriff.
Jakub Keller
286

Sie können die Array.insertMethode 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' ]
FrEsC 81
quelle
9
Um mehrere Elemente einzufügen, können Sie verwendenArray.prototype.insert = function (index, items) { this.splice.apply(this, [index, 0].concat(items)); }
Ryan Smith
7
Das Problem beim Hinzufügen von Dingen zum Array ist, dass die Funktion als Element
angezeigt
7
Beachten Sie jedoch, dass es nicht empfohlen wird, native Typen zu erweitern, da dies möglicherweise anderen Code oder zukünftige Funktionen beeinträchtigt.
Marsze
17
Ändern Sie keine Objekte, die Sie nicht besitzen
Luis Cabrera Benito
4
Ändern Sie keine Prototypen
satya164
141

Anders als beim Spleißen können Sie diesen Ansatz verwenden, bei dem das ursprüngliche Array nicht mutiert wird, sondern ein neues Array mit dem hinzugefügten Element erstellt wird. Sie sollten Mutationen nach Möglichkeit vermeiden, wann immer dies möglich ist. 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 mehr als ein Element hinzuzufügen, indem Sie die Funktion ein wenig optimieren, um den Restoperator für die neuen Elemente zu verwenden, und dies auch im zurückgegebenen Ergebnis verteilen

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]

Gafi
quelle
1
Ist das ein guter und sicherer Weg, dies zu tun? Ich frage, weil dies so elegant und prägnant erscheint, aber keine anderen Antworten berühren dies. Die meisten von ihnen modifizieren das Prototypobjekt!
Harte Kanchina
5
@ HarshKanchina Das liegt wahrscheinlich daran, dass die meisten Antworten vor ES6 sind, aber dieser Ansatz ist jetzt aus meiner Erfahrung sehr verbreitet
Gafi
77

Benutzerdefinierte Array- insertMethoden

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 es native splicetut) und unterstützt die Verkettung:

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

2. Unterstützung beim Zusammenführen und Verketten von Argumenten vom Typ 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;
};

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/

Vision
quelle
Gibt es eine kompakte Möglichkeit, mit dieser Version auch ein Array zusammenzuführen, wenn es eines in den Argumenten findet?
Nolo
Ich verstehe das erste Ergebnis nicht ["b", "X", "Y", "Z", "c"]. Warum ist nicht "d"enthalten? Es scheint mir, dass Sie slice()alle 6 Elemente im Rückgabewert erhalten sollten , wenn Sie 6 als zweiten Parameter von und 6 Elemente im Array beginnend mit dem angegebenen Index angeben. (Das Dokument sagt howManyfür diesen Parameter.) Developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Alexis Wilke
Wenn ich einen Index von 3 oder mehr verwende, wird in der Ausgabe nichts angezeigt (Fall 1., FireFox) ["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(3, 3);=>[ ]
Alexis Wilke
@AlexisWilke Im ersten Beispiel habe ich eine sliceMethode verwendet und nicht splice, auf die Sie sich im Kommentar beziehen. Der zweite Parameter von slice(benannt end) ist ein auf Null basierender Index, bei dem die Extraktion beendet werden soll. sliceAuszüge bis zu, aber nicht einschließlichend . Daher, nachdem insertSie haben ["a", "b", "X", "Y", "Z", "c", "d"], aus denen sliceElemente mit Indizes von 1bis extrahiert werden 6, dh von "b"bis, "d"aber nicht einschließlich "d". Macht das Sinn?
VisioN
41

Wenn Sie mehrere Elemente gleichzeitig in ein Array einfügen möchten, lesen Sie diese Antwort zum Stapelüberlauf: Eine bessere Möglichkeit, ein Array in Javascript in ein Array zu verbinden

Auch hier sind 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;
}

Schließlich ist hier eine jsFiddle, damit Sie sie 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);
Luis Perez
quelle
1
Wäre insertAt () nicht besser, insertArrayAt () aufzurufen, wenn ein ArrayToInsert mit einem einzelnen Element erstellt wurde? Dadurch wird die Wiederholung identischen Codes vermieden.
Matt Sach
1
Dies ist ein großartiges Beispiel für die Verwendung von 'apply'
CRice
Ich habe dieser Methode einen removeCount-Parameter hinzugefügt, um die Fähigkeit von splice zu nutzen, auch Elemente an diesem Index zu entfernen: Array.prototype.splice.apply (array, [index, removeCount || 0] .concat (arrayToInsert));
CRice
23

Für eine ordnungsgemäße funktionale Programmierung und Verkettung ist eine Erfindung von Array.prototype.insert()wesentlich. Tatsächlich hätte der Spleiß perfekt sein können, wenn er das mutierte Array anstelle eines völlig bedeutungslosen leeren Arrays zurückgegeben hätte. Also los geht's

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

Nun gut, das obige mit dem Array.prototype.splice()einen mutiert das ursprüngliche Array und einige könnten sich beschweren wie "Sie sollten nicht ändern, was Ihnen nicht gehört" und das könnte sich auch als richtig herausstellen. Für das Gemeinwohl möchte ich eine andere geben, Array.prototype.insert()die das ursprüngliche Array nicht mutiert. 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));

Reduzieren
quelle
2
"ein völlig bedeutungsloses leeres Array" - gibt nur dann ein leeres Array zurück, wenn der zweite Parameter 0 ist. Wenn er größer als 0 ist, werden die aus dem Array entfernten Elemente zurückgegeben. Angesichts der Tatsache, dass Sie einen Prototyp hinzufügen und splicedas ursprüngliche Array mutieren, glaube ich nicht, dass "ordnungsgemäße funktionale Programmierung" irgendwo in die Nähe von gehört splice.
Chrisbajorin
Wir sprechen hier über Einfügen und der zweite Parameter von Array.prototype.splice () muss Null sein. Und was es zurückgibt, hat keine andere Bedeutung als "Ich habe nichts gelöscht" und da wir es zum Einfügen eines Elements verwenden, haben wir diese Informationen bereits. Wenn Sie das ursprüngliche Array nicht mutieren möchten, können Sie dasselbe mit zwei Array.prototype.slice () - und einer Array.prototype.concat () -Operation tun. Es liegt an dir.
Reduzieren Sie
1
Ihre zweite Implementierung ist die sauberste auf dieser ganzen Seite und Sie haben keine Stimmen. Bitte nimm meine und mach weiter so. (Sie sollten nur vermeiden, den Prototyp zu mutieren, aber das wissen Sie bereits)
NiKo
1
Ich denke, es ist erwähnenswert, dass der Rest-Parameter neu ECMA 6 ist ( developer.mozilla.org/en/docs/Web/JavaScript/Reference/… )
Geza Turi
18

Ich empfehle in diesem Fall die Verwendung von reinem JavaScript. Es gibt auch keine Einfügemethode in JavaScript, aber wir haben eine Methode, die eine integrierte Array- Methode ist, die die Arbeit für Sie erledigt. Sie heißt Spleiß ...

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 so entfernen 3:

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

Es wird 3 zurückgeben, aber wenn wir die Arr jetzt überprüfen, haben wir:

[1, 2, 4, 5]

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

arr.splice(2, 0, 3);

Mal sehen, was wir getan haben ...

Wir verwenden wieder Spleiß , aber dieses Mal übergeben wir für das zweite Argument 0 , was bedeutet, dass wir kein Element löschen möchten, aber gleichzeitig fügen wir das dritte Argument hinzu, nämlich 3, das beim zweiten Index hinzugefügt wird ...

Sie sollten sich bewusst sein, 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 3 bei Index 2 hinzugefügt und das Ergebnis lautet:

[1, 2, 3, 5];

Dies zeigt, wie jedes Element im Spleiß funktioniert:

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

Alireza
quelle
13

Fügen Sie ein einzelnes Element an einen bestimmten Index an

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

Hängen Sie mehrere Elemente an einen bestimmten Index an

//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
Srikrushna
quelle
8
Beachten Sie, dass arrName [3] nicht angehängt wird, sondern überschreibt.
Sfratini
Es fügt das Element dem vorhandenen Array hinzu, das nicht überfahren wird. Beispiel: let arrName = ['xxx', 'yyy', 'zzz']; arrName.splice (1, 0, 'aaa', 'bbb', 'ccc'); Nach dem Drucken der arrName
Srikrushna
Wenn arrName mehr als 3 Elemente enthält, überschreiben Sie das dritte und hängen es nicht an. Oder sehe ich das falsch?
Sfratini
Wenn wir ein Element in die Mitte einfügen, wird das nächste Element nicht überschrieben. Bitte geben Sie Ihr Problem an, was Sie brauchen. Nehmen Sie ein Array (Beispiel) und was Sie für die Ausgabe benötigen. Bitte kommentieren Sie mich
Srikrushna
1
@Srikrushna arrName[3] = 'newName1';wird angehängt , wenn das Array nur 3 Elemente enthält. Wenn Index 3 ein Element enthält, wird dieses ersetzt. Wenn Sie am Ende anhängen möchten, ist es besser zu verwendenarrName.push('newName1');
Ehrfurcht
6

Eine andere mögliche Lösung mit der Verwendung von Array#reduce.

var arr = ["apple", "orange", "raspberry"],
    arr2 = [1, 2, 4];

function insert(arr, item, index) {
    arr = arr.reduce(function(s, a, i) {
      i == index ? s.push(item, a) : s.push(a);
      return s;
    }, []);   
    console.log(arr);
}

insert(arr, "banana", 1);
insert(arr2, 3, 2);

freundlicher Benutzer
quelle
6

Hier sind zwei Möglichkeiten:

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

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

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

ODER

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

M. Hamza Rajput
quelle
4

Obwohl dies bereits beantwortet wurde, füge ich diesen Hinweis 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 per Definition nicht garantiert in einer sortierten Reihenfolge vorliegt. Ich wollte, dass das resultierende Array ein Array von Objekten ist, aber die Objekte sollten sich in einer bestimmten Reihenfolge im Array befinden, da ein Array ihre Reihenfolge garantiert. Also habe ich das gemacht.

Zuerst das Quellobjekt, eine aus PostgreSQL abgerufene JSONB-Zeichenfolge. Ich wollte, dass es in jedem untergeordneten Objekt nach der Eigenschaft "order" 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);

Anschließend iterieren Sie das Objekt und platzieren die neu erstellten temporären Objekte an den gewünschten Stellen im Array, ohne dass wirklich "sortiert" wird.

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);
Ville
quelle
3

Jeder, der immer noch Probleme mit diesem hat und alle oben genannten Optionen ausprobiert hat und es nie bekommen hat. Ich teile meine Lösung, um zu berücksichtigen, dass Sie die Eigenschaften Ihres Objekts gegenüber dem Array nicht explizit angeben möchten.

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

Dies ist eine Kombination aus Iteration des Referenzarrays und Vergleich mit dem Objekt, das Sie überprüfen möchten. Konvertieren Sie beide in eine Zeichenfolge und iterieren Sie sie, wenn sie übereinstimmt. Dann können Sie einfach zählen. Dies kann verbessert werden, aber hier habe ich mich niedergelassen. Hoffe das hilft.

Clyde
quelle
3

Profitieren Sie von der Reduktionsmethode wie folgt:

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

Auf diese Weise können wir ein neues Array zurückgeben (dies ist eine coole funktionale Methode - viel besser als Push oder Splice), wobei das Element am Index eingefügt wird. Wenn der Index größer als die Länge des Arrays ist, wird es eingefügt Am Ende.

Alejoko
quelle
3

Array#splice()ist der richtige Weg, es sei denn, Sie möchten wirklich vermeiden, dass das Array mutiert. Gegeben zwei Arrays arr1und arr2hier, wie Sie den Inhalt einfügen würden arr2in arr1nach dem ersten Elemente:

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)

Wenn Sie Bedenken haben, das Array zu mutieren (z. B. wenn Sie Immutable.js verwenden), können Sie stattdessen verwenden slice(), nicht zu verwechseln splice()mit a 'p'.

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

Ich habe es versucht und es funktioniert gut!

var initialArr = ["India","China","Japan","USA"];
initialArr.splice(index, 0, item);

Index ist die Position, an der Sie das Element einfügen oder löschen möchten. 0 dh der zweite Parameter definiert die Anzahl der Elemente aus dem zu entfernenden Indexelement. Dies sind die neuen Einträge, die Sie im Array vornehmen möchten. Es kann einer oder mehrere sein.

initialArr.splice(2, 0, "Nigeria");
initialArr.splice(2, 0, "Australia","UK");
Pawan
quelle
4
Kopieren Sie einfach die obige Antwort. Dies bringt keinen Mehrwert für die Frage. Entweder fügen Sie eine neue Antwort hinzu oder Sie kommentieren eine vorhandene. Bitte versuchen Sie etwas Neues beizutragen. Wir wollen diese Community nicht verderben
Hannad Rehman
1

Hier ist eine Arbeitsfunktion, die ich in einer meiner Anwendungen verwende.

Dies prüft, ob das Element beendet wird

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

Und dann nenne ich es unten.

ifExist("friends", [ ' ( ', ' )' ], 1)}  // output: ( friends )
ifExist("friends", [ ' - '], 1)}  // output:  - friends 
ifExist("friends", [ ':'], 0)}  // output:   friends: 
Lesly Revenge
quelle
1

Ein bisschen wie ein älterer Thread, aber ich muss Redu oben zustimmen, da Splice definitiv eine etwas verwirrende Oberfläche hat. Und die Antwort von cdbajorin, dass "ein leeres Array nur zurückgegeben wird, wenn der zweite Parameter 0 ist. Wenn es größer als 0 ist, werden die aus dem Array entfernten Elemente zurückgegeben", beweist dies den Punkt, obwohl es genau ist. Die Absicht der Funktion ist es, zu verbinden oder, wie bereits von Jakob Keller gesagt, "zu verbinden oder zu verbinden, auch zu ändern. Sie haben ein etabliertes Array, das Sie jetzt ändern, was das Hinzufügen oder Entfernen von Elementen beinhalten würde ..." Der Rückgabewert der Elemente, falls vorhanden, die entfernt wurden, ist bestenfalls umständlich. Und ich stimme zu 100% zu, dass diese Methode besser zur Verkettung geeignet gewesen wäre, wenn sie das zurückgegeben hätte, was natürlich erscheint, ein neues Array mit den hinzugefügten gespleißten Elementen. Dann könnten Sie Dinge wie ["19", "17"]. Splice (1,0, "18"). Join ("...") oder was auch immer Sie mit dem zurückgegebenen Array mögen. Die Tatsache, dass es zurückgibt, was entfernt wurde, ist meiner Meinung nach nur ein Unsinn. Wenn die Absicht der Methode darin bestand, "eine Reihe von Elementen auszuschneiden", und das war vielleicht nur die Absicht. Es scheint, als ob ich, wenn ich nicht weiß, was ich bereits ausschneide, wahrscheinlich wenig Grund habe, diese Elemente auszuschneiden, nicht wahr? Es wäre besser, wenn es sich wie Concat, Map, Reduce, Slice usw. verhalten würde, wenn ein neues Array aus dem vorhandenen Array erstellt wird, anstatt das vorhandene Array zu mutieren. Diese sind alle verkettbar, und das ist ein wichtiges Problem. Es ist ziemlich üblich, Array-Manipulationen zu verketten. Es scheint, als müsste die Sprache in die eine oder andere Richtung gehen und versuchen, so weit wie möglich daran festzuhalten. Da Javascript funktional und weniger aussagekräftig ist, scheint es nur eine seltsame Abweichung von der Norm zu sein.

meem
quelle
-2

Performance

Heute (2020.04.24) führe ich Tests für ausgewählte Lösungen für große und kleine Arrays durch. Ich habe sie auf MacOs High Sierra 10.13.6 auf Chrome 81.0, Safari 13.1, Firefox 75.0 getestet.

Schlussfolgerungen

Für alle Browser

  • überraschenderweise sind bei kleinen Arrays nicht vorhandene Lösungen, die auf sliceund reduce(D, E, F) basieren, normalerweise 10x-100x schneller als in-place-Lösungen
  • Bei großen Arrays waren die auf splice(AI, BI, CI) basierenden In-Place-Lösungen am schnellsten (manchmal ~ 100x - dies hängt jedoch von der Arraygröße ab).
  • Für kleine Arrays war die BI-Lösung am langsamsten
  • Für große Arrays war die E-Lösung am langsamsten

Geben Sie hier die Bildbeschreibung ein

Einzelheiten

Die Tests wurden in zwei Gruppen unterteilt: In-Place-Lösungen (AI, BI, CI) und Nicht-In-Place-Lösungen (D, E, F) und wurden für zwei Fälle durchgeführt

  • Test für Array mit 10 Elementen - Sie können es HIER ausführen
  • Test für Array mit 1.000.000 Elementen - Sie können es HIER ausführen

Der getestete Code ist im folgenden Snippet dargestellt

Beispielergebnisse für kleine Arrays auf Chrom sind unten aufgeführt

Geben Sie hier die Bildbeschreibung ein

Kamil Kiełczewski
quelle