js交换数组中2个元素的位置，实现排序功能

原始数据：数组中有三个关于电影的对象数据

const movies = [
    { title: 'a', year: 2018, rating: 4. 3 },
    { title: 'b', year: 2018, rating: 4.7 },
    { title: 'c', year: 2018, rating: 4.9 }
];

需求：需要根据评分（rating）的高低，按倒序排列，即评分越高，越靠前

错误示范一：

// 冒泡排序法：
  for (var i = 0; i < movies.length - 1; i++) {
    for (var k = i + 1; k < movies.length; k++) {
      if (movies[i].rating < movies[k].rating) {
          movies.splice(i, 1, movies[k]);
          movies.splice(k, 1, movies[i]);
      }
    }
  }

个人想法：把当前值赋给下一个值，再把下一个值赋给当前值，理论上来说没问题的。但是...............

结果：

image

错误示范二：

// 冒泡排序法：
  for (var i = 0; i < movies.length - 1; i++) {
    for (var k = i + 1; k < movies.length; k++) {
      if (movies[i].rating < movies[k].rating) {
          movies.splice(i, 1, ...movies.splice(k, 1, movies[i]));
      }
    }
  }

结果：评分都覆盖了，变为一组数据了

image

正确示范一：

// 冒泡排序法
for (var i = 0; i < movies.length - 1; i++) {
    for (var k = i + 1; k < movies.length; k++) {
      if (movies[i].rating < movies[k].rating) {
        var temp = arr[i];
        arr[i] = arr[k];
        arr[k] = temp;
      }
    }
  }

结果：

image

正确示范二（es6解构赋值写法）：

// 冒泡排序法：
  for (var i = 0; i < movies.length - 1; i++) {
    for (var k = i + 1; k < movies.length; k++) {
      if (movies[i].rating < movies[k].rating) {
        [movies[i], movies[k]] = [movies[k], movies[i]];
      }
    }
  }

结果：

image

正确示范三：sort排序（注意这样是返回的新数组，而不是修改原数组）

const title3 = movies.sort((a, b) => {
    return a.rating > b.rating ? -1 : (a.rating = b.rating) ? 0 : 1;
})

返回值是负数，意味着不交换位置，返回值是正数交换位置，0的话，值是相等的，也就不存在交换一说了

结果：

image

正确示范四：sort排序（注意这样是返回的新数组，而不是修改原数组）

const title = movies
    .sort((a, b) => a.rating - b.rating)
    .reverse()

// 或者

const title = movies
    .sort((a, b) => b.rating - a.rating)

直接返回a-b的结果，a大于b，即返回正数交换，a小于b，即返回负数不交换，这样得到的数据是反的，即分数越高，排名越靠后，通过翻转得到正确的数据

或者返回b-a的结果就是正确的

结果：

image

如上就是根据需求交换数组数据实现排序的方法。

如有问题，请指出，接受批评。