RegEx pour correspondre à un modèle et exclure une partie de la chaîne

Question

J'ai des chaînes à associer via RegEx. Nous avons une application Java qui lit la regex à partir d'un fichier de configuration et prend deux groupes de chaînes, dont le nombre est spécifié dans la même configuration.

E.g.

CustomAction.523274ca945f.dialogLabel=Executing Custom Code... 

seront jumelés à

(?m)^(?!#)\s*(\S*)\s*=\s*(\S*.*) 

Ce que je dois est de choisir le premier groupe « CustomAction.523274ca945f.dialogLabel » et exclure la chaîne aléatoire dans le milieu si je me retrouve avec quelque chose comme « CustomAction.dialogLabel » ou " CustomAction..dialogLabel "Eh bien toute autre combinaison, mais la chaîne aléatoire.

Je n'ai pas la source pour l'application Java que j'utilise. Ceci est une application pour laquelle je peux créer un fichier de configuration dans lequel je précise un motif et deux groupes et les app prend

 
pattern: (?m)^(?!#)\\s*([^.=\\s]*)\\.(?:[^.=\\s]*\\.)?([^.=\\s]*)\\s*=\\s*(.*?)\\s*$ 
key_group: 1 
value_group: 2 

Je ne peux spécifier un groupe par clé et une par valeur. Selon ce modèle, l'application choisit key_group comme clé et value_group comme valeur.

Je ne veux pas la poubelle au milieu car c'est aléatoire cela change la clé à chaque fois.

Answer 1

Deux approches; d'abord en supposant que votre propriété est trois éléments à long un simple remplacement de votre premier (\ S *) avec:

(\S+?)\.\S+?\.(\S+) 

Remarque J'ai aussi changé le * à + car il n'a pas de sens d'avoir « .. » comme partie d'une propriété, j'ai aussi utilisé des qualificatifs non gourmands, mais ça devrait fonctionner sans eux. Ensuite, vous pouvez simplement utiliser les numéros de groupe appropriés pour reconstruire la propriété ajustée. Une seconde approche supposant que votre chaîne aléatoire est un nombre hexadécimal (ce qui semble être) et les parties non aléatoires de la propriété ne comprennent pas les numéros:

((?:\S+.)*)(?:[0-9A-Fa-f]+.)?((?:\S+.?)+) 

Ainsi, le premier groupe devrait tout pick-up avant que le hasard nombre (y compris un point de fin) le deuxième groupe va manger le nombre aléatoire, et le troisième va correspondre à la chaîne restante (ou le tout s'il n'y a pas de partie de nombre aléatoire).

EDIT

Avec la description mise à jour du problème et correspondant à deux groupes seulement ma réponse est cela est impossible. Dans une expression régulière, il n'y a pas de mécanisme pour "effacer" une partie d'une correspondance. De la définition du problème, la partie de la clé qui est de ne pas être inclus est au milieu d'un autre texte-à-dire le modèle général est:

((a)(?:b)(c)) 

Puisque nous ne pouvons pas pré ou post-traitement « B » Toujours faire partie du groupe de correspondance plus grand qui inclut à la fois a et c, le fait qu'il s'agisse d'un groupe sans correspondance n'affecte pas le groupe plus grand.

Answer 2

La spécification est pas très claire, mais voici ce que je vais supposer:

• # au début de la ligne est un commentaire
• La « clé » peut avoir jusqu'à 3 parties, séparées par un littéral .
  • La partie centrale est une option « poubelle »
• La « clé » est foll due par =, puis la « valeur »
• . et = sont des marqueurs spéciaux au moins jusqu'à ce que la partie, où alors tout va
• Allow espaces blancs

« valeur » Alors peut-être le motif est quelque chose comme ça fonctionne:

String text = 
     " some.stuff.here = blah blah \n" + 
     " awesome.key = { level = 10 } \n" + 
     "# awesome.key = { level = 11 } \n" + 
     " awesome..key = { level = 12 } \n" + 
     " !@#$.)(*&.$%& = a=b=c.d=f "; 

    Pattern p = Pattern.compile(
     "(?m)^(?!#) (key)@(?:key@)?(key) = (value) $" 
      .replace("@", "\\.") 
      .replace(" ", "\\s*") 
      .replace("key", "[^.=\\s]*") 
      .replace("value", ".*?") 
    ); 

    Matcher m = p.matcher(text); 
    while (m.find()) { 
     System.out.printf("%s.%s => [%s]%n", 
      m.group(1), 
      m.group(2), 
      m.group(3) 
     ); 
    } 

Cette impression:

some.here => [blah blah] 
awesome.key => [{ level = 10 }] 
awesome.key => [{ level = 12 }] 
!@#$.$%& => [a=b=c.d=f] 

Notez l'approche replace pour générer le modèle d'expression régulière final; Il est utilisé pour améliorer la lisibilité de l'image globale "modèle"