Éléments du tableau d'échange Javascript

Est-il un moyen plus simple pour échanger deux éléments dans un tableau?

var a = list[x], b = list[y];
list[y] = a;
list[x] = b;
135
demandé sur ken 2009-05-16 16:10:28

26 réponses

vous n'avez besoin que d'une seule variable temporaire.

var b = list[y];
list[y] = list[x];
list[x] = b;
228
répondu tvanfosson 2009-05-16 12:14:16

si vous voulez une seule expression, en utilisant javascript natif, rappelez-vous que la valeur de retour d'une opération d'épissure contient le ou les élément(s) qui a été supprimé.

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"

Edit:

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

97
répondu kennebec 2012-10-21 06:05:50

ça semble correct....

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

Mais à l'aide de

var b = list[y];

signifie que la variable b sera présente pour le reste du champ d'application. Cela peut potentiellement conduire à une fuite de mémoire. Peu probable, mais encore mieux d'éviter.

peut-être une bonne idée de mettre ceci en réseau.prototype.échange 151950920"

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 )

C'est un propre approche à la fois éviter les fuites de mémoire et SEC .

60
répondu Stefan 2009-06-12 07:29:22

selon une personne quelconque sur Metafilter , "Les versions récentes de Javascript vous permettent de faire des swaps (entre autres choses) beaucoup plus proprement: "

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

mes tests rapides ont montré que ce code pythonique fonctionne très bien dans la version de JavaScript actuellement utilisé dans" Google Apps Script" (".g"). Hélas, d'autres tests montrent que ce code donne un "Référenceerror Uncaught: côté gauche invalide dans l'affectation." dans quelle que soit la version de JavaScript (".js") est utilisé par Google Chrome Version 24.0.1312.57 M.

34
répondu David Cary 2017-05-23 11:54:59

Eh bien, vous n'avez pas besoin de tampon les deux valeurs - un seul:

var tmp = list[x];
list[x] = list[y];
list[y] = tmp;
27
répondu Marc Gravell 2009-05-16 12:14:38

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]

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

var a=1,b=5;
a = [b,b=a][0]
19
répondu Jan 2014-02-26 21:17:17

avec des valeurs numériques, vous pouvez éviter une variable temporaire en utilisant bitwise xor

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

ou une somme arithmétique (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];
18
répondu Jakub Arnold 2014-08-14 18:27:41

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

var a = 5, b = 9;    
b = (a += b -= a) - b;    
alert([a, b]); // alerts "9, 5"
13
répondu R-way Orz 2011-03-08 14:14:04

pour échanger deux éléments consécutifs du tableau

array.splice(IndexToSwap,2,array[IndexToSwap+1],array[IndexToSwap]);
12
répondu Piyush Madan 2012-12-09 07:51:34

qu'en est-il Destructuring_assignment

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]
8
répondu ROROROOROROR 2018-01-22 07:29:25

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

let a = 1, b = 2;
// a: 1, b: 2
[a, b] = [b, a];
// a: 2, b: 1
8
répondu dirkdig 2018-08-23 01:14:58

vous pouvez échanger n'importe quel nombre d'objets ou littérales, même de types différents, en utilisant 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 parce qu'il accepte des arguments supplémentaires même s'ils ne sont pas déclarés ou utilisés. Les assignations a=b etc, se produisent après a est passé dans la fonction.

6
répondu dansalmo 2013-12-16 00:47:09

pour deux ou plusieurs éléments (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 ça ne fonctionnerait comme swap que lorsque list.length = x + y + 1 .

pour nombre variable d'éléments

j'ai examiné diverses constructions Javascript modernes à cet effet, y compris carte et carte , mais malheureusement aucun n'a abouti à un code plus compact ou plus rapide que cette ancienne construction 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>
5
répondu 7vujy0f0hy 2017-05-03 13:14:17
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];
4
répondu Nathan Romano 2011-06-17 23:40:04

il y a une façon intéressante d'échanger:

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

(ES6 façon)

4
répondu Vivek 2017-05-29 10:43:17

Voici une doublure qui ne mute pas list :

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

(utilise des fonctionnalités linguistiques non disponibles en 2009 lorsque la question a été postée!)

2
répondu fmg 2017-09-09 15:31:44

Voici une version compacte swaps valeur à i1 avec i2 en arr .151920920"

arr.slice(0,i1).concat(arr[i2],arr.slice(i1+1,i2),arr[i1],arr.slice(i2+1))
1
répondu user2044802 2014-01-20 09:09:12

envisager une telle solution sans avoir à 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"]

Note: Vous pouvez ajouter des vérifications supplémentaires par exemple pour la longueur du tableau. Cette solution est mutable donc swap fonction n'a pas besoin de retourner un nouveau tableau, il fait juste mutation sur tableau passé dans.

1
répondu Shevchenko Viktor 2018-09-07 14:53:31

Voici une variation qui vérifie d'abord si l'indice 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;
}

il retournera simplement this si l'index n'existe pas, mais vous pourriez facilement modifier le comportement sur fail

0
répondu Douglas.Sesar 2015-11-25 14:20:22

juste pour le plaisir, une autre façon sans utiliser Aucune 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]
0
répondu vsync 2017-04-03 08:54:02

par souci de brièveté, voici la version moche à une doublure qui n'est que légèrement moins moche que tout ce qui est concat et tranchant ci-dessus. La réponse acceptée est vraiment la voie à suivre et beaucoup plus lisible.

:

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

si vous voulez échanger les valeurs de deux indices (a et b); alors ce serait:

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

Par exemple, si vous voulez é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:)

0
répondu Jasonovich 2018-05-22 14:45:12

si vous ne voulez pas utiliser la variable temp dans ES5, c'est une façon d'échanger des éléments de 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 ]
0
répondu venkat7668 2018-06-21 05:04:02

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>
0
répondu bilal chaudhari 2018-06-21 05:45:06

Swap premier et dernier élément d'un tableau sans variable temporaire ou méthode de swap ES6 [a, b] = [b, a]

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

0
répondu gengns 2018-07-08 15:09:33

si nécessaire, ne remplacer que les premier et dernier éléments:

array.unshift( array.pop() );
-3
répondu Alex Moonlight 2016-07-16 03:12:04
Array.prototype.swap = function(a, b) {
  var temp = this[a];
  this[a] = this[b];
  this[b] = temp;
};

Utilisation:

var myArray = [0,1,2,3,4...];
myArray.swap(4,1);
-5
répondu user2472643 2018-08-22 22:33:04