Regex et s'est échappé et sans échappement délimiteur

question relative à l' cette

J'ai une chaîne

a\;b\\;c;d

qui en Java ressemble 

String s = "a\\;b\\\\;c;d"

J'ai besoin de le diviser par le point-virgule avec les règles suivantes:

  1. Si le point-virgule est précédé d'une barre oblique inverse, il ne doit pas être traitée comme séparateur (entre un et b).

  2. Si la barre oblique inverse est échappé et, par conséquent, n'échappe pas lui-même le point-virgule, point-virgule doit être de séparation (entre b et c).

Donc point-virgule doit être traitée comme séparateur si il est zéro ou un nombre de barres obliques avant.

Pour l'exemple ci-dessus, je veux recevoir les chaînes de caractères suivantes (double anti-slash pour compilateur java):

a\;b\\
c
d
Où est la double barre oblique inverse? Allé?
Je ne suis pas sûr que c'est une regex que vous voulez ici
Je suis également pas sûr si les expressions régulières sont le meilleur outil pour cette tâche. Mais vous avez choisi d'ignorer ma réponse ci-dessous; - /

OriginalL'auteur lstipakov | 2011-10-26

  1. 5

    Vous pouvez utiliser les regex

    (?:\\.|[^;\\]++)*

    pour correspondre à tout le texte entre sans échappement des points-virgules:

    List<String> matchList = new ArrayList<String>();
try {
    Pattern regex = Pattern.compile("(?:\\\\.|[^;\\\\]++)*");
    Matcher regexMatcher = regex.matcher(subjectString);
    while (regexMatcher.find()) {
        matchList.add(regexMatcher.group());
    }

    Explication:

    (?:        # Match either...
 \\.       # any escaped character
|          # or...
 [^;\\]++  # any character(s) except semicolon or backslash; possessive match
)*         # Repeat any number of times.

    Le possessif match (++) est important pour éviter le retour en arrière catastrophique en raison de la imbriquée quantificateurs.

    Il renvoie également des chaînes vides, je me suis donc [a\;b\\, , c, , d, ]. Est ce que c'est possible de la prévenir, à l'exception de la vérification de la valeur de retour de groupe()?
    Oui, avec un + à la place de *, vous débarrasser des chaînes vides
    Étrange, il ne fait pas cela dans mes tests (en RegexBuddy, tout de même). Eh bien, si vous ne voulez pas vide correspond à, changer la * à +, mais vous pourrez également ne pas avoir de "vrai" vide matches comme dans a;;b.
    yep, véritable vide matchs sont très bien.

    OriginalL'auteur Tim Pietzcker

  2. 0
    String[] splitArray = subjectString.split("(?<!(?<!\\\\)\\\\);");

    Cela devrait fonctionner.

    Explication : 

    //(?<!(?<!\\)\\);
//
//Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!(?<!\\)\\)»
//   Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!\\)»
//      Match the character “\” literally «\\»
//   Match the character “\” literally «\\»
//Match the character “;” literally «;»

    Il vous suffit de le match, les points-virgules sont pas précédées par exactement un \.

    EDIT :

    String[] splitArray = subjectString.split("(?<!(?<!\\\\(\\\\\\\\){0,2000000})\\\\);");

    Cela va prendre soin de tout nombre impair de . Il bien sûr échouer si vous avez plus de 4000000 nombre de \. Explication de édité réponse :

    //(?<!(?<!\\(\\\\){0,2000000})\\);
//
//Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!(?<!\\(\\\\){0,2000000})\\)»
//   Assert that it is impossible to match the regex below with the match ending at this position (negative lookbehind) «(?<!\\(\\\\){0,2000000})»
//      Match the character “\” literally «\\»
//      Match the regular expression below and capture its match into backreference number 1 «(\\\\){0,2000000}»
//         Between zero and 2000000 times, as many times as possible, giving back as needed (greedy) «{0,2000000}»
//         Note: You repeated the capturing group itself.  The group will capture only the last iteration.  Put a capturing group around the repeated group to capture all iterations. «{0,2000000}»
//         Match the character “\” literally «\\»
//         Match the character “\” literally «\\»
//   Match the character “\” literally «\\»
//Match the character “;” literally «;»
    Cette échoue pour a\\\;b;c et d'autres cas, avec plus de deux barres obliques inverses.
    Il ne fonctionne pas avec un"\\; b\\\\\\;c;d"...
    vérifier édité réponse 🙂
    c'est le cas maintenant 🙂
    Quelqu'un peut m'expliquer la downvoting? Sauf que je suis absent quelque chose d'évident?

    OriginalL'auteur FailedDev

  3. 0

    Je ne fais pas confiance à détecter les cas avec n'importe quel type d'expression régulière. J'ai l'habitude de faire une simple boucle pour de telles choses, je vais les dessiner à l'aide de C puisque c'est il y a longtemps j'ai touché en dernier Java 😉

    int i, len, state;
char c;

for (len=myString.size(), state=0, i=0; i < len; i++) {
    c=myString[i];
    if (state == 0) {
       if (c == '\\') {
            state++;
       } else if (c == ';') {
           printf("; at offset %d", i);
       }
    } else {
        state--;
    }
}

    La avantages sont:

    1. vous pouvez exécuter la sémantique des actions sur chaque étape.
    2. il est très facile à porter vers une autre langue.
    3. vous n'avez pas besoin d'inclure l'intégralité de la bibliothèque regex juste pour cette tâche simple, ce qui ajoute à la portabilité.
    4. il devrait être beaucoup plus rapide que l'expression régulière matcher.

    OriginalL'auteur hochl

  4. 0

    Cette approche suppose que votre chaîne n'aura pas char '\0' dans votre chaîne. Si vous le faites, vous pouvez utiliser un autre char.

    public static String[] split(String s) {
    String[] result = s.replaceAll("([^\\\\])\\\\;", "$1
    public static String[] split(String s) {
String[] result = s.replaceAll("([^\\\\])\\\\;", "$1\0").split(";");
for (int i = 0; i < result.length; i++) {
result[i] = result[i].replaceAll("\0", "\\\\;");
}
return result;
}
    "    ).split(";");
    for (int i = 0; i < result.length; i++) {
        result[i] = result[i].replaceAll("
    public static String[] split(String s) {
String[] result = s.replaceAll("([^\\\\])\\\\;", "$1\0").split(";");
for (int i = 0; i < result.length; i++) {
result[i] = result[i].replaceAll("\0", "\\\\;");
}
return result;
}
    "    , "\\\\;");
    }
    return result;
}

    OriginalL'auteur krico

  5. 0

    C'est la vraie réponse, je pense.
    Dans mon cas, je suis en train de séparer à l'aide de | et le caractère d'échappement est &.

        final String regx = "(?<!((?:[^&]|^)(&&){0,10000}&))\\|";
    String[] res = "&|aa|aa|&|&&&|&&|s||||e|".split(regx);
    System.out.println(Arrays.toString(res));

    Dans ce code, je suis en utilisant Lookbehind pour échapper & personnage.
    à noter que le coup d'oeil derrière doit avoir un maximum de longueur.

    (?<!((?:[^&]|^)(&&){0,10000}&))\\|

    cela signifie tout | à l'exception de ceux qui sont les suivantes ((?:[^&]|^)(&&){0,10000}&)) et cette partie signifie n'importe quel nombre impair de &s.
    la partie (?:[^&]|^) est important de s'assurer que vous êtes en comptant toutes les &s derrière le | au début ou à d'autres personnages.

    OriginalL'auteur Rasoul