Verschieben eines Array-Elements von einer Array-Position zu einer anderen

Question

Ich habe eine harte Zeit herauszufinden, wie man ein Element eines Arrays zu bewegen. Zum Beispiel, gegeben die folgenden:

var array = [ 'a', 'b', 'c', 'd', 'e'];

Wie kann ich eine Funktion schreiben, um das Element zu verschieben 'd' links von 'b' ?

O 'a' rechts von 'c' ?

Nach dem Verschieben der Elemente sollten die Indizes der übrigen Elemente aktualisiert werden. Die resultierende Anordnung wäre:

array = ['a', 'd', 'b', 'c', 'e']

Das scheint ziemlich einfach zu sein, aber ich kann es nicht begreifen.

Answer 1

Objektorientiert, ausdrucksstark, debuggingfähig, ohne Mutation, getestet.

class Sorter {
    sortItem(array, fromIndex, toIndex) {
        const reduceItems = () => {
            const startingItems = array.slice(0, fromIndex);
            const endingItems = array.slice(fromIndex + 1);
            return startingItems.concat(endingItems);
        }
        const addMovingItem = (movingItem, reducedItems) => {
            const startingNewItems = reducedItems.slice(0, toIndex);
            const endingNewItems = reducedItems.slice(toIndex);
            const newItems = startingNewItems.concat([movingItem]).concat(endingNewItems);
            return newItems;
        }
        const movingItem = array[fromIndex];
        const reducedItems = reduceItems();
        const newItems = addMovingItem(movingItem, reducedItems);
        return newItems;
    }
}

const sorter = new Sorter();
export default sorter;

import sorter from 'src/common/Sorter';

test('sortItem first item forward', () => {
    const startingArray = ['a', 'b', 'c', 'd'];
    const expectedArray = ['b', 'a', 'c', 'd'];
    expect(sorter.sortItem(startingArray, 0, 1)).toStrictEqual(expectedArray);
});
test('sortItem middle item forward', () => {
    const startingArray = ['a', 'b', 'c', 'd'];
    const expectedArray = ['a', 'c', 'b', 'd'];
    expect(sorter.sortItem(startingArray, 1, 2)).toStrictEqual(expectedArray);
});
test('sortItem middle item backward', () => {
    const startingArray = ['a', 'b', 'c', 'd'];
    const expectedArray = ['a', 'c', 'b', 'd'];
    expect(sorter.sortItem(startingArray, 2, 1)).toStrictEqual(expectedArray);
});
test('sortItem last item backward', () => {
    const startingArray = ['a', 'b', 'c', 'd'];
    const expectedArray = ['a', 'b', 'd', 'c'];
    expect(sorter.sortItem(startingArray, 3, 2)).toStrictEqual(expectedArray);
});

Answer 2

Array.move.js

Zusammenfassung

Verschiebt Elemente innerhalb eines Arrays und gibt ein Array zurück, das die verschobenen Elemente enthält.

Syntax

array.move(index, howMany, toIndex);

Parameter

Index : Index, bei dem Elemente verschoben werden sollen. Falls negativ, Index wird vom Ende her beginnen.

howMany : Anzahl der zu verschiebenden Elemente von Index .

toIndex : Index des Arrays, an dem die verschobenen Elemente platziert werden sollen. Falls negativ, toIndex wird vom Ende her beginnen.

Verwendung

array = ["a", "b", "c", "d", "e", "f", "g"];

array.move(3, 2, 1); // returns ["d","e"]

array; // returns ["a", "d", "e", "b", "c", "f", "g"]

Polyfill

Array.prototype.move || Object.defineProperty(Array.prototype, "move", {
    value: function (index, howMany, toIndex) {
        var
        array = this,
        index = parseInt(index) || 0,
        index = index < 0 ? array.length + index : index,
        toIndex = parseInt(toIndex) || 0,
        toIndex = toIndex < 0 ? array.length + toIndex : toIndex,
        toIndex = toIndex <= index ? toIndex : toIndex <= index + howMany ? index : toIndex - howMany,
        moved;

        array.splice.apply(array, [toIndex, 0].concat(moved = array.splice(index, howMany)));

        return moved;
    }
});

Answer 3

Als Ergänzung zu Reid's ausgezeichnete Antwort (und weil ich keinen Kommentar abgeben kann); Sie können modulo verwenden, um sowohl negative Indizes als auch zu große Indizes "umzudrehen":

function array_move(arr, old_index, new_index) {
  new_index =((new_index % arr.length) + arr.length) % arr.length;
  arr.splice(new_index, 0, arr.splice(old_index, 1)[0]);
  return arr; // for testing
}

// returns [2, 1, 3]
console.log(array_move([1, 2, 3], 0, 1));

Answer 4

Ich habe mein Problem wie folgt gelöst immutability-helper Bibliothek.

import update from 'immutability-helper';

const move = (arr: any[], from: number, to: number) => update(arr, {
  $splice: [
    [from, 1],
    [to, 0, arr[from] as string],
  ],
});

const testArray = ['a', 'b', 'c', 'd', 'e'];
console.log(move(testArray, 1, 3)); // [ 'c', 'b', 'c', 'd', 'e' ]
console.log(move(testArray, 4, 0)); // [ 'e', 'b', 'c', 'd', 'a' ]

Answer 5

Ich habe die schöne Antwort von @Reid , hatte aber Probleme damit, ein Element vom Ende eines Arrays einen Schritt weiter zu verschieben - an den Anfang (wie in einer Schleife ). Z.B. ['a', 'b', 'c'] sollte durch den Aufruf von .move(2,3) zu ['c', 'a', 'b'] werden

Ich habe dies erreicht, indem ich den Fall für new_index >= this.length geändert habe.

Array.prototype.move = function (old_index, new_index) {
        console.log(old_index + " " + new_index);
        while (old_index < 0) {
            old_index += this.length;
        }
        while (new_index < 0) {
            new_index += this.length;
        }
        if (new_index >= this.length) {
            new_index = new_index % this.length;
        }
        this.splice(new_index, 0, this.splice(old_index, 1)[0]);
        return this; // for testing purposes
    };