JavaScript: split no funciona en IE?

Hay una razón por la cual el siguiente fragmento de código no funciona en IE?
Mientras que con FF y otros cuerdo de los navegadores se divide la cadena por la expresión dada, es decir, que simplemente no funciona.

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

Gracias.

Tal vez esta página es de uso: blog.stevenlevithan.com/archives/cross-browser-split
Me pregunto, son aquellos que clase de idiota cosas, es decir, son errores o características que se decidió por parte de la administración? Supongo que IE 8 chupa tan bien!
BROMA: los Errores de los programadores son nuevas y emocionantes características de los anuncios publicitarios.
Tenga en cuenta que de los errores se corrigen en IE9+, el cual tiene un nuevo motor de JS.

OriginalEl autor thedp | 2009-09-21

2 respuestas

  1. 2

    puede agregar el código a continuación el programa y va a trabajar.

    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;
    }();
    Para la referencia y más detalles, el código es de: blog.stevenlevithan.com/archives/cross-browser-split

    OriginalEl autor http://www.tonitech.com的站长

  2. 0

    Quizás debería utilizar el objeto RegExp como el segundo ejemplo de http://msdn.microsoft.com/en-us/library/h6e2eb7w%28VS.85%29.aspx.

    Se refiere.

    No tiene nada que ver con ella. El problema es la existencia de una expresión regular, no la manera en que se pasa al método split.
    Lo siento, no me expreso bien; yo sólo quería apuntar la manera en la regexp es creado, no la regexp expresión de sí mismo. Si mal no recuerdo he arreglado algunos regexp problemas para crear el objeto RegExp, en lugar de utilizar el /…/ formato.

    OriginalEl autor ATorras

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *