原始数据：数组中有三个关于电影的对象数据
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
如上就是根据需求交换数组数据实现排序的方法。
如有问题，请指出，接受批评。