Javascript 重新排序数组

比如说，我有一个数组，看起来像这样：

var playlist = [
    {artist:"Herbie Hancock", title:"Thrust"},
    {artist:"Lalo Schifrin", title:"Shifting Gears"},
    {artist:"Faze-O", title:"Riding High"}
];

var tmp = playlist.splice(2,1);
playlist.splice(2,0,tmp);

function swapElement(array, indexA, indexB) {
  var tmp = array[indexA];
  array[indexA] = array[indexB];
  array[indexB] = tmp;
}

swapElement(playlist, 1, 2);
// [{"artist":"Herbie Hancock","title":"Thrust"},
//  {"artist":"Faze-O","title":"Riding High"},
//  {"artist":"Lalo Schifrin","title":"Shifting Gears"}]

const swapPositions = (array, a ,b) => {
  [array[a], array[b]] = [array[b], array[a]]
}

let array = [1,2,3,4,5];
swapPositions(array,0,1);

/// => [2, 1, 3, 4, 5]

如何将图元移动到其他位置

例如，我想把{艺术家：“Lalo Schifrin”，标题：“换挡”}移到最后

我试着使用splice，如下所示：

var playlist = [
    {artist:"Herbie Hancock", title:"Thrust"},
    {artist:"Lalo Schifrin", title:"Shifting Gears"},
    {artist:"Faze-O", title:"Riding High"}
];

var tmp = playlist.splice(2,1);
playlist.splice(2,0,tmp);

function swapElement(array, indexA, indexB) {
  var tmp = array[indexA];
  array[indexA] = array[indexB];
  array[indexB] = tmp;
}

swapElement(playlist, 1, 2);
// [{"artist":"Herbie Hancock","title":"Thrust"},
//  {"artist":"Faze-O","title":"Riding High"},
//  {"artist":"Lalo Schifrin","title":"Shifting Gears"}]

const swapPositions = (array, a ,b) => {
  [array[a], array[b]] = [array[b], array[a]]
}

let array = [1,2,3,4,5];
swapPositions(array,0,1);

/// => [2, 1, 3, 4, 5]

---

但它不起作用。

删除元素时，将2更改为1，作为接头调用中的第一个参数：

var tmp = playlist.splice(1, 1);
playlist.splice(2, 0, tmp[0]);

---

如果您不知道记录当前在哪里，则始终可以使用排序方法：

playlist.sort(function (a, b) {
    return a.artist == "Lalo Schifrin" 
               ? 1    // Move it down the list
               : 0;   // Keep it the same
});

---

如果您知道索引，则可以使用以下简单函数轻松交换元素：

var playlist = [
    {artist:"Herbie Hancock", title:"Thrust"},
    {artist:"Lalo Schifrin", title:"Shifting Gears"},
    {artist:"Faze-O", title:"Riding High"}
];

var tmp = playlist.splice(2,1);
playlist.splice(2,0,tmp);

function swapElement(array, indexA, indexB) {
  var tmp = array[indexA];
  array[indexA] = array[indexB];
  array[indexB] = tmp;
}

swapElement(playlist, 1, 2);
// [{"artist":"Herbie Hancock","title":"Thrust"},
//  {"artist":"Faze-O","title":"Riding High"},
//  {"artist":"Lalo Schifrin","title":"Shifting Gears"}]

const swapPositions = (array, a ,b) => {
  [array[a], array[b]] = [array[b], array[a]]
}

let array = [1,2,3,4,5];
swapPositions(array,0,1);

/// => [2, 1, 3, 4, 5]

数组索引只是数组对象的属性，因此您可以交换其值。

的语法是：

其中：

• 索引是要开始从中删除元素的数组中的位置
• howmany是要从索引中删除的元素数
• element1、…、elementX是要从位置索引插入的元素

这意味着

splice（）

可用于删除数组中的元素、添加元素或替换元素，具体取决于传递的参数

请注意，它返回一个已删除元素的数组

一些好的和通用的东西应该是：

Array.prototype.move = function (from, to) {
  this.splice(to, 0, this.splice(from, 1)[0]);
};

然后使用：

var ar = [1,2,3,4,5];
ar.move(0,3);
alert(ar) // 2,3,4,1,5

图表：

试试这个：

playlist = playlist.concat(playlist.splice(1, 1));

---

如果您只想将一个项目从任意位置移动到数组的末尾，则此操作应该可以：

function toEnd(list, position) {
    list.push(list.splice(position, 1));
    return list;
}

如果要将多个项目从任意位置移动到终点，可以执行以下操作：

function toEnd(list, from, count) {
    list.push.apply(list, list.splice(from, count));
    return list;
}

如果要将多个项目从任意位置移动到任意位置，请尝试：

function move(list, from, count, to) {
    var args = [from > to ? to : to - count, 0];
    args.push.apply(args, list.splice(from, count));
    list.splice.apply(list, args);

    return list;
}

---

以下是一个不可变的版本供感兴趣的人使用：

function immutableMove(arr, from, to) {
  return arr.reduce((prev, current, idx, self) => {
    if (from === to) {
      prev.push(current);
    }
    if (idx === from) {
      return prev;
    }
    if (from < to) {
      prev.push(current);
    }
    if (idx === to) {
      prev.push(self[from]);
    }
    if (from > to) {
      prev.push(current);
    }
    return prev;
  }, []);
}

