数组排序 sort() 方法 （映射对含有大小写的字符串进行排序）

sort() 方法：用于对数组元素进行排序，默认升序。如果指明了参数，那数组会按照比较函数的返回值进行排序。

sort() 方法比较两个值时，将值发送给比较函数，根据返回的（负、零、正）值对值进行排序。举例，a 和 b 两个将要被比较的元素：

如果 a-b 小于 0 ，那么 a 会被排列到 b 之前。

如果 a-b 等于 0 ， a 和 b 的相对位置不变。

如果 a-b 大于 0 ， b 会被排列到 a 之前。

简单的理解，就是：** a-b升序 b-a 降序 **

具体解析：

1、概念

sort() 是 JavaScript 中数组对象的一个方法，用于对数组元素进行排序。

它会原地修改数组，将数组元素重新排列，并返回排序后的数组。

默认情况下，

sort()

方法将数组元素视为字符串并按照 Unicode 码点进行排序。

排序顺序可以是按字母或数字，也可以是升序（向上）或降序（向下）。默认情况下，

sort()

方法将按字母和升序将值作为字符串进行排序。

2、语法

array.sort(compareFunction)

参数说明：

• compareFunction（可选）：用于指定排序顺序的比较函数。

如果不提供

compareFunction

参数，

sort()

方法将按照字符串 Unicode 码点的顺序对数组元素进行排序。

3、参数详解

该函数应返回负值、零值或正值，具体取决于参数，例如：

function(a, b){ return a-b }

sort() 方法比较两个值时，将值发送给比较函数，根据返回的（负、零、正）值对值进行排序。

举例，a和b 两个将要被比较的元素：

如果 a-b 小于 0 ，那么 a 会被排列到 b 之前。

如果 a-b 等于 0 ， a 和 b 的相对位置不变。

如果 a-b 大于 0 ， b 会被排列到 a 之前。

简单的理解，就是：** a-b升序 b-a 降序 **

const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
arr.sort((a, b) => a - b);
console.log(arr); // [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

在这个示例中，我们提供了一个比较函数

(a, b) => a - b

，它表示按照数字大小进行升序排序。因此，最终数组被排序成了

[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

。

需要注意的是，

sort()

方法会直接修改原始数组，并返回排序后的数组。如果需要保留原始数组，可以在排序前先创建一个副本进行操作。

4、应用

① 非数字排序：字母顺序

字符串排序，可以直接使用 sort() 方法

var fruits = ["Banana", "Orange", "Apple", "Mango", "Blueberries"];
fruits.sort(); // ["Apple", "Banana", "Blueberries", "Mango", "Orange"]

var arr = ['h','a','k','c','e'];
arr.sort();
console.log(arr)  // ["a", "c", "e", "h", "k"]

按字母顺序对数组进行排序，然后反转排序项的顺序（降序）：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits.reverse();
console.log(fruits) //  ["Orange", "Mango", "Banana", "Apple"]

② 数字

默认会将其作为字符串进行排序

var arr = [12, 22, 66, 3]
arr.sort()
console.log(arr) // [12, 22, 3, 66]

③ 按 升序 对数组中的数字进行排序：a-b

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

console.log(points) // [1, 4, 5, 10, 10, 25]

④ 按 降序 对数组中的数字进行排序：b-a

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

console.log(points) // [25, 10, 10, 5, 4, 1]

⑤ 获取数组中的最小值：

var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){ return a-b });    // 按升序对数组中的数字进行排序

// 数组中的第一项 (points[0]) 现在是最小值

⑥ 获取数组中的最大值：

var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){ return b-a });    // 按降序对数组中的数字进行排序

// 数组中的第一项 (points[0]) 现在是最大值

⑦ 根据对象的某个属性进行排序：

var arr = [
  { name: 'A', age: 21 },
  { name: 'B', age: 37 },
  { name: 'C', age: 18 },
  { name: 'D', age: -12 },
  { name: 'E', age: 15 },
  { name: 'F', age: 19 }
 ];

// 依据age排序
arr.sort(function(a, b) {
    return a.age - b.age
});
console.log(arr); // 0: {name: "D", age: -12}
                  // 1: {name: "E", age: 15}
                  // 2: {name: "C", age: 18}
                  // 3: {name: "F", age: 19}
                  // 4: {name: "A", age: 21}
                  // 5: {name: "B", age: 37}

// 依据name排序
arr.sort(function(a, b) {
    const nameA = a.name;
    const nameB = b.name;
    if(nameA < nameB) {
      return -1;
    }
    if(nameA > nameB) {
      return 1;
    }
    return 0;
});
console.log(arr); // 0: { name: 'A', age: 21 }
                  // 1: { name: 'B', age: 37 }
                  // 2: { name: 'C', age: 18 }
                  // 3: { name: 'D', age: -12 }
                  // 4: { name: 'E', age: 15 }
                  // 5: { name: 'F', age: 19 }

⑧ 非ASCII字符排序(如类似 e, é, è, a, ä 等字符的字符串)

一些非英语的字符串，需要使用 String.localeCompare

var a = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
a.sort(function (a, b) {
    return a.localeCompare(b);
});

console.log(a); // ["adieu", "café", "cliché", "communiqué", "premier", "réservé"]

⑨ 使用映射对含有大小写的字符串进行排序

方法一：

// 需要被排序的数组
var list = ['Delta', 'alpha', 'CHARLIE', 'bravo'];
 
// 对需要排序的数字和位置的临时存储
var mapped = list.map((item, index) => { 
    return { index, value: item.toLowerCase() }
})

console.log(mapped) // 0: {index: 0, value: "delta"}
                     // 1: {index: 1, value: "alpha"}
                     // 2: {index: 2, value: "charlie"}
                     // 3: 3: {index: 3, value: "bravo"}

// 按照多个值排序数组
mapped.sort((a, b) => {
    return +(a.value > b.value) || +(a.value === b.value) - 1;
});

console.log(mapped) // 0: {index: 1, value: "alpha"}
                    // 1: {index: 3, value: "bravo"}
                    // 2: {index: 2, value: "charlie"}
                    // 3: {index: 0, value: "delta"}

// 根据索引得到排序的结果
var result = mapped.map((el) => {
    return list[el.index];
});

console.log(result); // ["alpha", "bravo", "CHARLIE", "Delta"]

方法二：

// 需要被排序的数组
var list = ["Delta", "alpha", "CHARLIE", "bravo"];
let newObj = {};
list.forEach((item, index) => {
    newObj[(item.toLocaleLowerCase())] = item
});
console.log(newObj) 
// { alpha: "alpha", bravo: "bravo", charlie: "CHARLIE", delta: "Delta" }

let arr = Object.keys(newObj);
arr.sort((a, b) => {
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    } else {
        return 0;
    }
});
console.log(arr); // ["alpha", "bravo", "charlie", "delta"]

let res = arr.map(item => item = newObj[item])
console.log(res) //  ["alpha", "bravo", "CHARLIE", "Delta"]