Discussion :

[Eric Berger]

Je suis une bille en expressions régulières..... j'ai donc tout naturellement un problème avec ces dernières...

Je parse des fichiers CSV pour splitter sur les séparateurs, or il se trouve que j'ai des séparateurs qui se trouvent entre guillemets et que ceux-ci doivent être ignorés.... et là.... je bloque....

Exemple

Code :

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

aaa,bbb,"cc,c",ddd

devrait donner:

Code :

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

1
2
3
4
aaa
bbb
ccc
ddd

et non:

Code :

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

1
2
3
4
5
aaa
bbb
cc
c
ddd

Je cherche donc une expression régulière qui me permet d'ignorer les virgules si elles sont entre guillemets.

Merci d'avance pour vos réponses.

Eric

[harakatyouness]

J'ai le meme probleme que toi , j'espere que tu as trouve la solution , sinon tu peux me proposer des solution que tu as essaye...

[maa]

Je propose cela :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
            string s = "aaa,bbb,\"cc,c\",ddd"; 
 
            Regex r = new Regex("(((([^,\"]+),?)*)(\")(.*?)(\",)((([^,\"]+),?)*))+");
            GroupCollection gs = r.Match(s).Groups;
 
            var captures = (new List<Group> { gs[4], gs[6], gs[9] })
                           .SelectMany(g => from c in g.Captures.OfType<Capture>() select c);
 
            foreach (var c in captures)
                Console.WriteLine(c.Value);

[StormimOn]

Je n'ai pas réussi avec le Split, alors j'ai essayé de procéder autrement

Code :

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

1
2
3
4
5
6
7
string input = "aaa,\"\",\"\",bbb,,\"cc,c\",\"jjj,j\",ddd";
string pattern = "(\"[^\"]*\"|[^,]*),?";
MatchCollection coll = Regex.Matches(input, pattern);
for (int i = 0; i < coll.Count - 1; i++)
{
    string s = coll[i].Groups[1].Value;
}

Le dernier item de la collection ne correspond à rien, donc j'ai utilisé un for plutôt qu'un foreach.

Si ca peut aider

[maa]

C'est vrai que c'est plus beau comme ça :

Code :

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

1
2
3
4
5
 
string s = "aaa,bbb,\"cc,c\",ddd";
Regex r = new Regex("((\"[^\"]*\"|[^,]*),?)*");
foreach (Capture c in r.Match(s).Groups[2].Captures)
    Console.WriteLine(c.Value);

[SaumonAgile]

J'aurais tendance à trouver celle-là plus jolie :

Code :

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

"((?<token>\".*?\"|[^,]*),?)*"

J'ai préféré utiliser un quantifieur feignant, pour améliorer le traitement des longues chaines.

[ced600]

Je comprend l'intéret des expressions régulière mais c'est super chiant à débuguer pourquoi ne pas faire :

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
 
public string[] Decoupage (string s)
{
	string[] temp = s.Split(',');
	string temp2 = "";
	string temp3 = "";
	for (int i = 0; i < temp.Length; i++)
	{
		if (temp[i].StartsWith("\""))
		{
			temp2 = temp[i].Substring(1,temp[i].Length);
			i++;
			while (!temp[i].EndsWith("\""))
			{
				temp2 = temp2 + temp[i];
				i++;
			}
			temp3 = temp3 + "," + temp2;
			temp2 = "";
		}
		else
		{
			temp3 = temp3 + "," + temp[i];
		}
	}
	return temp3.Split(',');
}

Je trouve cela plus clair

[SaumonAgile]

Je comprend l'intéret des expressions régulière mais c'est super chiant à débuguer pourquoi ne pas faire :

Code :

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

1
2
3
4
5
 
public string[] Decoupage (string s)
{
 
}

Je trouve cela plus clair

ARGGHHH

[StormimOn]

ARGGHHH

Le cri du coeur
C'est vrai que ca pique les yeux quand même

ced600, tu trouves peut être plus clair sans expression régulière parce que tu n'y est pas habitué, parce que finalement c'est beaucoup plus clair avec que sans

[maa]

Je trouve cela plus clair

Il est fou ??

J'aurais tendance à trouver celle-là plus jolie :
Code :

"((?<token>\".*?\"|[^,]*),?)*"

J'ai préféré utiliser un quantifieur feignant, pour améliorer le traitement des longues chaines.

Je ne comprends pas trop ce bout de code : ?<token>
Pourrais-tu me l'expliquer ?

[SaumonAgile]

?<token> donne un nom au groupe contenu entre les parenthèse. Dans ce cas-là, le nom du groupe sera token.

[maa]

ok.

J'ai tenté d'utiliser un quantifieur paresseux pour la seconde alternative, comme ceci :

Code :

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

"((\".*?\"|.*?),?)*"

Mais ça ne fonctionne pas car la virgule n'est pas dans le même groupe.

Je pensais qu'écrire cela :

Code :

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

"((\".*?\"|.*?,{0}),?)*"

pourrais marcher. C'est à dire utiliser la virgule pour permettre l'utilisation du quantifieur paresseux, mais sans la capturer. Mais bon ça ne fonctionne pas...

[ced600]

Je me doutais que cela ferait réagir.
Le problème des expressions régulières, c'est que pour les comprendre vous devez avoir l'habitude de les utiliser, alors que du code c'est quasiment de l'algo.

Je dit juste qu'à mon avis c'est plus simple à comprendre qu'une expression régulière pour quelqu'un qui est :

une bille en expressions régulières

comme notre ami Eric Berger (je pourrais peut être me rajouter dans le lot des billes en expression régulière )

