L'effondrement et de la Capture d'un Motif répété dans une Seule Regex Expression

Je continue cogner dans des situations où j'ai besoin d'obtenir un certain nombre de jetons à partir d'une chaîne et après d'innombrables essais, je ne pouvais pas trouver un moyen de simplifier le processus.

Disons donc que le texte est:

début:test-test-lorem ipsum-sir-doloret-etc-etc-chose:la fin

Cet exemple a 8 éléments à l'intérieur, mais dire qu'il pourrait avoir entre 3 et 10 points.

J'avais idéalement comme quelque chose comme ceci:

start:(?:(\w+)-?){3,10}:end agréable et propre, MAIS il ne saisit du dernier match. voir ici

J'ai l'habitude d'utiliser quelque chose comme cela dans des situations simples: 

start:(\w+)-(\w+)-(\w+)-?(\w+)?-?(\w+)?-?(\w+)?-?(\w+)?-?(\w+)?-?(\w+)?-?(\w+)?:end

3 groupes obligatoires et un autre de 7 en option en raison de la max 10 limite, mais cela n'a pas l'air "sympa" et ce serait une douleur à écrire et à suivre si la limite est de 100, et les matchs ont été plus complexe. démo

Et le meilleur que j'ai pu faire jusqu'à présent:

start:(\w+)-((?1))-((?1))-?((?1))?-?((?1))?-?((?1))?-?((?1))?-?((?1))?:end

plus courte, surtout si les matches sont complexes, mais encore long. démo

Quelqu'un a réussi à le faire fonctionner comme un 1 regex seule solution sans programmation?

Je suis surtout intéressé sur la façon dont cela peut être fait en PCRE mais d'autres saveurs serait ok aussi.

Mise à jour:

Le but est de valider un match et de capturer des jetons à l'intérieur de match 0 par RegEx seul, sans OS/logiciel/Logiciel de Programmation de Langue limitation

Mise à jour 2 (bounty):

Avec @nhahtdh de l'aide, je suis arrivé à l'expression régulière ci-dessous en utilisant \G: 

(?:start:(?=(?:[\w]+(?:-|(?=:end))){3,10}:end)|(?!^)\G-)([\w]+)

démo encore plus court, mais peut être décrit sans la répétition du code

