É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;
26 réponses
vous n'avez besoin que d'une seule variable temporaire.
var b = list[y];
list[y] = list[x];
list[x] = b;
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é.
ç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 .
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.
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;
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]
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];
Digest from http://www.greywyvern.com/?post=265
var a = 5, b = 9;
b = (a += b -= a) - b;
alert([a, b]); // alerts "9, 5"
pour échanger deux éléments consécutifs du tableau
array.splice(IndexToSwap,2,array[IndexToSwap+1],array[IndexToSwap]);
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]
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
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.
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: </td> <td><code></code></td></tr>
</table>
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];
il y a une façon intéressante d'échanger:
var a = 1;
var b = 2;
[a,b] = [b,a];
(ES6 façon)
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!)
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))
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.
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
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]
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:)
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 ]
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>
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()]
si nécessaire, ne remplacer que les premier et dernier éléments:
array.unshift( array.pop() );
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);