JavaScript: split doesn't work in IE?

Question

Is there a reason why the following piece of code doesn't work in IE? While with FF and other sane browsers it splits the string by the given expression, in IE it simply doesn't work.

var str = "abc<font id=\"something\">def</font>gh";
alert(str.split(/(\<.*?\>|.)/).length);

Thank you.

Transect

Perhaps this page is of use: blog.stevenlevithan.com/archives/cross-browser-split – Style

I wonder, are those kind of idiotic stuff in IE are bugs or features decided by the management? I guess IE 8 sucks just as well! – Transect

JOKE ON: Bugs for programmers are new and exciting features for commercials. – Undertrick

Note that those bugs are fixed in IE9+ which has a new JS engine. – Colleencollege

Answer 1

you could add the code below to you program and it will work.

var split;
// Avoid running twice; that would break the `nativeSplit` reference
split = split || function (undef) {

var nativeSplit = String.prototype.split,
    compliantExecNpcg = /()??/.exec("")[1] === undef, // NPCG: nonparticipating capturing group
    self;

self = function (str, separator, limit) {
    // If `separator` is not a regex, use `nativeSplit`
    if (Object.prototype.toString.call(separator) !== "[object RegExp]") {
        return nativeSplit.call(str, separator, limit);
    }
    var output = [],
        flags = (separator.ignoreCase ? "i" : "") +
                (separator.multiline  ? "m" : "") +
                (separator.extended   ? "x" : "") + // Proposed for ES6
                (separator.sticky     ? "y" : ""), // Firefox 3+
        lastLastIndex = 0,
        // Make `global` and avoid `lastIndex` issues by working with a copy
        separator = new RegExp(separator.source, flags + "g"),
        separator2, match, lastIndex, lastLength;
    str += ""; // Type-convert
    if (!compliantExecNpcg) {
        // Doesn't need flags gy, but they don't hurt
        separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags);
    }
    /* Values for `limit`, per the spec:
     * If undefined: 4294967295 // Math.pow(2, 32) - 1
     * If 0, Infinity, or NaN: 0
     * If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296;
     * If negative number: 4294967296 - Math.floor(Math.abs(limit))
     * If other: Type-convert, then use the above rules
     */
    limit = limit === undef ?
        -1 >>> 0 : // Math.pow(2, 32) - 1
        limit >>> 0; // ToUint32(limit)
    while (match = separator.exec(str)) {
        // `separator.lastIndex` is not reliable cross-browser
        lastIndex = match.index + match[0].length;
        if (lastIndex > lastLastIndex) {
            output.push(str.slice(lastLastIndex, match.index));
            // Fix browsers whose `exec` methods don't consistently return `undefined` for
            // nonparticipating capturing groups
            if (!compliantExecNpcg && match.length > 1) {
                match[0].replace(separator2, function () {
                    for (var i = 1; i < arguments.length - 2; i++) {
                        if (arguments[i] === undef) {
                            match[i] = undef;
                        }
                    }
                });
            }
            if (match.length > 1 && match.index < str.length) {
                Array.prototype.push.apply(output, match.slice(1));
            }
            lastLength = match[0].length;
            lastLastIndex = lastIndex;
            if (output.length >= limit) {
                break;
            }
        }
        if (separator.lastIndex === match.index) {
            separator.lastIndex++; // Avoid an infinite loop
        }
    }
    if (lastLastIndex === str.length) {
        if (lastLength || !separator.test("")) {
            output.push("");
        }
    } else {
        output.push(str.slice(lastLastIndex));
    }
    return output.length > limit ? output.slice(0, limit) : output;
};

// For convenience
String.prototype.split = function (separator, limit) {
    return self(this, separator, limit);
};

return self;
}();

Satirist

For reference and further details, code is from: blog.stevenlevithan.com/archives/cross-browser-split – Quantum

Answer 2

Maybe you should use the RegExp object like the second example of http://msdn.microsoft.com/en-us/library/h6e2eb7w%28VS.85%29.aspx.

Regards.

Undertrick

It has nothing to do with it. The problem is the existence of a regular expression, not the way it is passed to the split method. – Transect

I'm sorry I didn't express well; I just wanted to point the way the regexp is created, not the regexp expression itself. IIRC I fixed some regexp problems creating the RegExp object, instead of using the /.../ format. – Undertrick