Elementos de matriz de intercambio de Javascript

¿Hay alguna forma más simple de intercambiar dos elementos en una matriz?

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

Solo necesita una variable temporal.

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

Edite la respuesta principal de secuestro 10 años después con mucha adopción de ES6 bajo nuestros cinturones:

Dada la matriz arr = [1,2,3,4], puede intercambiar valores en una línea ahora así:

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

Esto produciría la matriz [2,1,3,4]. Esta es una tarea desestructuradora .

Si desea una sola expresión, utilizando JavaScript nativo, recuerde que el valor de retorno de una operación de empalme contiene los elementos que se eliminaron.

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"

Editar:

El [0]es necesario al final de la expresión, ya que Array.splice()devuelve una matriz, y en esta situación requerimos el único elemento en la matriz devuelta.

Esto parece estar bien ...

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

Howerver usando

var b = list[y];

significa que una variable b va a estar presente para el resto del alcance. Esto puede conducir a una pérdida de memoria. Improbable, pero aún mejor evitarlo.

Quizás sea una buena idea poner esto en Array.prototype.swap

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

que se puede llamar como:

list.swap( x, y )

Este es un enfoque limpio para evitar pérdidas de memoria y SECO .

Según una persona aleatoria en Metafilter , "las versiones recientes de Javascript le permiten hacer intercambios (entre otras cosas) mucho más claramente:"

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

Mis pruebas rápidas mostraron que este código Pythonic funciona muy bien en la versión de JavaScript utilizada actualmente en "Google Apps Script" (".gs"). Por desgracia, otras pruebas muestran que este código proporciona un "Error de referencia no capturado: lado izquierdo no válido en la asignación". en cualquier versión de JavaScript (".js") utilizada por Google Chrome Versión 24.0.1312.57 m.

Bueno, no necesita almacenar ambos valores, solo uno:

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

Puede intercambiar elementos en una matriz de la siguiente manera:

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

Vea el siguiente ejemplo:

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

Nota: funciona de la misma manera para variables regulares

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

Con valores numéricos puede evitar una variable temporal utilizando bitor xor

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

o una suma aritmética (teniendo en cuenta que esto solo funciona si x + y es menor que el valor máximo para el tipo de datos)

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

Esto no existía cuando se hizo la pregunta, pero ES2015 introdujo la desestructuración de la matriz, lo que le permite escribirla de la siguiente manera:

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

Para intercambiar dos elementos consecutivos de la matriz

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

Recopilación de http://www.greywyvern.com/?post=265

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

¿Qué pasa con Destructuring_assignment

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

que también se puede extender a

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

Considere tal solución sin necesidad de definir la tercera variable:

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"]

Nota: es posible que desee agregar comprobaciones adicionales, por ejemplo, para la longitud de la matriz. Esta solución es mutable, por lo que la swapfunción no necesita devolver una nueva matriz, solo hace la mutación sobre la matriz pasada.

Puede intercambiar cualquier cantidad de objetos o literales, incluso de diferentes tipos, utilizando una función de identidad simple como esta:

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

Para su problema:

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

Esto funciona en JavaScript porque acepta argumentos adicionales incluso si no se declaran ni se utilizan. Las asignaciones a=b, etc., suceden después de apasar a la función.

Para dos o más elementos (número fijo)

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

¡No se requiere una variable temporal!

Estaba pensando en simplemente llamar list.reverse().
Pero luego me di cuenta de que funcionaría como intercambio solo cuando list.length = x + y + 1.

Para un número variable de elementos

He examinado varias construcciones Javascript modernas para este efecto, incluyendo Map y map , pero lamentablemente ninguna ha resultado en un código que sea más compacto o más rápido que esta construcción antigua basada en bucles:

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>

Hay una forma interesante de intercambio:

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

(Forma ES6)

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

Aquí hay una frase que no muta list:

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

(Utiliza funciones de idioma que no estaban disponibles en 2009 cuando se publicó la pregunta)

Aquí hay un valor de intercambio de versión compacta en i1 con i2 en arr

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

Aquí hay una variación que primero verifica si el índice existe en la matriz:

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

Actualmente solo regresará thissi el índice no existe, pero podría modificar fácilmente el comportamiento en caso de falla

Intercambie el primer y el último elemento en una matriz sin variable temporal o método de intercambio ES6 [a, b] = [b, a]

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

Solución mecanografiada que clona la matriz en lugar de mutar la existente

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

Solo por el gusto de hacerlo, otra forma sin usar ninguna variable adicional sería:

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]

En aras de la brevedad, aquí está la versión fea de una sola línea que es solo un poco menos fea que toda esa concat y rebanadas anteriores. La respuesta aceptada es realmente el camino a seguir y mucho más legible.

Dado:

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

si desea intercambiar los valores de dos índices (a y b); entonces esto lo haría:

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

Por ejemplo, si desea intercambiar el 3 y el 5, puede hacerlo de esta manera:

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

o

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

Ambos producen el mismo resultado:

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

#splicehatersarepunks :)

Si no desea utilizar la variable temporal en ES5, esta es una forma de intercambiar elementos de la matriz.

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 ]

prueba esta función ...

$(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>

Usando ES6 es posible hacerlo así ...

Imagina que tienes estas 2 matrices ...

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

y quieres intercambiar los primeros valores:

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

y valor:

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

Uso:

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

Si es necesario, intercambie solo el primer y el último elemento:

array.unshift( array.pop() );