在 JavaScript 中，将 .NET 中的字符串与序号忽略大小写进行比较的等效物是什么？

function ordinalCompareInsensitive(a/*: string*/, b/*: string*/)/*: number */ {
    const lowera = a.toLowerCase();
    const lowerb = b.toLowerCase();
    if (lowera === lowerb) {
        return 0;
    }
    if (lowera < lowerb) {
        return -1;
    }
    return 1;
}

function ordinalCompareInsensitive2(a/*: string*/, b/*: string*/)/*: number */ {
    const itA = a[Symbol.iterator]();
    const itB = b[Symbol.iterator]();
    let rA/*: IteratorResult<string, any>*/;
    let rB/*: IteratorResult<string, any>*/;
    while (true) {
        rA = itA.next();
        rB = itB.next();
        if (rA.done) {
            return rB.done ? 0 : -1;
        } else if (rB.done) {
            return 1;
        }
        const chA = rA.value.toLowerCase();
        const chB = rB.value.toLowerCase();
        if (chA < chB) {
            return -1;
        }
        if (chA > chB) {
            return 1;
        }
    }
}

function ordinalCompareInsensitive3(a/*: string*/, b/*: string*/)/*: number */ {
    let indexA = 0;
    let indexB = 0;

    while (true) {
        if (indexA >= a.length) {
            return indexB >= b.length ? 0 : -1;
        } else if (indexB >= b.length) {
            return 1;
        }
        const chA = String.fromCodePoint(a.codePointAt(indexA)/*!*/).toLowerCase();
        const chB = String.fromCodePoint(b.codePointAt(indexB)/*!*/).toLowerCase();
        if (chA < chB) {
            return -1;
        }
        if (chA > chB) {
            return 1;
        }
        indexA += chA.length;
        indexB += chB.length;
    }
}

function usLocaleCompareInsensitive(a/*: string*/, b/*: string*/)/*: number */ {
    return a.localeCompare(b, undefined, { sensitivity: "accent" });
}

function clampReturn(x/*: number */)/*: number */ {
    if (x === 0) {
        return x;
    }
    if (x < 0) {
        return -1;
    }
    return 1;
}

function test(a/*: string*/, b/*: string*/, expect/*: number*/) {
    const o1 = clampReturn(ordinalCompareInsensitive(a, b));
    const o2 = clampReturn(ordinalCompareInsensitive2(a, b));
    const o3 = clampReturn(ordinalCompareInsensitive3(a, b));
    const rUS = clampReturn(usLocaleCompareInsensitive(a, b));
    const result = o1 === o2 && o2 === o3 && o3 === rUS && rUS === expect ? "OK" : "<== ERROR !";
    console.log(`${a} vs. ${b}: ${o1} ${o2} ${o3} ${rUS} expect ${expect} ${result}`);
}

test("abc", "abc", 0);
test("abc", "ABC", 0);
test("abc", "aBC", 0);
test("abc", "abcd", -1);
test("abcd", "abc", 1);
test("abc", "acd", -1);
test("acd", "abc", 1);

.as-console-wrapper {
    max-height: 100% !important;
}

// Tell the in-snippet console not to throw away old log entries
console.config({
    maxEntries: Infinity
});

const MAX_UNICODE = 0x10ffff;

function ucode(ch/*: string*/) {
    return `\\u${ch
        .codePointAt(0)/*!*/
        .toString(16)
        .toUpperCase()
        .padStart(4, "0")}`;
}

function check(
    type/*: string*/,
    convertToMethod/*: "toLowerCase" | "toUpperCase"*/,
    convertBackMethod/*: "toLowerCase" | "toUpperCase"*/
) {
    console.log(
        `Checking '${type}' characters converted with ${convertToMethod} then back with ${convertBackMethod}:`
    );
    let found = 0;
    let mismatches = 0;
    for (let n = 1; n < MAX_UNICODE; ++n) {
        const char = String.fromCodePoint(n);
        const converted = char[convertToMethod]();
        if (char !== converted) {
            ++found;
            if (
                char.localeCompare(converted, "en-US", {
                    sensitivity: "accent",
                }) !== 0
            ) {
                ++mismatches;
                const reconverted = converted[convertBackMethod]();
                console.log(
                    `${char} vs ${converted} vs ${reconverted} (${ucode(
                        char
                    )} vs. ${ucode(converted)} vs. ${ucode(reconverted)})`
                );
            }
        }
    }
    console.log(
        `Done, ${mismatches} mis-matches found (total "${type}" chars found: ${found})`
    );
}

check("upper case", "toLowerCase", "toUpperCase");
check("lower case", "toUpperCase", "toLowerCase");

.as-console-wrapper {
    max-height: 100% !important;
}