Javascript-Swap-Array-Elemente

Gibt es eine einfachere Möglichkeit, zwei Elemente in einem Array auszutauschen?

var a = list[x], b = list[y];
list[y] = a;
list[x] = b;

Sie benötigen nur eine temporäre Variable.

var b = list[y];
list[y] = list[x];
list[x] = b;

Bearbeiten Sie die Entführung der Top-Antwort 10 Jahre später mit viel ES6-Akzeptanz:

In Anbetracht des Arrays arr = [1,2,3,4]können Sie die Werte jetzt wie folgt in einer Zeile austauschen:

[arr[0], arr[1]] = [arr[1], arr[0]];

Dies würde das Array erzeugen [2,1,3,4]. Dies ist eine Destrukturierungsaufgabe .

Wenn Sie einen einzelnen Ausdruck mit nativem Javascript verwenden möchten, denken Sie daran, dass der Rückgabewert einer Spleißoperation die Elemente enthält, die entfernt wurden.

var A = [1, 2, 3, 4, 5, 6, 7, 8, 9], x= 0, y= 1;
A[x] = A.splice(y, 1, A[x])[0];
alert(A); // alerts "2,1,3,4,5,6,7,8,9"

Bearbeiten:

Das [0]ist am Ende des Ausdrucks erforderlich, da es Array.splice()ein Array zurückgibt. In dieser Situation benötigen wir das einzelne Element im zurückgegebenen Array.

Das scheint in Ordnung zu sein ....

var b = list[y];
list[y] = list[x];
list[x] = b;

Wie auch immer mit

var b = list[y];

bedeutet, dass eine b- Variable für den Rest des Bereichs vorhanden sein wird. Dies kann möglicherweise zu einem Speicherverlust führen. Unwahrscheinlich, aber immer noch besser zu vermeiden.

Vielleicht eine gute Idee, dies in Array.prototype.swap einzufügen

Array.prototype.swap = function (x,y) {
  var b = this[x];
  this[x] = this[y];
  this[y] = b;
  return this;
}

was wie folgt genannt werden kann:

list.swap( x, y )

Dies ist ein sauberer Ansatz, um sowohl Speicherlecks als auch DRY zu vermeiden .

Laut einer zufälligen Person auf Metafilter "können Sie in neueren Versionen von Javascript (unter anderem) viel sauberer Swaps durchführen:"

[ list[x], list[y] ] = [ list[y], list[x] ];

Meine schnellen Tests haben gezeigt, dass dieser Pythonic-Code in der Version von JavaScript, die derzeit in "Google Apps Script" (".gs") verwendet wird, hervorragend funktioniert. Leider zeigen weitere Tests, dass dieser Code einen "Nicht erfassten Referenzfehler: Ungültige linke Seite in Zuweisung" ergibt. in welcher Version von JavaScript (".js") von Google Chrome Version 24.0.1312.57 m verwendet wird.

Nun, Sie müssen nicht beide Werte puffern - nur einen:

var tmp = list[x];
list[x] = list[y];
list[y] = tmp;

Sie können Elemente in einem Array folgendermaßen austauschen:

list[x] = [list[y],list[y]=list[x]][0]

Siehe folgendes Beispiel:

list = [1,2,3,4,5]
list[1] = [list[3],list[3]=list[1]][0]
//list is now [1,4,3,2,5]

Hinweis: Dies funktioniert für reguläre Variablen genauso

var a=1,b=5;
a = [b,b=a][0]

Mit numerischen Werten können Sie eine temporäre Variable vermeiden, indem Sie bitweises xor verwenden

list[x] = list[x] ^ list[y];
list[y] = list[y] ^ list[x];
list[x] = list[x] ^ list[y];

oder eine arithmetische Summe (wobei zu beachten ist, dass dies nur funktioniert, wenn x + y kleiner als der Maximalwert für den Datentyp ist)

list[x] = list[x] + list[y];
list[y] = list[x] - list[y];
list[x] = list[x] - list[y];

Dies war nicht vorhanden, als die Frage gestellt wurde, aber ES2015 führte die Array-Destrukturierung ein, sodass Sie sie wie folgt schreiben können:

let a = 1, b = 2;
// a: 1, b: 2
[a, b] = [b, a];
// a: 2, b: 1

Zwei aufeinanderfolgende Elemente des Arrays austauschen

array.splice(IndexToSwap,2,array[IndexToSwap+1],array[IndexToSwap]);

Digest von http://www.greywyvern.com/?post=265

