Javascript交换数组元素

有没有更简单的方法来交换数组中的两个元素

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

---

您只需要一个临时变量

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]

。这是。

好吧，您不需要同时缓冲两个值-只需缓冲一个：

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

---

对于数值，可以使用位异或避免临时变量

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

或算术和（注意，只有当x+y小于数据类型的最大值时，此方法才有效）

这似乎没问题

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

如何使用服务器

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 )

---

这是一种干净的方法，既可以避免内存泄漏，又可以。

如果您想要一个表达式，请使用本机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]

，因为

数组。splice（）

返回一个数组，在这种情况下，我们需要返回数组中的单个元素。

摘要自

var a=[1,2,3,4,5]，b=a.length；
用于（var i=0；i交换数组的两个连续元素

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

根据,，
“最新版本的Javascript允许您更灵活地进行交换（除其他外）：

我的快速测试表明，这在JavaScript版本中非常有效
目前在“谷歌应用程序脚本”（“.gs”）中使用。
唉，进一步的测试表明，这段代码给出了一个“未捕获的引用错误：赋值中的左侧无效”
所使用的JavaScript（“.js”）的任何版本
Google Chrome 24.0.1312.57 m版。
这是一个精简版
用arr中的i2交换i1处的值

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

您可以使用以下简单的标识函数交换任意数量的对象或文字，即使是不同类型的对象或文字：

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
传递到函数后。
有一种有趣的交换方式：

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

（ES6方式）
您可以通过以下方式交换数组中的元素：

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]

以下是一个变体，首先检查数组中是否存在索引：

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
，但您可以很容易地修改失败时的行为

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

当提出这个问题时，这种情况并不存在，但ES2015引入了阵列分解，允许您按如下方式编写：

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

为了好玩，不使用任何额外变量的另一种方法是：


var-arr=[1,2,3,4,5,6,7,8,9]；
//互换指数0和2
arr[arr.length]=arr[0]；//将idx1复制到数组的末尾
arr[0]=arr[2]；//将idx2复制到idx1
arr[2]=arr[arr.length-1]；//将idx1复制到idx2
arr.length-->//删除idx1（已添加到数组末尾）
console.log（arr）；//->[3,2,1,4,5,6,7,8,9]
用于两个或多个元素（固定编号）
不需要临时变量

我正在考虑只调用
list.reverse（）


但后来我意识到，只有当
list.length=x+y+1
时，它才可以作为交换

对于可变数量的元素
我研究了各种现代Javascript结构，包括和，但遗憾的是，没有一种代码比这种老式的基于循环的结构更紧凑或更快：


函数multiswap（arr，i0，i1）{/*参数不可变如果字符串*/
if（arr.split）返回multiswap（arr.split（“”），i0，i1.join（“”）；
var-diff=[]；
对于（设i在i0中）diff[i0[i]=arr[i1[i]]；
返回Object.assign（arr，diff）；
}
例子：
var alphabet=“abcdefghijklmnopqrstuvxyz”；
var[x，y，z]=[14,6,15]；
var输出=document.getElementsByTagName（“代码”）；
输出[0]。innerHTML=字母表；
输出[1]。innerHTML=multiswap（字母表[0,25]，[25,0]）；
输出[2]。innerHTML=multiswap（字母[0,25，z，1，y，x]，[25,0，x，y，z，3]）；

输入：

交换两个元素：

交换多个元素：

这里有一个不会变异的单行程序
列表
：

让newList=Object.assign（[]，list，{[x]：list[y]，[y]：list[x]}）

（使用了2009年问题发布时没有的语言功能！）
那怎么办

这也可以扩展到

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

为了简洁起见，这是一个丑陋的单行版本，它只比上面所有的concat和slicing稍微难看一点。公认的答案是真正的方式去做，更可读

鉴于：

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

或

两者产生相同的结果：

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

#如果您不想在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 ]

试试这个功能…


$（文档）.ready（函数（）{
var对=[]；
var destinationarray=['AAA'、'BBB'、'CCC']；
var cityItems=getCityList（destinationarray）；
对于（变量i=0；i[src order elements] => [dest order elements]

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

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

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 ]

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 ]

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]

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

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");

let swap= (arr,i,j)=> arr.map((e,k)=> k-i ? (k-j ? e : arr[i]) : arr[j]);