有没有更简单的方法来交换数组中的两个元素？
var a = list[x], b = list[y];
list[y] = a;
list[x] = b;
答案 0 :(得分：295)
您只需要一个临时变量。
var b = list[y];
list[y] = list[x];
list[x] = b;
编辑劫持最佳答案，我们已经接受了大量的ES6采用：
给定数组arr = [1,2,3,4]，您可以现在交换一行中的值：
[arr[0], arr[1]] = [arr[1], arr[0]];
这将生成数组[2,1,3,4]。这是destructuring assignment。
答案 1 :(得分：103)
如果你想要一个表达式，使用原生的javascript， 记住来自拼接操作的返回值 包含已删除的元素。
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"
编辑：
[0]在表达式结束时是必需的，因为Array.splice()返回一个数组，在这种情况下，我们需要返回数组中的单个元素。
答案 2 :(得分：67)
这似乎没问题....
var b = list[y];
list[y] = list[x];
list[x] = b;
Howerver使用
var b = list[y];
意味着 b 变量将出现在范围的其余部分。这可能会导致内存泄漏。不太可能，但最好避免。
将这个放入Array.prototype.swap
也许是一个好主意Array.prototype.swap = function (x,y) {
var b = this[x];
this[x] = this[y];
this[y] = b;
return this;
}
可以被称为：
list.swap( x, y )
对于避免内存泄漏和DRY，这是一种干净的方法。
答案 3 :(得分：45)
根据some random person on Metafilter， “Javascript的最新版本允许你更加巧妙地进行交换（以及其他事情）：”
[ list[x], list[y] ] = [ list[y], list[x] ];
我的快速测试显示，此Pythonic code在JavaScript版本中效果很好 目前用于“Google Apps脚本”（“。gs”）。 唉，进一步的测试显示这段代码给出了“未捕获的ReferenceError：赋值中的左侧无效”。在 使用的是任何版本的JavaScript（“。js”） 谷歌浏览器版本24.0.1312.57 m。
答案 4 :(得分：29)
好吧，你不需要缓冲两个值 - 只有一个：
var tmp = list[x];
list[x] = list[y];
list[y] = tmp;
答案 5 :(得分：21)
您可以通过以下方式交换数组中的元素：
list[x] = [list[y],list[y]=list[x]][0]
请参阅以下示例：
list = [1,2,3,4,5]
list[1] = [list[3],list[3]=list[1]][0]
//list is now [1,4,3,2,5]
注意：对于常规变量
，它的工作方式相同var a=1,b=5;
a = [b,b=a][0]
答案 6 :(得分：18)
使用数字值可以通过使用按位xor
来避免临时变量list[x] = list[x] ^ list[y];
list[y] = list[y] ^ list[x];
list[x] = list[x] ^ list[y];
或算术和（注意这只有在x + y小于数据类型的最大值时才有效）
list[x] = list[x] + list[y];
list[y] = list[x] - list[y];
list[x] = list[x] - list[y];
答案 7 :(得分：14)
摘自http://www.greywyvern.com/?post=265
var a = 5, b = 9;
b = (a += b -= a) - b;
alert([a, b]); // alerts "9, 5"
答案 8 :(得分：14)
当提出问题时，这并不存在，但ES2015引入了数组解构，允许您按如下方式编写：
let a = 1, b = 2;
// a: 1, b: 2
[a, b] = [b, a];
// a: 2, b: 1
答案 9 :(得分：13)
交换数组的两个连续元素
array.splice(IndexToSwap,2,array[IndexToSwap+1],array[IndexToSwap]);
答案 10 :(得分：9)
var arr = [1, 2, 3, 4]
[arr[index1], arr[index2]] = [arr[index2], arr[index1]]
也可以扩展到
[src order elements] => [dest order elements]
答案 11 :(得分：7)
您可以使用这样的简单身份函数交换任意数量的对象或文字，甚至是不同类型的文字：
var swap = function (x){return x};
b = swap(a, a=b);
c = swap(a, a=b, b=c);
对于你的问题：
var swap = function (x){return x};
list[y] = swap(list[x], list[x]=list[y]);
这适用于JavaScript，因为即使未声明或使用它们，它也会接受其他参数。分配a=b等在a传递给函数后发生。
答案 12 :(得分：6)
[list[y], list[x]] = [list[x], list[y]];
无需临时变量！
我在考虑简单地拨打list.reverse()
但后来我意识到它只能在list.length = x + y + 1时作为交换。
我已经研究了各种现代Javascript结构，包括Map和map，但遗憾的是没有一个代码比这个老式的循环更紧凑或更快 - 基础建设：
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>
答案 13 :(得分：5)
考虑这种解决方案，而无需定义第三个变量：
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"]
注意：您可能需要添加其他检查，例如数组长度。此解决方案是可变的，因此swap函数无需返回新数组，只需对传入的数组进行突变即可。
答案 14 :(得分：5)
有一种有趣的交换方式：
var a = 1;
var b = 2;
[a,b] = [b,a];
（ES6方式）
答案 15 :(得分：4)
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];
答案 16 :(得分：3)
这是一个不会改变list的单行：
let newList = Object.assign([], list, {[x]: list[y], [y]: list[x]})
（使用2009年问题发布时无法提供的语言功能！）
答案 17 :(得分：1)
Typescript解决方案，可克隆数组而不是对现有数组进行突变
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;
}
答案 18 :(得分：1)
这是一个紧凑版本 在i1中交换值与arr中的i2
arr.slice(0,i1).concat(arr[i2],arr.slice(i1+1,i2),arr[i1],arr.slice(i2+1))
答案 19 :(得分：0)
function moveElement(array, sourceIndex, destinationIndex) {
return array.map(a => a.id === sourceIndex ? array.find(a => a.id === destinationIndex): a.id === destinationIndex ? array.find(a => a.id === sourceIndex) : a )
}
let arr = [
{id: "1",title: "abc1"},
{id: "2",title: "abc2"},
{id: "3",title: "abc3"},
{id: "4",title: "abc4"}];
moveElement(arr, "2","4");
答案 20 :(得分：0)
只是为了它的乐趣，另一种不使用任何额外变量的方法是：
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]
答案 21 :(得分：0)
这是一个变体，首先检查数组中是否存在索引：
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;
}
如果索引不存在，它目前只返回this，但您可以在失败时轻松修改行为
答案 22 :(得分：0)
为了简洁起见，这是一个丑陋的单行版本，它只比上面的所有内容和切片略显丑陋。接受的答案是真正的方式，更具可读性。
假设：
var foo = [ 0, 1, 2, 3, 4, 5, 6 ];
如果你想交换两个指数（a和b）的值;然后就可以了：
foo.splice( a, 1, foo.splice(b,1,foo[a])[0] );
例如，如果你想交换3和5，你可以这样做：
foo.splice( 3, 1, foo.splice(5,1,foo[3])[0] );
或
foo.splice( 5, 1, foo.splice(3,1,foo[5])[0] );
两者产生相同的结果：
console.log( foo );
// => [ 0, 1, 2, 5, 4, 3, 6 ]
#splicehatersarepunks：）
答案 23 :(得分：0)
尝试使用此功能...
$(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>
答案 24 :(得分：0)
交换没有临时变量或ES6交换方法[a，b] = [b，a]的数组中的第一个和最后一个元素
[a.pop(), ...a.slice(1), a.shift()]
答案 25 :(得分：0)
使用 ES6 可以这样做...
想象一下，您有这些 2个数组 ...
const a = ["a", "b", "c", "d", "e"];
const b = [5, 4, 3, 2, 1];
，您想交换第一个值：
const [a0] = a;
a[0] = b[0];
b[0] = a0;
和值：
a; //[5, "b", "c", "d", "e"]
b; //["a", 4, 3, 2, 1]
答案 26 :(得分：0)
var arr = [1, 2];
arr.splice(0, 2, arr[1], arr[0]);
console.log(arr); //[2, 1]
答案 27 :(得分：-1)
非就地解决方案
let swap= (arr,i,j)=> arr.map((e,k)=> k-i ? (k-j ? e : arr[i]) : arr[j]);
let swap= (arr,i,j)=> arr.map((e,k)=> k-i ? (k-j ? e : arr[i]) : arr[j]);
// test index: 3<->5 (= 'f'<->'d')
let a= ["a","b","c","d","e","f","g"];
let b= swap(a,3,5);
console.log(a,"\n", b);
console.log('Example Flow:', swap(a,3,5).reverse().join('-') );
和就地解决方案
let swap= (arr,i,j)=> {let t=arr[i]; arr[i]=arr[j]; arr[j]=t; return arr}
// test index: 3<->5 (= 'f'<->'d')
let a= ["a","b","c","d","e","f","g"];
console.log( swap(a,3,5) )
console.log('Example Flow:', swap(a,3,5).reverse().join('-') );
在此解决方案中，我们使用"flow pattern"，这意味着swap函数将数组作为结果返回-这允许使用点.（例如reverse和{{ 1}}中的摘要
答案 28 :(得分：-1)
如果您不想在ES5中使用temp变量，这是交换数组元素的一种方法。
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 ]
答案 29 :(得分：-3)
如果只需要交换第一个和最后一个元素：
array.unshift( array.pop() );
答案 30 :(得分：-3)
Array.prototype.swap = function(a, b) {
var temp = this[a];
this[a] = this[b];
this[b] = temp;
};
用法：
var myArray = [0,1,2,3,4...];
myArray.swap(4,1);