Je suis aussi intéressé par l'ECMA saveur et comme il ne supporte pas \G demandais si il y a une autre façon, surtout sans l'aide de /g modificateur.

  • Les expressions régulières sont vraiment conçus pour la reconnaissance de motifs, mais vous essayez de l'utiliser pour un changement de tendance. Vous ne dites pas quel système d'exploitation vous êtes sur mais un Awk (Unix/Linux) ou Powershell (Windows) serait probablement faire ce que vous devez faire...
  • mis à jour le post pour clarifier, la recherche d'une façon intelligente d'utiliser les RegEx dans des situations complexes, sans l'utilisation d'un logiciel d'assistance
  • non, vous ne pouvez pas faire général des choses comme ça en JS dans un seul match/étape. Les seules façons de faire qui sont dans: .NET (capture de répéter le contenu de groupe), ou avec la regex saveurs qui prennent en charge \G (ou similaire fonctionnalités de l'API).
InformationsquelleAutor CSᵠ | 2013-03-07
  1. 35

    De lire ceci en premier!

    Ce post est de montrer la possibilité, plutôt que de sanctionner le "tout regex" approche du problème. L'auteur a écrit 3-4 variantes, chacun a bug subtil qui sont difficiles à détecter, avant d'arriver à la solution actuelle.

    Pour votre exemple, il y a d'autres meilleure solution est plus facile à gérer, comme l'appariement et le fractionnement du match, le long de la délimiteurs.

    Ce post traite avec votre exemple. Je doute vraiment plein de généralisation est possible, mais l'idée derrière est réutilisable pour des cas similaires.

    Résumé

    • .NET prend en charge la capture motif de répétition avec CaptureCollection classe.
    • Pour les langues qui prend en charge \G et de regarder derrière, nous pouvons être en mesure de construire une regex qui fonctionne avec appariement globale de la fonction. Il n'est pas facile de l'écrire tout à fait correcte et facile à écrire un subtil buggy regex.
    • Pour les langues sans \G et regardez-derrière: il est possible d'émuler \G avec ^, en partant de la chaîne d'entrée après un seul match. (Ne sont pas couverts dans cette réponse).

    Solution

    Cette solution suppose que le moteur d'expressions régulières prend en charge \G match frontière, look-ahead (?=pattern), et regardez-derrière (?<=pattern). Java, Perl, PCRE, .NET, Ruby regex saveurs en faveur de ces fonctionnalités avancées ci-dessus.

    Cependant, vous pouvez aller avec votre regex dans .NET. Depuis .NET prend en charge la capture de toutes les instances de qui est compensée par une capture d'un groupe qui est répété par CaptureCollection classe.

    Pour votre cas, il peut être fait dans une regex, avec l'utilisation de \G correspondre à des limites, et regarde en avant pour limiter le nombre de répétitions:

    (?:start:(?=\w+(?:-\w+){2,9}:end)|(?<=-)\G)(\w+)(?:-|:end)

    DÉMO. La construction est \w+- répète, puis \w+:end.

    (?:start:(?=\w+(?:-\w+){2,9}:end)|(?!^)\G-)(\w+)

    DÉMO. La construction est \w+ pour le premier élément, puis -\w+ répété. (Merci à ka ᵠ pour la suggestion). Cette construction est plus simple de raisonner sur son exactitude, car il y a moins de postes.

    \G match frontière est particulièrement utile lorsque vous devez effectuer la segmentation, où vous devez assurez-vous que le moteur n'est pas d'avancer et de correspondance des étoffes qui doivent avoir été invalide.

    Explication

    Laissez-nous briser les regex:

    (?:
  start:(?=\w+(?:-\w+){2,9}:end)
    |
  (?<=-)\G
)
(\w+)
(?:-|:end)

    La partie la plus facile à reconnaître, c'est (\w+) dans la ligne de l'avant-dernier, qui est le mot que vous voulez capturer.

    La dernière ligne est également très facile à reconnaître: le mot à rechercher peut être suivie par - ou :end.

    J'autorise l'expression régulière regex pour librement début correspondant n'importe où dans la chaîne. En d'autres termes, start:...:end peuvent apparaître n'importe où dans la chaîne, et un certain nombre de fois; les regex simplement correspondre à tous les mots. Vous avez seulement besoin de traiter le tableau retourné à séparer le cas de la correspondance des jetons viennent en fait de.

    Comme pour l'explication, le début de la regex vérifie la présence de la chaîne start:, et la suite de look-ahead vérifie que le nombre de mots est à l'intérieur de la limite spécifiée, et il se termine avec :end. Soit ça, ou nous vérifions que le caractère avant le match précédent est un -, et continuer de match précédent.

    Pour les autres constructions:

    (?:
  start:(?=\w+(?:-\w+){2,9}:end)
    |
  (?!^)\G-
)
(\w+)

    Tout est presque la même, sauf que nous match start:\w+ d'abord avant d'égaler la répétition de la forme -\w+. Contrairement à la première de la construction, où nous match start:\w+- en premier, et les instances répétées de \w+- (ou \w+:end pour la dernière répétition).

    Il est assez difficile à faire cette regex fonctionne pour la mise en correspondance dans le milieu de la chaîne:

    • Nous avons besoin de vérifier le nombre de mots entre start: et :end (dans le cadre de l'exigence de l'original regex).

    • \G correspond au début de la chaîne aussi! (?!^) est nécessaire pour éviter ce problème. Sans prendre soin de cela, les regex peuvent produire un match quand il n'est pas tout start:.

      Pour la première construction, à l'affût derrière (?<=-) déjà éviter ce cas ((?!^) est implicite par (?<=-)).

    • Pour la première construction (?:start:(?=\w+(?:-\w+){2,9}:end)|(?<=-)\G)(\w+)(?:-|:end), nous devons nous assurer que nous n'avons pas correspondre à quelque chose de drôle après :end. Le look-derrière est à cette fin: elle empêche les poubelles après :end à partir de la correspondance.

      La deuxième construction n'a pas ce problème, puisque nous sommes coincés à : (de :end) après nous avons comparé l'ensemble des jetons entre les deux.

    De Validation De La Version

    Si vous voulez faire que la validation de la chaîne d'entrée suit le format (pas de trucs supplémentaires à l'avant et derrière), et extraire les données, vous pouvez ajouter des ancres en tant que tel:

    (?:^start:(?=\w+(?:-\w+){2,9}:end$)|(?!^)\G-)(\w+)
