Js string.split() sans enlever les délimiteurs

Essaie:

"abcdeabcde".split(/(d)/);

var parts= string.split('d');
for (var i= parts.length; i-->1;)
    parts.splice(i, 0, 'd');

(la boucle inversée est nécessaire pour éviter d'ajouter ds pour les parties de la liste qui ont déjà eu d s insérée.)

j'aime la réponse de Kai, mais c'est incomplet. Au lieu d'utiliser:

"abcdeabcde".split(/(?=d)/g) //-> ["abc", "deabc", "de"]

ceci utilise un Anticipation De Longueur Nulle Affirmation dans regex, ce qui fait qu'une correspondance ne fait pas partie du groupe de capture. Pas d'autres astuces ou solutions nécessaires.

Peut être fait en une seule ligne:

var string = "abcdeabcde";    
string.split(/(d)/);
["abc", "d", "eabc", "d", "e"]

split - split est utilisé pour créer des lignes de pas pour la recherche.

[^D] - trouver un groupe de substrats ne contenant pas"d"

var str = "abcdeabcde";

str.match(/[^d]+|d/g)         // ["abc", "d", "eabc", "d", "e"]
or
str.match(/[^d]+/g)           // ["abc", "eabc", "e"]
or
str.match(/[^d]*/g)           // ["abc", "", "eabc", "", "e", ""]

Lire "Objet RegExp" si vous ne voulez pas de problèmes avec le "javascript".

Ceci est ma version pour les délimiteurs regexp. Il a la même interface avec String.prototype.split; il traitera global et non global regexp sans différence. La valeur retournée est un tableau dont les membres impairs sont des délimiteurs assortis.

function split(text, regex) {
    var token, index, result = [];
    while (text !== '') {
        regex.lastIndex = 0;
        token = regex.exec(text);
        if (token === null) {
            break;
        }
        index = token.index;
        if (token[0].length === 0) {
            index = 1;
        }
        result.push(text.substr(0, index));
        result.push(token[0]);
        index = index + token[0].length;
        text = text.slice(index);
    }
    result.push(text);
    return result;
}

// Tests
assertEquals(split("abcdeabcde", /d/), ["abc", "d", "eabc", "d", "e"]);
assertEquals(split("abcdeabcde", /d/g), ["abc", "d", "eabc", "d", "e"]);
assertEquals(split("1.2,3...4,5", /[,\.]/), ["1", ".", "2", ",", "3", ".", "", ".", "", ".", "4", ",", "5"]);
assertEquals(split("1.2,3...4,5", /[,\.]+/), ["1", ".", "2", ",", "3", "...", "4", ",", "5"]);
assertEquals(split("1.2,3...4,5", /[,\.]*/), ["1", "", "", ".", "2", "", "", ",", "3", "", "", "...", "4", "", "", ",", "5", "", ""]);
assertEquals(split("1.2,3...4,5", /[,\.]/g), ["1", ".", "2", ",", "3", ".", "", ".", "", ".", "4", ",", "5"]);
assertEquals(split("1.2,3...4,5", /[,\.]+/g), ["1", ".", "2", ",", "3", "...", "4", ",", "5"]);
assertEquals(split("1.2,3...4,5", /[,\.]*/g), ["1", "", "", ".", "2", "", "", ",", "3", "", "", "...", "4", "", "", ",", "5", "", ""]);
assertEquals(split("1.2,3...4,5.", /[,\.]/), ["1", ".", "2", ",", "3", ".", "", ".", "", ".", "4", ",", "5", ".", ""]);
assertEquals(split("1.2,3...4,5.", /[,\.]+/), ["1", ".", "2", ",", "3", "...", "4", ",", "5", ".", ""]);
assertEquals(split("1.2,3...4,5.", /[,\.]*/), ["1", "", "", ".", "2", "", "", ",", "3", "", "", "...", "4", "", "", ",", "5", "", "", ".", ""]);
assertEquals(split("1.2,3...4,5.", /[,\.]/g), ["1", ".", "2", ",", "3", ".", "", ".", "", ".", "4", ",", "5", ".", ""]);
assertEquals(split("1.2,3...4,5.", /[,\.]+/g), ["1", ".", "2", ",", "3", "...", "4", ",", "5", ".", ""]);
assertEquals(split("1.2,3...4,5.", /[,\.]*/g), ["1", "", "", ".", "2", "", "", ",", "3", "", "", "...", "4", "", "", ",", "5", "", "", ".", ""]);

// quick and dirty assert check
function assertEquals(actual, expected) {
  console.log(JSON.stringify(actual) === JSON.stringify(expected));
}

essaye ceci:

var string = "abcdeabcde";
    var delim = "d";
    var newstring = string.split(delim);
    var newArr = [];
    var len=newstring.length;
    for(i=0; i<len;i++)
    {
        newArr.push(newstring[i]);
        if(i != len-1)newArr.push(delim);
    }

il suffit d'annuler le String.prototype.split fonction avec celle-ci :

String.prototype._split = String.prototype.split;
String.prototype.split = function(delimiter, keepDelimiters) {
    if (!keepDelimiters) {
        return this._split(delimiter);
    } else {
        var res = [];
        var start = 0, index;
        while ((index = this.indexOf(delimiter, start)) != -1) {
            res.push(this.substr(start, index - start));
            res.push(delimiter);
            start = index + 1;
        }
        res.push(this.substr(start));
        return res;
    }
};


var str = "abcdeabcde";
alert(str.split("d", true));
alert(str.split("d"));

// output : 
//
//  [ 'abc', 'd', 'eabc', 'd', 'e' ]
//  [ 'abc', 'eabc', 'e' ]

cette méthode n'échouera pas, n'utilisez pas d'expressions régulières et est compatible avec l'original String.split fonction. Il est également compatible avec l' str.split(/(d)/); solution, mais n'échouera pas dans IE.

La seule restriction est que, si le deuxième paramètre est utilisé (le split fonction de remplacement drop-in), alors le délimiteur ne peut pas être une expression régulière. Mais si vous y réfléchissez un peu, ce n'est pas un restriction réelle puisque vous n'avez pas besoin du second paramètre si vous utilisez l'expression regular...

Essayez ceci

"abcdeabcde".split("d").reduce((result, value, index) => {
    return (index !== 0) ? result.concat(["d", value]) : result.concat(value)
}, [])

function split2(original){
   var delimiter = "d", result = [], tmp;
   tmp = original.split(delimiter);
   tmp.forEach(function(x){result.push(x); result.push(delimiter); });
   return result;
}

Essayez ceci

var string = "abcdeabcde";
var res = string.replace( /d/g, 'd' ).split(/(?=d)|/);
console.log( res );
//["abc", "d", "eabc", "d", "e"]