Discussion :

[Mehdi Feki]

Salut ,
Je comprends plus rien, quand je vous ai demandé ce que vous entendez dire par chaine minimale vous avez repondu :

Utilisée par exemple avec la chaine

...)(myValue = (myFunction(myParameter,myVar)* myConst))(...

et les délimitateur "(" et ")", j'obtiens bien

myValue = (myFunction(myParameter,myVar)* myConst)
myFunction(myParameter,myVar)* myConst
myParameter,myVar

Mais votre solution retourne la derniere chaine à partir de gauche entre les delimtateurs, c'est bien ca ??

A part ca le pattern à l'air (sans doute ) bien formulé

[neguib]

Salut ,
Je comprends plus rien, quand je vous ai demandé ce que vous entendez dire par chaine minimale vous avez repondu :



Mais votre solution retourne la derniere chaine à partir de gauche entre les delimtateurs, c'est bien ca ??

A part ca le pattern à l'air (sans doute ) bien formulé

Oui suis_je bête je t'ai mis le resultat d'un autre test qui m'avait mis sur la voie des groupes imbriqués donc j'obtiens bien

myParameter,myVar

donc nous avons également la méthode qui retrouve tous les groupes imbriqués dont tu a vu le resultat anticipé et cela en une seule passe. En même temps toujours pas de différence significative en terme de performance. Pour ce qui est des groupes non imbriqués StormiOn a trouv le pattern pour retrouver les groupes minimaux mais nous planchons sur les groupes englobant qui reste encore introuveble via regexp. On s'accroche

[Mehdi Feki]

je t'ai mis le resultat d'un autre test qui m'avait mis sur la voie des groupes imbriqués

Ah ok vous me rassurez

Pour obtenir les groupes minimaux, j'ai utilisé ce pattern
Biensure à remplacer "\(" par borne inf et "\)" par borne Sup

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 MatchCollection mc = Regex.Matches(InputString, @"\((?<mot>[^\)\(]*)\)");
            for (int i = 0; i < mc.Count; i++)
            {
                Console.WriteLine(mc[i].Groups["mot"].Value);
            }

PS: Je viens de verifier avant de poster et apparament c'est le meme pattern que vous utiliser avec moins de groupe et sans les .*

Edit :

mais nous planchons sur les groupes englobant qui reste encore introuveble via regexp

Bon courage mais franchement je ne crois pas que c'est possible, parce que une fois que le RegExp a trouvé le premier groupe englobant, il le classe comme solution et ne l'utilise plus pour verifier s'il y a un groupe dedans, donc il faut trouver un moyen d'utiliser une recursivité avev la RegExp,

J'ai trouvé un article qui parle de la recursivité des RegEcp en Perl , mais j'ai pas encore testé en Dot Net :

Regexp Power

[StormimOn]

Bon courage mais franchement je ne crois pas que c'est possible, parce que une fois que le RegExp a trouvé le premier groupe englobant, il le classe comme solution et ne l'utilise plus pour verifier s'il y a un groupe dedans

C'est le problème en effet, je ne pense pas que les expressions régulières soient la solution si l'on souhaite obtenir tous les groupes, sans exceptions, se trouvant entre les délimiteurs. Pour les groupes "minimaux" voici la version finale

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
Sub Main()
    Dim results As String() = Test.ExtraireChaineMinCompiled("myValue = _
            myFunction(myParameter,myVar)*(myConst)", "(", ")")
End Sub
 
Public Class Test
    Public Shared Function ExtraireChaineMinCompiled( _
      ByVal chaine As String, ByVal borneDepart As String, _
      ByVal borneFin As String) As String()
        borneDepart = PreparerChaine(borneDepart)
        borneFin = PreparerChaine(borneFin)
 
        Dim pattern As New StringBuilder(borneDepart)
        pattern.Append("(?<output>[^")
        pattern.Append(borneDepart)
        pattern.Append(borneFin)
        pattern.Append("]*)")
        pattern.Append(borneFin)
        Dim matchColl As MatchCollection = _
  New Regex(pattern.ToString(), RegexOptions.Compiled And _
  RegexOptions.ExplicitCapture).Matches(chaine)
        If (matchColl.Count > 0) Then
            Dim tabString(matchColl.Count - 1) As String
            Dim i As Integer = 0
            While i < matchColl.Count
                tabString(i) = matchColl(i).Groups("output").Value
                i += 1
            End While
            Return tabString
        Else
            Return Nothing
        End If
    End Function
 
    Private Shared ReadOnly CaracteresSpecifiques() As Char = _
        {"("c, ")"c, "["c, "]"c, "."c, "^"c, "$"c, "*"c, "?"c, "+"c}
 
    Private Shared Function PreparerChaine(ByVal chaine As String) As _
    String
        If Array.IndexOf(CaracteresSpecifiques, CChar(chaine)) > -1 Then
            Dim sb As New StringBuilder("(\")
            sb.Append(chaine)
            sb.Append(")")
            Return sb.ToString()
        End If
        Return chaine
    End Function
End Class

[Mehdi Feki]

J'utilise les groupes parce que ca me permet d'obtenir exactement la chaine dont j'ai besoin, ca m'eviterais les differents Replace, mais bon chacun a son point de vue, l'essentiel est qu'on a compris les limites des RegExps

Edit : Oops désolé je n'ai pas vu l'edit