函数不可变移动（arr、from、to）{
返回arr.reduce（（上一个、当前、idx、自身）=>{
如果（从===到）{
上推（当前）；
}
如果（idx==from）{
返回上一个；
}
如果（从<到）{
上推（当前）；
}
如果（idx==to）{
上推（自[自]）；
}
如果（从>到）{
上推（当前）；
}
返回上一个；
}, []);
}

以这种方式重新安排工作

 var tmpOrder = playlist[oldIndex];
    playlist.splice(oldIndex, 1);
    playlist.splice(newIndex, 0, tmpOrder);

---

我希望这能奏效编辑：请检查一下，因为他的答案排在第一位，这只是他的延伸

我知道这是一个老问题，但我认为包含

Array.prototype.sort（）

是值得的

这里有一个来自MDN的示例

幸运的是，它不仅适用于数字：

arr.sort（[compareFunction]）

compareFunction

指定定义排序顺序的函数。如果省略，则根据每个字符的Unicode代码点值以及每个元素的字符串转换对数组进行排序

我注意到您是按名字订购的：

let playlist = [
    {artist:"Herbie Hancock", title:"Thrust"},
    {artist:"Lalo Schifrin", title:"Shifting Gears"},
    {artist:"Faze-O", title:"Riding High"}
];

// sort by name
playlist.sort((a, b) => {
  if(a.artist < b.artist) { return -1; }
  if(a.artist > b.artist) { return  1; }

  // else names must be equal
  return 0;
});

let playlist=[
{艺术家：“赫比·汉考克”，标题：“推力”}，
{艺术家：“Lalo Schifrin”，标题：“换档”}，
{艺术家：“Faze-O”，标题：“骑得很高”}
];
//按名称排序
播放列表.排序（（a，b）=>{
如果（a.artistb.artist）{返回1；}
//否则名称必须相等
返回0；
});

请注意，如果您想按姓氏排序，则必须为

名字

&

姓氏

都有一个键，或者执行一些正则表达式魔术，我无法执行XD

---

希望有帮助：）

作为一个简单的可变解决方案，您可以连续调用splice两次：

playlist.splice(playlist.length - 1, 1, ...playlist.splice(INDEX_TO_MOVE, 1))

另一方面，一个简单的不可变解决方案可以使用slice，因为此方法从原始数组返回一个节的副本，而不改变它：

const copy = [...playlist.slice(0, INDEX_TO_MOVE - 1), ...playlist.slice(INDEX_TO_MOVE), ...playlist.slice(INDEX_TO_MOVE - 1, INDEX_TO_MOVE)]

---

使用ES6可以执行以下操作：

var playlist = [
    {artist:"Herbie Hancock", title:"Thrust"},
    {artist:"Lalo Schifrin", title:"Shifting Gears"},
    {artist:"Faze-O", title:"Riding High"}
];

var tmp = playlist.splice(2,1);
playlist.splice(2,0,tmp);

function swapElement(array, indexA, indexB) {
  var tmp = array[indexA];
  array[indexA] = array[indexB];
  array[indexB] = tmp;
}

swapElement(playlist, 1, 2);
// [{"artist":"Herbie Hancock","title":"Thrust"},
//  {"artist":"Faze-O","title":"Riding High"},
//  {"artist":"Lalo Schifrin","title":"Shifting Gears"}]

const swapPositions = (array, a ,b) => {
  [array[a], array[b]] = [array[b], array[a]]
}

let array = [1,2,3,4,5];
swapPositions(array,0,1);

/// => [2, 1, 3, 4, 5]

---

不可变版本，无副作用（不会改变原始数组）：

---

codepen:

什么是“不工作”的意思？它会抛出错误吗？它不会改变任何东西吗？它会以一种你不希望的方式改变你的数组吗？这在我看来是合理的。那么

return+（a.artist==“Lalo Schifrin”）

@Funko你可以这样做，如果你喜欢简洁而不是冗长的话。这是一个很好的答案，一个splice（）中的splice（）做得很好。但是，应该注意的是，将move（）方法添加到阵列原型中被称为“Monkey Patching”，通常被认为是不好的做法。它应该是playlist.splice（2,0，tmp[0]）；对吧？嗨，您能向我解释一下与上面的答案相比，这个函数的好处吗？这个解决方案不修改原始元素，而是返回一个新的数组，其中条目被移动。@Xogno它在React这样的框架中特别有用，因为React通常需要不可变的对象来检测更改谢谢您的解释，@CMS。如果我交换的意思是不想替换顺序…例如，如果我选择第三个对象到第1个位置，我想将1交换为2，将2交换为3作为1，这应该是一个编辑或注释。@JaredSmith Oops！我没有看到他的答案。我没有足够的观点或任何东西来编辑他的问题，我认为不应该在评论中添加所有这些信息。所以，在有人编辑他的问题之前，我只想补充一句，这是Andy E答案的延伸（就像我应该做的那样）。我认为现在可以了：）这在现有答案的基础上增加了什么？这交换了两个元素的位置。问题是重新订购。