二维码
搜索 ×

JavaScript 对数组进行排序

  • 作者：图形开发学院
  • 更新时间：2023年11月01日
  • 阅读量：0
  • 收藏数：0

JavaScript 对数组进行排序

对数组进行排序

sort()方法按字母顺序对数组进行排序：

1
2
3
4

const fruits = ["Banana", "Orange", "Apple", "Mango"];  
fruits.sort();

反转数组

reverse()方法反转数组中的元素。

您可以使用它来 按降序对数组进行排序：

1
2
3
4
5

const fruits = ["Banana", "Orange", "Apple", "Mango"];  
fruits.sort();  
fruits.reverse();

数值排序

默认情况下，sort()函数将值排序为字符串。

这适用于字符串（“Apple”在“Banana”之前）。

但是，如果数字按字符串排序，则“25”大于“100”， 因为“2”比“1”大。

因此，sort()方法在对数字进行排序时会产生不正确的结果。

您可以通过提供比较函数来解决此问题：

1
2
3
4

const points = [40, 100, 1, 5, 25, 10];  
points.sort(function(a, b){return a - b});

使用相同的技巧对数组进行降序排序：

1
2
3
4

const points = [40, 100, 1, 5, 25, 10];  
points.sort(function(a, b){return b - a});

比较函数

比较函数的目的是定义替代排序 次序。

比较函数应返回负值、零值或正值，具体取决于 参数：

1
function(a, b){return a - b}
当 `sort()` 函数比较两个值时，它将值发送到比较函数，并根据返回的（负、零、正）值对值进行排序。

如果结果为负，则 a 排在 b 之前。

如果结果为正，则 b 排在 a 之前。

如果结果为 0，则两个值的排序顺序不会发生任何更改。

例：

比较函数比较数组中的所有值，一次比较两个值 (a, b)。

当比较 40 和 100 时，sort() 方法调用比较函数(40, 100)。

该函数计算 40 - 100 (a - b)，由于结果为负 (-60)，因此排序函数会将 40 作为低于 100 的值进行排序。

您可以使用此代码片段来尝试按数字和字母顺序排序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<button onclick="myFunction1()">Sort Alphabetically</button>  
<button onclick="myFunction2()">Sort Numerically</button>  

<p id="demo"></p>  

<script>  
const points = [40, 100, 1, 5, 25, 10];  
document.getElementById("demo").innerHTML = points;  

function myFunction1() {  
  points.sort();  
  document.getElementById("demo").innerHTML = points;  
}  

function myFunction2() {  
  points.sort(function(a, b){return a - b});  
  document.getElementById("demo").innerHTML = points;  
}  
</script>

按随机顺序对数组进行排序

1
2
3
4

const points = [40, 100, 1, 5, 25, 10];  
points.sort(function(){return 0.5 - Math.random()});

费舍尔·耶茨方法

上面的例子 array.sort()并不准确。它会有利于一些人 数字高于其他数字。

最流行的正确方法，称为费舍尔耶茨洗牌，并且是 早在 1938 年就被引入数据科学！

在 JavaScript 中，该方法可以翻译为：

1
2
3
4
5
6
7
8
9
10

const points = [40, 100, 1, 5, 25, 10];  

for (let i = points.length -1; i > 0; i--) {  
  let j = Math.floor(Math.random() * (i+1));  
  let k = points[i];  
  points[i] = points[j];  
  points[j] = k;  
}

查找最低（或最高）数组值

没有用于查找最大值或最小值的内置函数 数组中的值。

但是，在对数组进行排序后，可以使用 索引以获取最高值和最低值。

升序排序：

1
2
3
4
5
6

const points = [40, 100, 1, 5, 25, 10];  
points.sort(function(a, b){return a - b});  
// now points[0] contains the lowest value  
// and points[points.length-1] contains the highest value

降序排序：

1
2
3
4
5
6

const points = [40, 100, 1, 5, 25, 10];  
points.sort(function(a, b){return b - a});  
// now points[0] contains the highest value  
// and points[points.length-1] contains the lowest value

如果您只想找到最高（或最低）值，则对整个数组进行排序是一种非常低效的方法。

在数组上使用 Math.max（）

您可以使用Math.max.apply来查找数组中的最大数字：

1
2
3
4
5

function myArrayMax(arr) {  
  return Math.max.apply(null, arr);  
}

Math.max.apply(null, [1, 2, 3]) 等价于 Math.max(1, 2, 3)。

在数组上使用 Math.min（）

您可以使用Math.min.apply方法查找数组中的最小数字：

1
2
3
4
5

function myArrayMin(arr) {  
  return Math.min.apply(null, arr);  
}

Math.min.apply(null, [1, 2, 3])等同于 。Math.min(1, 2, 3)

My Min / Max JavaScript 方法

最快的解决方案是使用“自制”方法。

此函数遍历一个数组，将每个值与最高值进行比较 找到的值：

:查找最大值 
1
2
3
4
5
6
7
8
9
10
11
function myArrayMax(arr) {  
  let len = arr.length;  
  let max = -Infinity;  
  while (len--) {  
    if (arr[len] > max) {  
      max = arr[len];  
    }  
  }  
  return max;  
}

此函数循环遍历一个数组，将每个值与找到的最小值进行比较：

:查找最小值 
1
2
3
4
5
6
7
8
9
10
11
12

function myArrayMin(arr) {  
  let len = arr.length;  
  let min = Infinity;  
  while (len--) {  
    if (arr[len] < min) {  
      min = arr[len];  
    }  
  }  
  return min;  
}

对对象数组进行排序

JavaScript 数组通常包含对象：

1
2
3
4
5
6

const cars = [  
  {type:"Volvo", year:2016},  
  {type:"Saab", year:2001},  
  {type:"BMW", year:2010}  
];
即使对象具有不同数据类型的属性，`sort()`方法可用于对数组进行排序。

解决方案是编写一个 compare 函数来比较属性值：

1
2
cars.sort(function(a, b){return a.year - b.year});

比较字符串属性稍微复杂一些：

1
2
3
4
5
6
7
8
9

cars.sort(function(a, b){  
  let x = a.type.toLowerCase();  
  let y = b.type.toLowerCase();  
  if (x < y) {return -1;}  
  if (x > y) {return 1;}  
  return 0;  
});

稳定数组 sort（）

[ES2019]修改了 Array sort()方法。

在 2019 年之前，该规范允许不稳定的排序算法，例如 QuickSort。

在 ES2019 之后，浏览器必须使用稳定的排序算法：

对值上的元素进行排序时，这些元素必须保持其与具有相同值的其他元素的相对位置。

1
2
3
4
5
6
7
8
9
10
11
12

const myArr = [  
  {name:"X00",price:100 },  
  {name:"X01",price:100 },  
  {name:"X02",price:100 },  
  {name:"X03",price:100 },  
  {name:"X04",price:110 },  
  {name:"X05",price:110 },  
  {name:"X06",price:110 },  
  {name:"X07",price:110 }  
];

在上面的示例中，在对价格进行排序时，不允许结果显示名称 在另一个相对位置，如下所示：

1
2
3
4
5
6
7
8
X01 100  
X03 100  
X00 100  
X03 100  
X05 110  
X04 110  
X06 110  
X07 110

推荐教程