js中带有大写的数字的对象如何排序？

Question

arr=[{km:'混合一组',rc:10},{km:'混合二组',rc:11},{km:'混合三组',rc:10},{km:'混合二组',rc:10},{km:'混合三组',rc:10},{km:'混合四组',rc:10},,{km:'混合四组',rc:10}]

使用arr.sort((a,b)=>(a.km.localeCompare(b.km, 'zh-Hans-CN'))排序，为何不能按照"混合一组、混合二组、混合三组..."的顺序，而是"混合二组、混合三组、混合四组、混合一组"？

Answer 1

如果您希望按照大写数字来排序数组中的对象，您可以编写一个自定义的比较函数，该函数将对象中的大写数字提取出来并将其转换为对应的阿拉伯数字，然后进行比较。以下是一个示例：

// 定义一个函数，将大写数字转换为阿拉伯数字
function convertChineseNumberToArabic(chineseNumber) {
    var chineseNumberMap = {
        '一': 1,
        '二': 2,
        '三': 3,
        // 添加更多大写数字映射
    };

    return chineseNumberMap[chineseNumber];
}

// 定义一个自定义比较函数
function customSort(a, b) {
    // 提取对象中的大写数字并转换为阿拉伯数字
    var numA = convertChineseNumberToArabic(a.km.charAt(2));
    var numB = convertChineseNumberToArabic(b.km.charAt(2));

    // 比较转换后的数字
    return numA - numB;
}

// 您的对象数组
var arr = [
    { km: '混合一组', rc: 10 },
    { km: '混合二组', rc: 11 },
    { km: '混合三组', rc: 10 },
    { km: '混合二组', rc: 10 },
    { km: '混合三组', rc: 10 },
    { km: '混合四组', rc: 10 },
    { km: '混合四组', rc: 10 }
];

// 使用自定义比较函数进行排序
arr.sort(customSort);

// 输出排序后的数组
console.log(arr);

这个示例中，我们首先定义了一个函数convertChineseNumberToArabic，用于将大写数字转换为阿拉伯数字的映射。然后，我们定义了一个自定义的比较函数customSort，该函数提取对象中的大写数字，并使用映射后的数字进行比较。最后，我们使用Array.sort()方法对数组进行排序，输出排序后的数组。

Answer 2

网上查了一下 localeCompare方法是先转成拼音,然后再进行比较,自然不符合你的要求

修改答案:

提取km中的中文数字,然后把中文数字转换成阿拉伯数字来进行比较

var map = {
        "零": 0,
 
        "一": 1,
        "壹": 1,
 
        "二": 2,
        "贰": 2,
        "两": 2,
 
        "三": 3,
        "叁": 3,
 
        "四": 4,
        "肆": 4,
 
        "五": 5,
        "伍": 5,
 
        "六": 6,
        "陆": 6,
 
        "七": 7,
        "柒": 7,
 
        "八": 8,
        "捌": 8,
 
        "九": 9,
        "玖": 9,
 
        "十": 10,
        "拾": 10,
 
        "百": 100,
        "佰": 100,
 
        "千": 1000,
        "仟": 1000,
 
        "万": 10000,
        "十万": 100000,
        "百万": 1000000,
        "千万": 10000000,
        "亿": 100000000
    };
    
    // 中文数字转阿拉伯数字
    // 解析失败返回-1，成功返回转换后的数字，不支持负数
    function numberDigit(chinese_number) {
        var len = chinese_number.length;
        if (len == 0) return -1;
        if (len == 1) return (map[chinese_number] <= 10) ? map[chinese_number] : -1;
        var summary = 0;
        if (map[chinese_number[0]] == 10) {
            chinese_number = "一" + chinese_number;
            len++;
        }
        if (len >= 3 && map[chinese_number[len - 1]] < 10) {
            var last_second_num = map[chinese_number[len - 2]];
            if (last_second_num == 100 || last_second_num == 1000 || last_second_num == 10000 || last_second_num == 100000000) {
                for (var key in map) {
                    if (map[key] == last_second_num / 10) {
                        chinese_number += key;
                        len += key.length;
                        break;
                    }
                }
            }
        }
        if (chinese_number.match(/亿/g) && chinese_number.match(/亿/g).length > 1) return -1;
        var splited = chinese_number.split("亿");
        if (splited.length == 2) {
            var rest = splited[1] == "" ? 0 : numberDigit(splited[1]);
            return summary + numberDigit(splited[0]) * 100000000 + rest;
        }
        splited = chinese_number.split("万");
        if (splited.length == 2) {
            var rest = splited[1] == "" ? 0 : numberDigit(splited[1]);
            return summary + numberDigit(splited[0]) * 10000 + rest;
        }
        var i = 0;
        while (i < len) {
            var first_char_num = map[chinese_number[i]];
            var second_char_num = map[chinese_number[i + 1]];
            if (second_char_num > 9)
                summary += first_char_num * second_char_num;
            i++;
            if (i == len)
                summary += first_char_num <= 9 ? first_char_num : 0;
        }
        return summary;
    }

    let arr = [{
        km: '混合一组',
        rc: 10
    }, {
        km: '混合二组',
        rc: 11
    }, {
        km: '混合三组',
        rc: 10
    }, {
        km: '混合二组',
        rc: 10
    }, {
        km: '混合三组',
        rc: 10
    }, {
        km: '混合四组',
        rc: 10
    }, {
        km: '混合四组',
        rc: 10
    }]

    let regexp = /[一二三四五六七八九十百千万亿]+/

    arr.forEach(item => {
        let sortBy = regexp.exec(item.km)
        if (sortBy.length) {
            item.sortBy = numberDigit(sortBy[0])
        } else {
            item.sortBy = 0
        }
    })
    
    arr.sort((a, b) => {
        if (a.sortBy > b.sortBy) {
            return 1
        } else if (a.sortBy < b.sortBy) {
            return -1
        } else {
            return 0
        }
    })
    console.log({arr})

Answer 3

1. 先替换汉字数字为 {{阿拉伯数字}}
2. 排序
3. 再把 {{阿拉伯数字}} 替换成汉字

似乎是最简单的做法。

Answer 4

二(er)排在一(yi)前面, 字母顺序比较

'er' < 'yi' === true