Javascript swap array elements

Existe-t-il un moyen plus simple d'échanger deux éléments dans un tableau?

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

Vous n'avez besoin que d'une variable temporaire.

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

Modifier la meilleure réponse de détournement 10 ans plus tard avec beaucoup d'adoption ES6 sous nos ceintures:

Étant donné le tableau arr = [1,2,3,4], vous pouvez maintenant échanger des valeurs sur une seule ligne comme suit:

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

Cela produirait le tableau [2,1,3,4]. C'est une mission destructurante .

Si vous voulez une seule expression, en utilisant du javascript natif, n'oubliez pas que la valeur de retour d'une opération d'épissage contient le ou les éléments qui ont été supprimés.

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"

Éditer:

Le [0]est nécessaire à la fin de l'expression as Array.splice()renvoie un tableau, et dans cette situation, nous avons besoin de l'élément unique dans le tableau renvoyé.

Cela semble ok ....

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

Howerver utilisant

var b = list[y];

signifie un b variable va être présente pour le reste de la portée. Cela peut potentiellement entraîner une fuite de mémoire. Peu probable, mais encore mieux à éviter.

Peut-être une bonne idée de mettre cela dans Array.prototype.swap

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

qui peut être appelé comme:

list.swap( x, y )

Il s'agit d'une approche propre à la fois pour éviter les fuites de mémoire et DRY .

Selon une personne aléatoire sur Metafilter , "Les versions récentes de Javascript vous permettent de faire des échanges (entre autres) beaucoup plus proprement:"

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

Mes tests rapides ont montré que ce code Pythonic fonctionne très bien dans la version de JavaScript actuellement utilisée dans "Google Apps Script" (".gs"). Hélas, d'autres tests montrent que ce code donne un "Uncaught ReferenceError: côté gauche non valide dans l'affectation". quelle que soit la version de JavaScript (".js") est utilisée par Google Chrome version 24.0.1312.57 m.

Eh bien, vous n'avez pas besoin de mettre en mémoire tampon les deux valeurs - une seule:

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

Vous pouvez échanger des éléments dans un tableau de la manière suivante:

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

Voir l'exemple suivant:

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

Remarque: cela fonctionne de la même manière pour les variables régulières

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

Avec les valeurs numériques, vous pouvez éviter une variable temporaire en utilisant xor au niveau du bit

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

ou une somme arithmétique (en notant que cela ne fonctionne que si x + y est inférieur à la valeur maximale pour le type de données)

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

Cela n'existait pas lorsque la question a été posée, mais ES2015 a introduit la déstructuration des baies, vous permettant de l'écrire comme suit:

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

Pour échanger deux éléments consécutifs d'un tableau

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

Résumé de http://www.greywyvern.com/?post=265

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

Qu'en est-il de la destruction_assignation

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

qui peut également être étendu à

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

Considérez une telle solution sans avoir besoin de définir la troisième 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"]

Remarque: vous souhaiterez peut-être ajouter des vérifications supplémentaires, par exemple pour la longueur du tableau. Cette solution est modifiable , la swapfonction n'a donc pas besoin de renvoyer un nouveau tableau, elle effectue simplement une mutation sur le tableau passé.

Vous pouvez échanger n'importe quel nombre d'objets ou de littéraux, même de différents types, à l'aide d'une simple fonction d'identité comme celle-ci:

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

Pour votre problème:

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

Cela fonctionne en JavaScript car il accepte des arguments supplémentaires même s'ils ne sont pas déclarés ou utilisés. Les affectations, a=betc., se produisent après leur apassage dans la fonction.

Pour deux éléments ou plus (nombre fixe)

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

Aucune variable temporaire requise!

Je pensais simplement appeler list.reverse().
Mais j'ai réalisé que cela ne fonctionnerait comme échange que lorsquelist.length = x + y + 1 .

Pour un nombre variable d'éléments

J'ai examiné différentes constructions Javascript modernes à cet effet, y compris Map et map , mais malheureusement, aucune n'a abouti à un code plus compact ou plus rapide que cette construction à l'ancienne en boucle:

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>

Il existe une façon intéressante de permuter:

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

(Manière 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];

Voici une doublure qui ne mute pas list:

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

(Utilise les fonctionnalités linguistiques non disponibles en 2009 lorsque la question a été publiée!)

Voici une version compacte échange la valeur à i1 avec i2 en arr

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

Voici une variante qui vérifie d'abord si l'index existe dans le tableau:

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

Actuellement, il reviendra simplement thissi l'index n'existe pas, mais vous pouvez facilement modifier le comportement en cas d'échec

Échangez le premier et le dernier élément d'un tableau sans variable temporaire ou méthode d'échange ES6 [a, b] = [b, a]

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

Solution dactylographiée qui clone le tableau au lieu de muter celui existant

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

Juste pour le plaisir, une autre façon sans utiliser de variable supplémentaire serait:

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]

Par souci de concision, voici la version laide à une ligne qui n'est que légèrement moins laide que tout ce qui est concaténé et tranché ci-dessus. La réponse acceptée est vraiment la voie à suivre et bien plus lisible.

Donné:

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

si vous souhaitez échanger les valeurs de deux indices (a et b); alors cela le ferait:

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

Par exemple, si vous souhaitez échanger les 3 et 5, vous pouvez le faire de cette façon:

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

ou

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

Les deux donnent le même résultat:

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

#splicehatersarepunks :)

Si vous ne souhaitez pas utiliser la variable temp dans ES5, c'est une façon d'échanger les éléments du tableau.

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 ]

essayez cette fonction ...

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

Utilisation d' ES6 il est possible de le faire comme ceci ...

Imaginez que vous ayez ces 2 tableaux ...

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

et vous voulez échanger les premières valeurs:

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

et valeur:

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

Usage:

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

Si vous souhaitez permuter uniquement les premiers et derniers éléments:

array.unshift( array.pop() );