Donc voila j'ai souhaité proposer une alternative, maintenant à lui de voir ce qu'il préfère.

[maa]

Ok, mais tu admettra que quand on a l'habitude des expressions régulières (est l'habitude vient vite) il suffit d'un clins d'oeil pour comprendre ce qui est fait alors qu'avec ton code il faut prendre le temps de lire ces 15 lignes. Pour peu que tu en ait plusieurs comme cela, ton code devient rapidement fastidieux à lire.
En plus, je pense qu'au niveau performance, c'est moins bon avec ta méthode.

[ced600]

Heu je pourrais te dire la même chose avec le code : Quand tu as l'habitude du code tu le lis en un clin d'oeil (si si)
Par contre je suis d'accord avec toi au niveau des performances, les expression régulières torchent mon code.

Mais ne dit on pas :

Rien ne sert de courir, il faut partir à point

Moi je dis mieux vaut un code moins performant, mais maitrisé et fonctionnelle, qu'un code performant, non maitrisé et donc dont on est pas sur s'il est fonctionnelle tout le temps.

[Eric Berger]

Je vois que j'arrive après l'orage....

Désolé, j'ai pas pu me connecter avant...

Du coup je me suis débrouillé avec un traitement en 2 temps, tout dabord un split sur la virgule, puis un merge des champs contenant des guillements (vu qu'elles se retrouvaient coupées par la virgule) c'est pass super-propre, mais ça fonctionne bien.

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
        private List<String> _ParseLine(String line)
        {
 
            Regex regex = new Regex(_separator.ToString());
 
            String[] fieldsArray = regex.Split(line);
 
            List<String> fieldsList = new List<string>();
 
            bool merging = false;
            String mergingString = "";
            foreach (String field in fieldsArray)
            {
                //Post Process for quoted values
                if (field.Contains("\"") || merging)
                {
                    if (!merging)
                    {
                        merging = true;
                        mergingString = field;
                    }
                    else if (field.Contains("\""))
                    {
                        fieldsList.Add(mergingString + _separator + field);
                        merging = false;
                    }
                    else //No quote in field but in merging process
                    {
                        mergingString += _separator + field;
                    }
                }
                else
                {
                    fieldsList.Add(field);
                }
            }
            return fieldsList;
        }

En tout cas merci à tous!

[cinemania]

Que celui qui a osé dire que les Regex c'était pas de l'algo se flagelle en public ...

Si tu avais "subis" des cours de théorie intensive et très poussée tu te rendrais vite compte que les expressions à elles seules sont un language correspondant à de l'algorithmique.

Elles sont basées sur la théorie des langages qui est la base même de l'informatique actuel et des "langages impératifs" tels que tu les connais... (et cela dit meme des "langages fonctionnels")

Et effectivement je préfere de très loin une écriture avec les Regexp. De plus soit dis en passant... Ton algo tu l'écrit en C# qui utilise donc des dll .NET qui sont exécutées par la CLR. Il n'est donc pas écrit en natif.
Le mécanisme des regexp implanté dans System.Text.RegularExpressions est une des meilleurs qui m'ai été donné de voir en terme de performances, surtout pour peu que tu ajoute l'option RegexOptions.Compiled.
Au final, les regexp sont sensiblement plus rapides que ton code.
Le contraire eu été vrai en Perl, mais pas en C#.

Bravo SaumonAgile pour ta regexp ?<token> j'adore

[ced600]

Heu... Je n'ai jamais dit que mon code était plus rapide que les regexp. Je sais qu'elles sont plus rapide. Je disais juste qu'il vaut mieux utiliser une solution que l'on maitrise plutot qu'une que l'on ne maitrise pas. Car dans le premier cas, on pourra la modifier, et dans le deuxième on aura beaucoup de mal à la modifier.
En général je cherche à faire un code propre et qui marche puis ensuite, si j'en ai le temps et le besoin, j'optimise mon code.
Utiliser les méthodes de l'objet string et des boucles pour découper une string, c'est propre et je maitrise mieux.
Dans un deuxième temps utiliser les expressions régulières pour optimiser le code ces bien.
Donc j'ai proposé cette alternative au cas où (et j'ai été un peu provocateur par jeu sur les expressions régulières ).
Et puis une dernière chose, lorsque vous développez une application pour une entreprise, vous ne serez pas forcement celui qui s'occupera de la maintenance de l'application. Donc il faut penser un peu à celui qui va reprendre le code, si vous utilisez du code super compressé et jolie mais difficilement compréhensible votre application sera inmaintenable
Cela me fait penser au C et à ses fonctions de 50 lignes compréssable en 1 ligne incompréhensible

[SaumonAgile]

Utiliser les méthodes de l'objet string et des boucles pour découper une string, c'est propre et je maitrise mieux..

Je pense que tu voulais évidemment écrire :

ce n'est pas propre mais je maitrise mieux

Donc il faut penser un peu à celui qui va reprendre le code

Le nivellement par le haut est toujours la pire solution envisageable. Ce n'est pas parce que certaines personnes ne sauront jamais conduire une voiture correctement qu'il faut en abandonner l'usage pour tous les autres.

[ced600]

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

	

	
Code  :
	
Sélectionner tout -
	Visualiser dans une fenêtre à part
	
123
Citation:
ced600 a écrit :
Utiliser les méthodes de l'objet string et des boucles pour découper une string, c'est propre et je maitrise mieux..
Je pense que tu voulais évidemment écrire :


	

	
Code  :
	
Sélectionner tout -
	Visualiser dans une fenêtre à part
	
12
Citation:
ce n'est pas propre mais je maitrise mieux

En quoi ce ne serais pas propre ? C'est juste plus lent.