ts - 兩種方法實現忽略大小寫的字串排序

這裡有一個奇奇怪怪的學生陣列：

const students = [
    { Name: 'aaa', Age: 18, Sex: "man" },
    { Name: 'aaaB', Age: 21, Sex: "man" },
    { Name: 'aaaBC', Age: 23, Sex: "woman" },
    { Name: 'aaaaB', Age: 16, Sex: "man" },
    { Name: 'aaaac', Age: 27, Sex: "man" },
    { Name: 'abcd', Age: 15, Sex: "man" }
];

現在呢我們要按照這奇奇怪怪的姓名來排序。
規則：忽略大小寫，根據字元在Hash Table裡位置進行排序。

---

先寫出排序的方法。
依舊是參照阮一峰的快速排序法 。
傳入三個引數arr、selector、compare，分別代表需要排序的陣列、排序依據、以及可選的比較方法。

function orderbyName<Titem, Tvalue>(arr: Titem[], selector: (i: Titem) => Tvalue, compare?: (a: Tvalue, b: Tvalue) => number): Titem[] {
    if (arr.length <= 1) {
        return arr;
    }

    if (!compare) {
        compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
    }
    //如果沒有傳入compare方法，就按照以上的方法來排序。


    const orderbyArray = arr.slice(0);

    const pivotIndex = Math.floor(orderbyArray.length / 2);
    const pivotItem = orderbyArray.splice(pivotIndex, 1)[0];
    const pivotValue = selector(pivotItem);

    const left = [] as Titem[];
    const right = [] as Titem[];

    for (const i of orderbyArray) {
        if (compare(selector(i), pivotValue) < 0) {
            left.push(i);
        } else {
            right.push(i);
        }
    }

    return orderbyName(left, selector, compare).concat([pivotItem], orderbyName(right, selector, compare));
}

//呼叫方法：
const nameOrder = orderbyName(students, i => i.Name, ignoreCaseStringCompare);
console.log(nameOrder);

接下來，有兩種不同的比較字串的方法。
方法一是我自己想的（說明自己還是有點進步的嘻嘻）。
方法二是師父補充的，可以提高函式執行的效率。

方法一

//ignoreCaseCharCompare方法用來比較兩個字母在Hash Table裡的位置大小
function ignoreCaseCharCompare(a: string, b: string): number {
//傳入兩個string型別的引數，得出number型別的結果。
    return a.toUpperCase().charCodeAt(0) - b.toUpperCase().charCodeAt(0);
    //忽略大小寫，所以全部轉換為toUpperCase()
}

//ignoreCaseStringCompare方法用來比較兩個字串
function ignoreCaseStringCompare(a: string, b: string): number {
    const aLen = a.length;
    const bLen = b.length;
    const Len = aLen - bLen < 0 ? aLen : bLen;
    // const Len = Math.min(aLen,bLen);   內建Math方法也可以

    for (let i = 0; i < Len; i++) {
        const result = ignoreCaseCharCompare(a.charAt(i), b.charAt(i));
        if (result !== 0) {
            return result;
        }
        // 一直遍歷，直到某位不相等，或者一個字串已經遍歷完為止，輸出比較結果，跳出函式。
    }
    if (aLen < bLen) {
        return -1;
        // 如果不滿足上一個判斷條件的話，再對比兩個字串長度。
    } else {
        return 1;
    }
}

方法一的缺點在於 需要一次又一次地遍歷字串的每一個字母，效率比較低。

方法二

function ignoreCaseCharCompare(a: string, b: string): number {
    return a.toUpperCase().charCodeAt(0) - b.toUpperCase().charCodeAt(0);
} // 同樣是比較字元的方法。

function ignoreCaseStringCompare(a: string, b: string): number {
    function ignoreCaseStringCompareRec(a: string, b: string, index: number): number {
    // 這個函式的關鍵，是傳入一個index，這個index通常從0開始，代表著字串（從左到右）的第一位
        if (index + 1 > a.length) {
            if (a.length === b.length) {
                return 0;
            }
            return -1;
        }
        // 以上這個判斷的意思就是，執行到這裡如果字串長度已經小於index了，說明兩個字串的前幾位都是相同的，位數短的那一個排在前面，相等的代表相同。
        if (index + 1 > b.length) {
            return 1;
        }
        const result = ignoreCaseCharCompare(a.charAt(index), b.charAt(index));
        if (result !== 0) {
            return result;
        }
        return ignoreCaseStringCompareRec(a, b, index + 1);執行到這裡沒有判斷出結果的，index+1回到函式頂部重新執行，也就是比較下一個字元
    }
    return ignoreCaseStringCompareRec(a, b, 0);
}

第二種方法就是一個一個字元去比較，而不是全部遍歷他的length，比較到某一位字元如果有結果的話就直接return，無需再進行下面的比較了。

其實第二種方法中用到的length可以用別的辦法來代替，但是應該比較複雜，所以師父就沒有告訴我。有時間的話再演技一下具體如何實現吧！