(?:^start:(?=\w+(?:-\w+){2,9}:end$)|(?!^)\G)(\w+)(?:-|:end)

    (Look-derrière n'est pas nécessaire, mais nous avons encore besoin (?!^) pour éviter \G à partir de la correspondance au début de la chaîne).

    Construction

    Pour tous les problèmes de l'endroit où vous souhaitez capturer toutes les instances d'une répétition, je ne pense pas qu'il existe une manière générale, pour modifier la regex. Un exemple d'un "dur" (voire impossible?) cas de conversion est lors d'une répétition a pour revenir en arrière d'une ou de plus de boucle de remplir certaines conditions de match.

    Lorsque la première regex décrit l'ensemble de la chaîne d'entrée (type de validation), il est généralement plus facile de convertir par rapport à une regex qui essaie de faire correspondre depuis le milieu de la corde (même type). Cependant, vous pouvez toujours faire un match avec l'original de la regex, et nous convertir correspondance type de problème de dos à la validation type de problème.

    Nous construire de tels regex en passant par ces étapes:

    • Écrire une regex qui couvre la partie avant de la répétition (par exemple,start:). Laissez-nous appeler cette préfixe regex.
    • Match et la capture de la première instance. (par exemple,(\w+))

      (À ce stade, la première instance et délimiteur doit avoir été appariés)
    • Ajouter le \G comme une alternance. Besoin d'être pour l'empêcher de correspondre au début de la chaîne.
    • Ajouter le séparateur (le cas échéant). (par exemple,-)

      (Après cette étape, le reste des jetons ont également été mis en correspondance, à l'exception de la dernière, peut-être)
    • Ajouter la partie qui couvre la partie après la répétition (le cas échéant) (par exemple,:end). Nous allons l'appeler la partie après la répétition suffixe regex (si nous l'ajoutons à la construction n'a pas d'importance).
    • Maintenant la partie difficile. Vous devez vérifier que:
      • Il n'y a pas d'autre façon de commencer un match, en dehors de la préfixe regex. Prendre note de la \G branche.
      • Il n'y a aucune façon de commencer n'importe quel match après la suffixe regex a été appariés. Prendre note de la façon dont \G branche commence un match.
      • Pour la première construction, si vous mélangez le suffixe regex (par exemple :end) avec séparateur (par exemple -) dans une alternance, assurez-vous de ne pas permettre le suffixe regex comme délimiteur.
    • Votre chemin est un chemin, lorsque vous avez un raisonnable limite supérieure sur le nombre de répétition (comme dans votre cas). Sinon, vous avez besoin d'un traitement supplémentaire pour choisir le bon élément. Je comprendrais si il n'est pas possible de faire la manipulation sur le résultat, mais quand c'est possible, vous devriez le faire.
    • Un autre point est que, vous pouvez toujours correspondre à l'ensemble de la start:...:end d'abord, puis diviser chaque match, le long de la délimiteurs. Dans le cas de votre exemple, le délimiteur est assez clair que vous n'avez même pas besoin de mon laid regex solution.
    • en fait, après un peu de réflexion, j'ai trouvé que votre chemin est vraiment une solution viable! peut-être même mieux dans certains cas que la capture de tous les groupes à la fois! btw: réparé votre regex pour permettre un minimum de 3 groupes voir ici. veuillez mettre à jour votre réponse afin que je puisse l'accepter
    • Merci pour la partie sur les 3-10 (qui a été très imprudent). Mais aussi la vôtre avez un problème regex101.com/r/zE5hU5. J'ai besoin probablement de 10 à 15 min à modifier.
    • bonne prise, c'est de là d'où: (?!^)\G est important démo
    • Fait. Cerveau frit.
    • bravo! J'ai besoin de ce dans les systèmes où seul RegEx est laissé à l'utilisateur et il est très utile truc pour faire dans ces situations. btw: j'aime toujours cette version plus parce que j'ai juste besoin de répéter le mess deux fois. Merci!
    • Notez que la regex est maintenant ambigu: Depuis : est autorisé dans la répétition de jeton, il n'est pas clair si pour correspondre à tout le chemin à la 2ème :end ou s'arrêter à la première :end dans start:some-thing-here:end:end unrelated text
    • Si vous supprimez le (?=...) direction générale, vous obtenez toujours les résultats de la droite... quel est Donc le point de l'avoir ? Je ne le vois pas xD
    • Veuillez rayer mes commentaires précédents. Le " look-ahead est habituellement nécessaire, après tout. Sinon, sans vérifier que tout est correctement répété et a un suffixe, la regex peut correspondre au contenu, même si un suffixe est manquant.

    InformationsquelleAutor nhahtdh
  2. 6

    Bien qu'il pourrait théoriquement être possible d'écrire une expression unique, c'est beaucoup plus pratique pour correspondre à l'extérieur des limites d'abord et ensuite effectuer un split sur la partie intérieure.

    Dans ECMAScript je voudrais écrire comme ceci:

    'start:test-test-lorem-ipsum-sir-doloret-etc-etc-something:end'
    .match(/^start:([\w-]+):end$/)[1] //match the inner part
    .split('-') //split inner part (this could be a split regex as well)

    En PHP:

    $txt = 'start:test-test-lorem-ipsum-sir-doloret-etc-etc-something:end';
if (preg_match('/^start:([\w-]+):end$/', $txt, $matches)) {
    print_r(explode('-', $matches[1]));
}
    • +1 solution en Deux étapes est généralement beaucoup plus lisible et maintenable.
    InformationsquelleAutor Ja͢ck
  3. 1

    Bien sûr, vous pouvez utiliser les regex dans cette chaîne de caractères entre guillemets.

    "(?<a>\\w+)-(?<b>\\w+)-(?:(?<c>\\w+)" \
"(?:-(?<d>\\w+)(?:-(?<e>\\w+)(?:-(?<f>\\w+)" \
"(?:-(?<g>\\w+)(?:-(?<h>\\w+)(?:-(?<i>\\w+)" \
"(?:-(?<j>\\w+))?" \
")?)?)?" \
")?)?)?" \
")"

    Est-ce une bonne idée? Non, je ne le pense pas.

    InformationsquelleAutor minopret
  4. 0

    Pas sûr que vous pouvez le faire de cette façon, mais vous pouvez utiliser l'indicateur global de trouver tous les mots, entre les deux points, voir:

    http://regex101.com/r/gK0lX1

    Vous auriez à valider le nombre de groupes de même à. Sans l'indicateur global, vous obtenez seulement un seul match, tous les matchs de changement {3,10} à {1,5} et vous obtenez le résultat "monsieur" à la place.

    import re

s = "start:test-test-lorem-ipsum-sir-doloret-etc-etc-something:end"
print re.findall(r"(\b\w+?\b)(?:-|:end)", s)

    produit

    ['test', 'test', 'lorem', 'ipsum', 'sir', 'doloret', 'etc', 'etc', 'something']

    • malheureusement, ce serait de trouver des correspondances dans cette chaîne non valide: invalid:test-lorem-ipsum-sir-doloret:end en plus de la validation des chaînes similaires de moins de 3 articles et plus de 10 articles et de programmation pour la mise en correspondance des processus
    • Vous êtes en train de faire trop de choses en une seule fois ici, je pense, puis, il est hors de la portée des expressions régulières.
    • RegExes sont très puissants! Dans certains cas, vous pouvez obtenir d'excellents résultats s'il est construit correctement. Voir accepté de répondre^
    InformationsquelleAutor spiralx
  5. 0

    Lorsque vous combinez:

    1. Votre observation: tout type de la répétition d'un seul groupe de capture entraînera un remplacement de la dernière capture, donc en ne retournant que la dernière prise de vue de la capture du groupe.
    2. La connaissance: Tout type de capture en fonction des pièces, au lieu de l'ensemble, le fait qu'il est impossible de fixer une limite sur le nombre de fois que le moteur d'expressions régulières vais le répéter. La limite devrait être de métadonnées (pas de regex).
    3. Avec une exigence que la réponse ne saurait engager la programmation (boucle), ni une réponse qui consiste à simplement copier-coller capturegroups comme vous l'avez fait dans votre question.

    Il peut être déduit qu'il ne peut pas être fait.

    Mise à jour: Il y a quelques regex moteurs pour lesquels p. 1 n'est pas nécessairement vrai. Dans ce cas, la regex que vous avez indiqué start:(?:(\w+)-?){3,10}:end va faire le travail (source).

    • Il peut être fait, avec \G.
    • En fait non, elle peut pas. \G exige de la boucle ou de la répétition (p. 3) et ne vous permettra pas de définir la limite de répétitions (3 à 10) sur les regex lui-même (p. 2).
    • Vous pouvez le faire avec preg_match_all, ce qui le rend très simple et regex seule solution. La limite de capture est peut-être possible avec look-ahead (dans la solution avec \G). (Je ne prétends pas que cela fonctionne pour tous les cas, il y a, mais il y a une catégorie de cas que cela fonctionne).
    • Ne fonctionne pas dans ce cas.
    • Eh bien, c'est possible, mais pas facile à écrire un correct. Voir ma réponse.
    • Eh bien, je vais être damné... +1
    • en fonction de votre source, il semble comme il pourrait être possible d'utiliser une simple regex, comme dans l' .NET bien que je ne suis pas certain de savoir comment, testé avec regexplanet/dotnet de l'outil et a obtenu le même résultat (seul le dernier)
    • Il est facile de faire dans .NET nommés de capturer les groupes. Particulier pour un groupe nommé, vous pouvez faire une boucle sur tous les sujets instances de celui-ci.

    InformationsquelleAutor Lodewijk Bogaards