JavaScript i regex: podziel ciąg i zachowaj separator


131

Mam ciąg:

var string = "aaaaaa<br />&dagger; bbbb<br />&Dagger; cccc"

Chciałbym podzielić ten ciąg za pomocą separatora, <br />po którym następuje znak specjalny.

Aby to zrobić, używam tego:

string.split(/<br \/>&#?[a-zA-Z0-9]+;/g);

Dostaję to, czego potrzebuję, z wyjątkiem tego, że tracę ogranicznik. Oto przykład: http://jsfiddle.net/JwrZ6/1/

Jak mogę zachować separator?


jeśli znasz separator wcześniej, dlaczego po prostu nie ... var delim = "<br/>";?
Andreas Wong,

Dziękuję @SiGanteng, znam wcześniej ogranicznik, ale nie mogę sprawić, by działał na moim przykładzie. Muszę zachować <br /> separator, po którym następuje znak specjalny, ponieważ czasami może wystąpić <br /> znak specjalny, po którym nie ma znaku specjalnego, a ten nie musi być dzielony.
Miloš

2
Dobre pytanie, mam podobny przypadek, w którym znajomość separatora nie pomaga. Dzielę się na „] i [”. Więc tak naprawdę moim ogranicznikiem jest „&”, ale podział na ten nie jest wystarczająco dokładny, potrzebuję nawiasów po obu stronach, aby określić właściwy podział. Jednak potrzebuję tych nawiasów z powrotem w moich podzielonych ciągach. 1 w każdym z każdej strony.
PandaWood

Odpowiedzi:


104

Użyj (dodatniego) lookahead, aby wyrażenie regularne stwierdzało, że znak specjalny istnieje, ale w rzeczywistości go nie dopasowuje:

string.split(/<br \/>(?=&#?[a-zA-Z0-9]+;)/g);

Zobacz to w akcji:

var string = "aaaaaa<br />&dagger; bbbb<br />&Dagger; cccc";
console.log(string.split(/<br \/>(?=&#?[a-zA-Z0-9]+;)/g));


Kiedy używam tego kodu, dodaje 0na końcu każdego ciągu
wojownik klawiatury

2
W linku, który podałeś, nie mogę znaleźć nic o pozytywnym spojrzeniu w przyszłość.
Paul Chris Jones,

@PaulJones zawartość została przeniesiona w międzyczasie. Dzięki za poinformowanie mnie, poprawiłem link.
Jon

179

Miałem podobny, ale nieco inny problem. W każdym razie, oto przykłady trzech różnych scenariuszy, w których należy zachować separator.

"1、2、3".split("、") == ["1", "2", "3"]
"1、2、3".split(/(、)/g) == ["1", "、", "2", "、", "3"]
"1、2、3".split(/(?=、)/g) == ["1", "、2", "、3"]
"1、2、3".split(/(?!、)/g) == ["1、", "2、", "3"]
"1、2、3".split(/(.*?、)/g) == ["", "1、", "", "2、", "3"]

Ostrzeżenie: czwarty będzie działał tylko do dzielenia pojedynczych znaków. ConnorsFan przedstawia alternatywę :

// Split a path, but keep the slashes that follow directories
var str = 'Animation/rawr/javascript.js';
var tokens = str.match(/[^\/]+\/?|\//g);

3
Szukałem czegoś podobnego do trzeciego przykładu, ale działa to tylko wtedy, gdy elementy są tylko jedną postacią - w przeciwnym razie podzieli się na pojedyncze znaki. W końcu musiałem iść żmudną trasą RegExp.exec .
Gordon

2
Nie rozumiem, dlaczego wszyscy używają / g
Sarsaparilla

1
Jak można użyć tego wyrażenia regularnego „1、2、3” .split (/ (?! 、) / G) == [„1 、”, „2 、”, „3”] dla pełnych słów? Na przykład „foo1, foo2, foo3”
Waltari

Jesteś geniuszem!. gdzie znajdziesz dokumentację wyjaśniającą sposób działania? nie potrzebujesz gkońca
pery mimon

1
Tłumaczenie .matchniechciwego rozwiązania dla tych przykładów: "11、22、33".match(/.*?、|.+$/g)-> ["11、", "22、", "33"]. Uwaga /gmodyfikator jest kluczowa dla meczu.
Beni Cherniavsky-Paskin

57

Jeśli zawiniesz separator w parantezach, będzie on częścią zwróconej tablicy.

string.split(/(<br \/>&#?[a-zA-Z0-9]+);/g);
// returns ["aaaaaa", "<br />&dagger;", "bbbb", "<br />&Dagger;", "cccc"]

W zależności od tego, którą część chcesz zachować, zmień pasującą podgrupę

string.split(/(<br \/>)&#?[a-zA-Z0-9]+;/g);
// returns ["aaaaaa", "<br />", "bbbb", "<br />", "cccc"]

Możesz ulepszyć wyrażenie, ignorując wielkość liter string.split (/ () & #? [A-z0-9] +; / gi);

Możesz dopasować do predefiniowanych grup, takich jak ta: \drówna się [0-9]i \wrówna się [a-zA-Z0-9_]. Oznacza to, że Twoje wyrażenie może wyglądać tak.

string.split(/<br \/>(&#?[a-z\d]+;)/gi);

JavaScriptKit zawiera dobre odniesienie do wyrażeń regularnych .


4
Co więcej, nie wiem, że możemy zachować tylko część ogranicznika. W rzeczywistości muszę zachować tylko specjalny znak, mogę to zrobić za pomocą tego: string.split (/ <br \/> (& #? [A-zA-Z0-9] +;) / g);
Miloš

1
Możesz zoptymalizować swoje wyrażenie, ignorując wielkość liter. Lub dopasuj do predefiniowanej klasy postaci. Zaktualizuję odpowiedź.
Torsten Walter,

2
Dlaczego to jest tak niskie… Jest doskonałe i takie elastyczne
Tofandel

2
Jest to z pewnością najłatwiejszy sposób i najbardziej czytelna składnia.
Timar Ivo Batis

4

odpowiedziałem na to tutaj również JavaScript Split Wyrażenie regularne zachowaj separator

użyj wzorca wyprzedzenia (? = wzorzec) w przykładzie wyrażenia regularnego

var string = '500x500-11*90~1+1';
string = string.replace(/(?=[$-/:-?{-~!"^_`\[\]])/gi, ",");
string = string.split(",");

da to następujący wynik.

[ '500x500', '-11', '*90', '~1', '+1' ]

Można również podzielić bezpośrednio

string = string.split(/(?=[$-/:-?{-~!"^_`\[\]])/gi);

dając ten sam wynik

[ '500x500', '-11', '*90', '~1', '+1' ]

Dlaczego nie od razu się rozdzielić, jak w zaakceptowanej odpowiedzi Jona?
Gordon

@Gordon ... :) Mogę po prostu to zrobić ... zaktualizowałem kod ... Pozdrawiam
Fry

2

Zrobiłem modyfikację odpowiedzi jichi i umieściłem ją w funkcji, która również obsługuje wiele liter.

String.prototype.splitAndKeep = function(separator, method='seperate'){
    var str = this;
    if(method == 'seperate'){
        str = str.split(new RegExp(`(${separator})`, 'g'));
    }else if(method == 'infront'){
        str = str.split(new RegExp(`(?=${separator})`, 'g'));
    }else if(method == 'behind'){
        str = str.split(new RegExp(`(.*?${separator})`, 'g'));
        str = str.filter(function(el){return el !== "";});
    }
    return str;
};

odpowiedzi jichi Trzecia metoda nie zadziała w tej funkcji, więc wybrałem czwartą metodę i usunąłem puste spacje, aby uzyskać ten sam wynik.

edit: druga metoda, która wyłącza tablicę do podziału char1 lub char2

String.prototype.splitAndKeep = function(separator, method='seperate'){
    var str = this;
    function splitAndKeep(str, separator, method='seperate'){
        if(method == 'seperate'){
            str = str.split(new RegExp(`(${separator})`, 'g'));
        }else if(method == 'infront'){
            str = str.split(new RegExp(`(?=${separator})`, 'g'));
        }else if(method == 'behind'){
            str = str.split(new RegExp(`(.*?${separator})`, 'g'));
            str = str.filter(function(el){return el !== "";});
        }
        return str;
    }
    if(Array.isArray(separator)){
        var parts = splitAndKeep(str, separator[0], method);
        for(var i = 1; i < separator.length; i++){
            var partsTemp = parts;
            parts = [];
            for(var p = 0; p < partsTemp.length; p++){
                parts = parts.concat(splitAndKeep(partsTemp[p], separator[i], method));
            }
        }
        return parts;
    }else{
        return splitAndKeep(str, separator, method);
    }
};

stosowanie:

str = "first1-second2-third3-last";

str.splitAndKeep(["1", "2", "3"]) == ["first", "1", "-second", "2", "-third", "3", "-last"];

str.splitAndKeep("-") == ["first1", "-", "second2", "-", "third3", "-", "last"];

1

Funkcja rozszerzająca rozdziela ciąg za pomocą podłańcucha lub wyrażenia regularnego, a separator jest umieszczany zgodnie z drugim parametrem przed lub za.

    String.prototype.splitKeep = function (splitter, ahead) {
        var self = this;
        var result = [];
        if (splitter != '') {
            var matches = [];
            // Getting mached value and its index
            var replaceName = splitter instanceof RegExp ? "replace" : "replaceAll";
            var r = self[replaceName](splitter, function (m, i, e) {
                matches.push({ value: m, index: i });
                return getSubst(m);
            });
            // Finds split substrings
            var lastIndex = 0;
            for (var i = 0; i < matches.length; i++) {
                var m = matches[i];
                var nextIndex = ahead == true ? m.index : m.index + m.value.length;
                if (nextIndex != lastIndex) {
                    var part = self.substring(lastIndex, nextIndex);
                    result.push(part);
                    lastIndex = nextIndex;
                }
            };
            if (lastIndex < self.length) {
                var part = self.substring(lastIndex, self.length);
                result.push(part);
            };
            // Substitution of matched string
            function getSubst(value) {
                var substChar = value[0] == '0' ? '1' : '0';
                var subst = '';
                for (var i = 0; i < value.length; i++) {
                    subst += substChar;
                }
                return subst;
            };
        }
        else {
            result.add(self);
        };
        return result;
    };

Test:

    test('splitKeep', function () {
        // String
        deepEqual("1231451".splitKeep('1'), ["1", "231", "451"]);
        deepEqual("123145".splitKeep('1', true), ["123", "145"]);
        deepEqual("1231451".splitKeep('1', true), ["123", "145", "1"]);
        deepEqual("hello man how are you!".splitKeep(' '), ["hello ", "man ", "how ", "are ", "you!"]);
        deepEqual("hello man how are you!".splitKeep(' ', true), ["hello", " man", " how", " are", " you!"]);
        // Regex
        deepEqual("mhellommhellommmhello".splitKeep(/m+/g), ["m", "hellomm", "hellommm", "hello"]);
        deepEqual("mhellommhellommmhello".splitKeep(/m+/g, true), ["mhello", "mmhello", "mmmhello"]);
    });

0

Używałem tego:

String.prototype.splitBy = function (delimiter) {
  var 
    delimiterPATTERN = '(' + delimiter + ')', 
    delimiterRE = new RegExp(delimiterPATTERN, 'g');

  return this.split(delimiterRE).reduce((chunks, item) => {
    if (item.match(delimiterRE)){
      chunks.push(item)
    } else {
      chunks[chunks.length - 1] += item
    };
    return chunks
  }, [])
}

Tyle że nie powinieneś się z tym bawić String.prototype, więc oto wersja funkcji:

var splitBy = function (text, delimiter) {
  var 
    delimiterPATTERN = '(' + delimiter + ')', 
    delimiterRE = new RegExp(delimiterPATTERN, 'g');

  return text.split(delimiterRE).reduce(function(chunks, item){
    if (item.match(delimiterRE)){
      chunks.push(item)
    } else {
      chunks[chunks.length - 1] += item
    };
    return chunks
  }, [])
}

Więc możesz zrobić:

var haystack = "aaaaaa<br />&dagger; bbbb<br />&Dagger; cccc"
var needle =  '<br \/>&#?[a-zA-Z0-9]+;';
var result = splitBy(haystack , needle)
console.log( JSON.stringify( result, null, 2) )

Otrzymasz:

[
  "<br />&dagger; bbbb",
  "<br />&Dagger; cccc"
]
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.