假设现在有一个这样的数组：

1
let arr = [3, 5, 1, 2, 6, 0, 4];

我们需要对他进行排序，从小到大。

方法一：使用sort方法

1
2
3
4
5
arr.sort(function(a, b) {
  return a - b;
});
console.log(arr);
// [0, 1, 2, 3, 4, 5, 6]

如果sort方法，不传入方法的话，某种情况下他是会有问题的。举个例子：

1
2
3
let _arr = [0, 1, 5, 10, 15, 51];
_arr.sort();
// [0, 1, 10, 15, 5, 51]

为了实现升序，sort()方法会调用每个数组项的toString()转型方法，然后比较得到的字符串，以确定如何排序。即使数组中的每一项都是数值，sort()方法比较的也是字符串。为了更好的实现排序，sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于那个值的前面。

方法二：使用冒泡排序方法

1
2
3
4
5
6
7
8
9
10
for(let i = 0 ; i < arr.length - 1 ; i++) {
  for(let j = 0 ; j < arr.length - 1 - i ; j++) {
    let now = arr[j],
      next = arr[j + 1];
    
    arr[j] = now > next ? next : now;
    arr[j + 1] = now < next ? next : now;
  }
}
console.log(arr);

关于冒泡排序我自己的个人理解：
循环数组，拿当前项now跟下一项next进行比较。如果当前项大于下一项，则进行位置互换，反之则不进行互换。循环完成后，即可以确定出数组中最大一项，并已经放到数组的末端了。当然循环当中，最后一项是无法与下一项进行比较的，毕竟是最后一项了，所有循环次数是数组的长度减一。

1
2
3
4
5
6
7
8
9
for(let i = 0 ; i < arr.length - 1 ; i++) {
  let now = arr[i],
    next = arr[i + 1];
  
  arr[i] = now > next ? next : now;
  arr[i + 1] = now < next ? next : now;
}
console.log(arr);
// [3, 1, 2, 5, 0, 4, 6]

这里只是确定出了一个最大值，那么剩下的还要进行排序，循环次数 = 数组的长度 - 1 - 已确定出的最大值的数量。

1
2
3
4
5
6
7
8
9
10
for(let i = 0 ; i < arr.length - 1 ; i++) {
  for(let j = 0 ; j < arr.length - 1 - i ; j++) {
    let now = arr[j],
      next = arr[j + 1];
    
    arr[j] = now > next ? next : now;
    arr[j + 1] = now < next ?  next : now;
  }
}
console.log(arr);

简单的封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// arr： 需要排序的数组
// type：升序还是降序 true 升序 false降序 默认升序
// key： 当子项为对象时，进行排序的依据字段
function sort(arr, type, key) {
  for(let i = 0 ; i < arr.length - 1 ; i++) {
    for(let j = 0 ; j < arr.length - 1 - i ; j++) {
      let now = arr[j],
        next = arr[j + 1],
        now_val = key ? now[key] : now,
        next_val = key ? next[key] : next;
      
      arr[j] = now_val > next_val ? next : now;
      arr[j + 1] = now_val < next_val ?  next : now;
    }
  }

  if(!type) arr.reverse();
  return arr;
}