Ich teste im Internet Explorer 8 unter Windows XP und stoße auf einen mühsamen Bug. Ich versuche, Zeichenfolgen mit einem regulären Ausdruck zu testen, der in Firefox einwandfrei funktioniert und in der ie8-Konsole unabhängig getestet wird.

Aber wenn es durch meine Verschlussfunktion die Zeichenfolge seltsam wirkt

[Bearbeiten] Detaillierterer Code: Nicht so schön oder sauber wie das frühere Snippet.

var m_TableSorter = (function() {

    // static reg expression string and array for ordering dates
    var dateRegEx = new RegExp(
     "(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\\s\\d{4}");
     ...
     ...
    function greaterThan(left, right) {
        window["globalLeft"] = left;
        window["globalRight"] = right;
        var a = $.trim(left.toLowerCase());
        var b = $.trim(right.toLowerCase());
        window["globalA"] = a.toString();
        window["globalReg"] = dateRegEx;
        if (dateRegEx.test(a) && dateRegEx.test(b)) {
            var yearA = parseInt(a.substring(4,8), 10);
            var yearB = parseInt(b.substring(4,8), 10);
            if (yearA > yearB) {
                return true;
            } else if (yearB > yearA) {
                return false;
            } else {
                /* ... */
                var monthA =
                    $.inArray(a.substring(0,3).toUpperCase(), monthArray);
                var monthB = 
                    $.inArray(b.substring(0,3).toUpperCase(), monthArray);
                m_Debug.tryAssert(monthA >= 0, "Date string malformed");
                m_Debug.tryAssert(monthB >= 0, "Date string malformed");
                if (monthA > monthB) {
                    return true;
                } else {
                    return false;
                }
            }
        }
        //alert("NONDATE");
        if ( a.toUpperCase() >= b.toUpperCase() ) {
            return true;
        }
        return false;
    }

    function mergeArrays(pr_left, pr_right, pr_compareFunction, pr_rowIndex) 
    {
        m_Debug.debugUtilityFunction(arguments);
        var results = new Array();
        var obj;
        /* Merges in order so that if right > left then the results is
         * [left right] otherwise the result is [right left] (Dependant on
         * ascending or descending order)
         */
        while (pr_left.length > 0 || pr_right.length > 0) {
            if (pr_left.length > 0 && pr_right.length > 0) {
                window["globalLeft1"] = $(pr_left[0].children[pr_rowIndex]).text().toString();
                window["globalRight1"] = $(pr_right[0].children[pr_rowIndex]).text().toString();
                var bool = pr_compareFunction(
                    $.trim($(pr_left[0].children[pr_rowIndex]).text()),
                    $.trim($(pr_right[0].children[pr_rowIndex]).text())
                );
                if (bool) {
                    results.push(pr_left.shift());
                } else {
                    results.push(pr_right.shift());
                }
            } else  if (pr_left.length > 0) {
                for (obj in pr_left) {
                    results.push(pr_left[obj]);
                }
                break;
            } else if (pr_right.length > 0) {
                for (obj in pr_right) {
                    results.push(pr_right[obj]);
                }
                break;
            }
        }
        return results;

    }

Für diemergeArrays functionpr_left & pr_right ist eine jQuery-Liste von TR-Objekten. und ich vergleiche den Text impr_rowIndex-th Zelle der Zeile für zwei Zeilen.

pr_compareFunction ist größer als

dateRegEx.test (a) gibt false zurück, da die Zeichenfolge a fehlerhaft ist.

Testing in der IE8-Konsole sagt mir, dass

globalA.toLowerCase() == "sep 2010"

returns false In diesem Fallalert(globalA) hat "sep 2010" und @ gezeialert(globalLeft) hat "Sep 2010" gezeigt. Ich habe .length auf beiden überprüft, um 8 zu sein, wie erwartet.

globalLeft1 == globalLeft scheint wahr zu sein, aber keines ist gleich normalen Strings.

Ich kann überhaupt nicht erkennen, warum JScript diese beiden Zeichenfolgen nicht erkennt. Das Reproduzieren dieser genauen Schritte in der Konsole funktioniert wie erwartet.

[Weitere Bearbeitung]

Es stellt sich heraus, dass eine andere Implementierung von Javascript nicht unterbrechende Leerzeichen entweder als Leerzeichenklasse oder als Nicht-Leerzeichenklasse behandelt. Ob dies ein Fehler ist oder wie beabsichtigt funktioniert, kann diskutiert werden.