1
var textt = "L'architecture du système d'information devient";
var pattern = "/(ARCH)/gi";
var array = textt.split(pattern);
console.log(array)

This results in:

[
    L',
    itecture du système d'information devient
]

And the expected result was:

[
    L',
    arch,
    itecture du système d'information devien
]

Another example

var textt = "ARCHIMAG";
var pattern = "/(ARCH)/gi";
var array = textt.split(pattern);
console.log(array)

Results in:

[
    IMAG
]

and the expected was:

[
    ARCH,
    IMAG
]
user2864740
  • 60,010
  • 15
  • 145
  • 220
leb
  • 73
  • 1
  • 8
  • 1
    Remove the quotes from the regex ? – adeneo Feb 05 '15 at 10:58
  • didn't work same result. it work fine in all browsers but only in IE7 – leb Feb 05 '15 at 11:03
  • You're saying it works in all other browsers with the regex as a string ? – adeneo Feb 05 '15 at 11:10
  • It seems that old versions of IE (7 and lower) don't support non–capturing patterns with *split*. There are ways of doing the same thing with a function if you're happy with a feature testing approach. – RobG Feb 05 '15 at 11:21
  • @adeneo yes it work in all other browsers.. – leb Feb 05 '15 at 11:52
  • @RobG can you give me the function or an example how to make that function – leb Feb 05 '15 at 11:53
  • A few years back (2007) Steven Levithan created a cross browser `String.prototype.split` and it can be found https://gist.github.com/slevithan/2048056 – Xotic750 Feb 05 '15 at 13:06
  • Possible duplicate: http://stackoverflow.com/questions/4417931/javascript-split-regex-bug-in-ie7?rq=1 – Xotic750 Feb 05 '15 at 14:30

3 Answers3

1

If you're OK with a feature test and function to replace a non–capturing split, try the following. It tests for support when the script is loaded and assigns an appropriate function to nonCaptureSplit, so the test is only done once.

The pattern will need to be escaped if you are using anything other than alphabetic characters or numerals (e.g. if there is punctuation in the string).

Edited

Now does a completely manual split if lacking support for non-capture split.

// Do case insensitive, non-capture split
var nonCaptureSplit = (function() {

  // Feature test for non-capturing split
  if ( 'ab'.split(/(a)/).length == 3) {
    return function (str, pattern) {
      var re = new RegExp('(' + pattern + ')','i');
      return str.split(re);
    };

  // Otherise, do it with a function
  } else {
    return function(str, pattern) {

      // Do case insensitive split
      var result = [];
      var ts = str.toLowerCase(); // copy of string in lower case
      var tp = pattern.toLowerCase();
      var first = true;

      while (ts.indexOf(tp) != -1) {
        var i = ts.indexOf(tp);

        // If first match is at the start, insert empty string + pattern
        // Trim pattern from front of temp strings
        if (i == 0 && first) {
          result.push('', pattern);
          ts = ts.substring(tp.length);
          str = str.substring(tp.length);

        // If match is at the end, append pattern and ''
        // Set temp string to '' (i.e. finished)
        } else if (i == ts.length - tp.length) {
          result.push(str.substr(0,i), pattern);
          ts = '';
          str = '';

        // Otherwise, append the next unmatched part
        // and pattern
        } else {
          result.push(str.substring(0,i), pattern);
          ts = ts.substring(i + pattern.length);
          str = str.substring(i + pattern.length);

        }
        first = false;
      }

      // Append remainder of string or '' if used, i.e. last match
      // must have been at end of string
      result.push( ts.length? str : '');

      return result;

    };
  }
}());

tests:

alert(nonCaptureSplit('wa', 'wa'));        // ,wa,
alert(nonCaptureSplit('qwqwaba', 'wa'));   // qwq,wa,ba
alert(nonCaptureSplit('qwqwaba', 'qw'));   // ,qw,,qw,aba
alert(nonCaptureSplit('qwqwaba', 'ba'));   // qwqwa,ba,
alert(nonCaptureSplit('baaqwqbawaba', 'ba')); // ,ba,aqwq,ba,wa,ba,

alert(nonCaptureSplit("L'architecture du système d'information devient", "ARCH"));
// L',arch,itecture du système d'information devient

alert(nonCaptureSplit("ARCHIMAG", "ARCH")); // ,ARCH,IMAG

It might be a bit inefficient for large strings with lots of matches, but only in browsers without support for non–capturing split. Test results matched in Safari and IE 6. Please test thoroughly and let me know if there are issues.

Oh, this isn't a general solution, but it should work for the limited cases similar to the OP.

RobG
  • 142,382
  • 31
  • 172
  • 209
  • the first part "L'architecture du système d'information devient" worked perfect but for the second part "ARCHIMAG" it get archimag not like i want ,ARCH,IMAG @RobG – leb Feb 05 '15 at 12:49
  • There was a bug in the script (I was splitting on the pattern, not the regular expression). It now does a completely manual split by matching and substring-ing the original. It is specific to non–capture, case insensitive split though and punctuation may give it trouble so still not a general solution (adding quoting for regular expression flags, etc. in the source string will make it so). – RobG Feb 05 '15 at 14:18
0

If you are looking to get around known browser issues in String.prototype.split then you need to take a look at Steven Levithan's cross browser fixes And see his original post from back in 2007. This is also used in his XRegExp library. It is also used in ES5 shim and probably others.

/*!
 * Cross-Browser Split 1.1.1
 * Copyright 2007-2012 Steven Levithan <stevenlevithan.com>
 * Available under the MIT License
 * ECMAScript compliant, uniform cross-browser split method
 */

/**
 * Splits a string into an array of strings using a regex or string separator. Matches of the
 * separator are not included in the result array. However, if `separator` is a regex that contains
 * capturing groups, backreferences are spliced into the result each time `separator` is matched.
 * Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably
 * cross-browser.
 * @param {String} str String to split.
 * @param {RegExp|String} separator Regex or string to use for separating the string.
 * @param {Number} [limit] Maximum number of items to include in the result array.
 * @returns {Array} Array of substrings.
 * @example
 *
 * // Basic use
 * split('a b c d', ' ');
 * // -> ['a', 'b', 'c', 'd']
 *
 * // With limit
 * split('a b c d', ' ', 2);
 * // -> ['a', 'b']
 *
 * // Backreferences in result array
 * split('..word1 word2..', /([a-z]+)(\d+)/i);
 * // -> ['..', 'word', '1', ' ', 'word', '2', '..']
 */
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;

}();
Xotic750
  • 22,914
  • 8
  • 57
  • 79
0

this is the best solution:

function ieSplit(str, separator) {
var match = str.match(RegExp(separator, 'g'));
var notmatch = str.replace(new RegExp(separator, 'g'), '[|]').split('[|]');
var merge = [];
for(i in notmatch) {
    merge.push(notmatch[i]);
    if (match != null && match[i] != undefined) {
        merge.push(match[i]);
    }
}
return merge;
}
leb
  • 73
  • 1
  • 8