var a = 5, b = 9;    
b = (a += b -= a) - b;    
alert([a, b]); // alerts "9, 5"

Was ist mit Destructuring_assignment?

var arr = [1, 2, 3, 4]
[arr[index1], arr[index2]] = [arr[index2], arr[index1]]

die auch erweitert werden kann

[src order elements] => [dest order elements]

Betrachten Sie eine solche Lösung, ohne die dritte Variable definieren zu müssen:

function swap(arr, from, to) {
  arr.splice(from, 1, arr.splice(to, 1, arr[from])[0]);
}

var letters = ["a", "b", "c", "d", "e", "f"];

swap(letters, 1, 4);

console.log(letters); // ["a", "e", "c", "d", "b", "f"]

Hinweis: Möglicherweise möchten Sie zusätzliche Überprüfungen hinzufügen, z. B. für die Arraylänge. Diese Lösung ist veränderbar, sodass die swapFunktion kein neues Array zurückgeben muss, sondern nur eine Mutation über das übergebene Array.

Mit einer einfachen Identitätsfunktion wie der folgenden können Sie eine beliebige Anzahl von Objekten oder Literalen, auch unterschiedlicher Art, austauschen:

var swap = function (x){return x};
b = swap(a, a=b);
c = swap(a, a=b, b=c);

Für Ihr Problem:

var swap = function (x){return x};
list[y]  = swap(list[x], list[x]=list[y]);

Dies funktioniert in JavaScript, da zusätzliche Argumente akzeptiert werden, auch wenn sie nicht deklariert oder verwendet werden. Die Zuweisungen a=busw. erfolgen, nachdem sie aan die Funktion übergeben wurden.

Für zwei oder mehr Elemente (feste Nummer)

[list[y], list[x]] = [list[x], list[y]];

Keine temporäre Variable erforderlich!

Ich dachte darüber nach, einfach anzurufen list.reverse().
Aber dann wurde mir klar, dass es nur dann als Tausch funktionieren würde list.length = x + y + 1.

Für variable Anzahl von Elementen

Ich habe verschiedene moderne Javascript-Konstruktionen zu diesem Zweck untersucht, einschließlich Map und Map , aber leider hat keine zu einem Code geführt, der kompakter oder schneller war als diese altmodische, schleifenbasierte Konstruktion:

function multiswap(arr,i0,i1) {/* argument immutable if string */
    if (arr.split) return multiswap(arr.split(""), i0, i1).join("");
    var diff = [];
    for (let i in i0) diff[i0[i]] = arr[i1[i]];
    return Object.assign(arr,diff);
}

Example:
    var alphabet = "abcdefghijklmnopqrstuvwxyz";
    var [x,y,z] = [14,6,15];
    var output = document.getElementsByTagName("code");
    output[0].innerHTML = alphabet;
    output[1].innerHTML = multiswap(alphabet, [0,25], [25,0]);
    output[2].innerHTML = multiswap(alphabet, [0,25,z,1,y,x], [25,0,x,y,z,3]);

<table>
    <tr><td>Input:</td>                        <td><code></code></td></tr>
    <tr><td>Swap two elements:</td>            <td><code></code></td></tr>
    <tr><td>Swap multiple elements:&nbsp;</td> <td><code></code></td></tr>
</table>

Es gibt eine interessante Art zu tauschen:

var a = 1;
var b = 2;
[a,b] = [b,a];

(ES6 Weg)

var a = [1,2,3,4,5], b=a.length;

for (var i=0; i<b; i++) {
    a.unshift(a.splice(1+i,1).shift());
}
a.shift();
//a = [5,4,3,2,1];

Hier ist ein Einzeiler, der nicht mutiert list:

let newList = Object.assign([], list, {[x]: list[y], [y]: list[x]})

(Verwendet Sprachfunktionen, die 2009 nicht verfügbar waren, als die Frage gestellt wurde!)

Hier ist eine kompakte Version, die den Wert bei i1 gegen i2 in arr austauscht

arr.slice(0,i1).concat(arr[i2],arr.slice(i1+1,i2),arr[i1],arr.slice(i2+1))

Hier ist eine Variante, die zuerst prüft, ob der Index im Array vorhanden ist:

Array.prototype.swapItems = function(a, b){
    if(  !(a in this) || !(b in this) )
        return this;
    this[a] = this.splice(b, 1, this[a])[0];
    return this;
}

Derzeit wird nur zurückgegeben, thiswenn der Index nicht vorhanden ist. Sie können das Verhalten jedoch bei einem Fehler leicht ändern

Tauschen Sie das erste und letzte Element in einem Array ohne temporäre Variable oder ES6-Swap-Methode aus [a, b] = [b, a]

[a.pop(), ...a.slice(1), a.shift()]

Typoskript-Lösung, die das Array klont, anstatt das vorhandene zu mutieren

export function swapItemsInArray<T>(items: T[], indexA: number, indexB: number): T[] {
  const itemA = items[indexA];

  const clone = [...items];

  clone[indexA] = clone[indexB];
  clone[indexB] = itemA;

  return clone;
}

Nur zum Spaß wäre ein anderer Weg ohne zusätzliche Variable:

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];

// swap index 0 and 2
arr[arr.length] = arr[0];   // copy idx1 to the end of the array
arr[0] = arr[2];            // copy idx2 to idx1
arr[2] = arr[arr.length-1]; // copy idx1 to idx2
arr.length--;               // remove idx1 (was added to the end of the array)


console.log( arr ); // -> [3, 2, 1, 4, 5, 6, 7, 8, 9]

Der Kürze halber ist hier die hässliche Einzeiler-Version, die nur geringfügig weniger hässlich ist als all das Concat und Slicing oben. Die akzeptierte Antwort ist wirklich der richtige Weg und lesbarer.

Gegeben:

var foo = [ 0, 1, 2, 3, 4, 5, 6 ];

wenn Sie die Werte zweier Indizes (a und b) tauschen möchten; dann würde das es tun:

foo.splice( a, 1, foo.splice(b,1,foo[a])[0] );

Wenn Sie beispielsweise die 3 und 5 tauschen möchten, können Sie dies folgendermaßen tun:

foo.splice( 3, 1, foo.splice(5,1,foo[3])[0] );

oder

foo.splice( 5, 1, foo.splice(3,1,foo[5])[0] );

Beide ergeben das gleiche Ergebnis:

console.log( foo );
// => [ 0, 1, 2, 5, 4, 3, 6 ]

#splicehatersarepunks :)

Wenn Sie in ES5 keine temporäre Variable verwenden möchten, können Sie auf diese Weise Array-Elemente austauschen.

var swapArrayElements = function (a, x, y) {
  if (a.length === 1) return a;
  a.splice(y, 1, a.splice(x, 1, a[y])[0]);
  return a;
};

swapArrayElements([1, 2, 3, 4, 5], 1, 3); //=> [ 1, 4, 3, 2, 5 ]

Probieren Sie diese Funktion aus ...

$(document).ready(function () {
        var pair = [];
        var destinationarray = ['AAA','BBB','CCC'];

        var cityItems = getCityList(destinationarray);
        for (var i = 0; i < cityItems.length; i++) {
            pair = [];
            var ending_point = "";
            for (var j = 0; j < cityItems[i].length; j++) {
                pair.push(cityItems[i][j]);
            }
            alert(pair);
            console.log(pair)
        }

    });
    function getCityList(inputArray) {
        var Util = function () {
        };

        Util.getPermuts = function (array, start, output) {
            if (start >= array.length) {
                var arr = array.slice(0);
                output.push(arr);
            } else {
                var i;

                for (i = start; i < array.length; ++i) {
                    Util.swap(array, start, i);
                    Util.getPermuts(array, start + 1, output);
                    Util.swap(array, start, i);
                }
            }
        }

        Util.getAllPossiblePermuts = function (array, output) {
            Util.getPermuts(array, 0, output);
        }

        Util.swap = function (array, from, to) {
            var tmp = array[from];
            array[from] = array[to];
            array[to] = tmp;
        }
        var output = [];
        Util.getAllPossiblePermuts(inputArray, output);
        return output;
    }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Mit ES6 ist das möglich ...

Stellen Sie sich vor, Sie haben diese 2 Arrays ...

const a = ["a", "b", "c", "d", "e"];
const b = [5, 4, 3, 2, 1];

und Sie möchten die ersten Werte tauschen:

const [a0] = a;
a[0] = b[0];
b[0] = a0;

und Wert:

a; //[5, "b", "c", "d", "e"]
b; //["a", 4, 3, 2, 1]

Array.prototype.swap = function(a, b) {
  var temp = this[a];
  this[a] = this[b];
  this[b] = temp;
};

Verwendung:

var myArray = [0,1,2,3,4...];
myArray.swap(4,1);

Bei Bedarf nur das erste und das letzte Element austauschen:

array.unshift( array.pop() );