Regex pour supprimer les commentaires de ligne de C #

Vos deux expressions régulières (pour les commentaires de bloc et de ligne) ont des bogues. Si vous voulez, je peux décrire les bugs, mais je pense que c’est peut-être plus productif si j’en écris de nouveaux, surtout parce que j’ai l’intention d’écrire un seul qui corresponde aux deux.

La chose est, chaque fois que vous avez /* et // et les chaînes littérales «interférer» les uns avec les autres, c’est toujours celui qui commence en premier qui a la priorité. C’est très pratique car c’est exactement ainsi que fonctionnent les expressions régulières: recherchez d’abord la première correspondance.

Définissons donc une expression régulière qui correspond à chacun de ces quatre jetons:

 var blockComments = @"/\*(.*?)\*/"; var lineComments = @"//(.*?)\r?\n"; var ssortingngs = @"""((\\[^\n]|[^""\n])*)"""; var verbatimSsortingngs = @"@(""[^""]*"")+"; 

Pour répondre à la question dans le titre (commentaires de bandes), il faut:

• Remplacer les commentaires du bloc par rien
• Remplacer les commentaires de ligne par une nouvelle ligne (parce que l’expression régulière mange la nouvelle ligne)
• Gardez les chaînes littérales où elles sont.

Regex.Replace peut le faire facilement en utilisant une fonction MatchEvaluator:

 ssortingng noComments = Regex.Replace(input, blockComments + "|" + lineComments + "|" + ssortingngs + "|" + verbatimSsortingngs, me => { if (me.Value.StartsWith("/*") || me.Value.StartsWith("//")) return me.Value.StartsWith("//") ? Environment.NewLine : ""; // Keep the literal ssortingngs return me.Value; }, RegexOptions.Singleline); 

J’ai exécuté ce code sur tous les exemples fournis par Holystream et sur divers autres cas auxquels je pouvais penser, et cela fonctionne comme un charme. Si vous pouvez fournir un exemple où il échoue, je suis heureux d’ajuster le code pour vous.

Avant de l’implémenter, vous devrez d’abord créer des scénarios de test.

1. Commentaires simples / * * /, //, ///
2. Commentaires sur plusieurs lignes / * This \ nis \ na \ ntest * /
3. Commentaires après la ligne de code var a = “apple”; // test ou / * test * /
4. Commentaires dans les commentaires / * Ceci // est un test /, ou // Ceci / est un test * /
5. Des commentaires simples qui ressemblent à des commentaires et apparaissent entre guillemets var comment = “/ * Ceci est un test * /” ou var url = ” http://stackoverflow.com “;
6. Les non-commentaires complexes ressemblent à des commentaires: var abc = @ “this / * \ n est un commentaire entre guillemets \ n * /”, avec ou sans espaces entre “et / * ou * / et”

Il y a probablement plus de cas là-bas.

Une fois que vous les avez tous, vous pouvez créer une règle d’parsing pour chacun d’eux ou en regrouper certains.

Résoudre cela avec une expression régulière seule sera probablement très difficile et sujette à erreur, difficile à tester et difficile à maintenir par vous et les autres programmeurs.

Vous pouvez numéroter le code avec une expression comme:

 @(?:"[^"]*")+|"(?:[^"\n\\]+|\\.)*"|'(?:[^'\n\\]+|\\.)*'|//.*|/\*(?s:.*?)\*/ 

Cela correspondrait également à certaines structures / échappements non valides (par exemple, 'foo' ), mais correspondrait probablement à tous les jetons d’intérêt (sauf si j’ai oublié quelque chose), ce qui fonctionne bien pour un code valide.

En l’utilisant dans un remplacement et en capturant les pièces que vous souhaitez conserver, vous obtiendrez le résultat souhaité. C’est à dire:

 static ssortingng SsortingpComments(ssortingng code) { var re = @"(@(?:""[^""]*"")+|""(?:[^""\n\\]+|\\.)*""|'(?:[^'\n\\]+|\\.)*')|//.*|/\*(?s:.*?)\*/"; return Regex.Replace(code, re, "$1"); } 

Exemple d’application :

 using System; using System.Text.RegularExpressions; namespace Regex01 { class Program { static ssortingng SsortingpComments(ssortingng code) { var re = @"(@(?:""[^""]*"")+|""(?:[^""\n\\]+|\\.)*""|'(?:[^'\n\\]+|\\.)*')|//.*|/\*(?s:.*?)\*/"; return Regex.Replace(code, re, "$1"); } static void Main(ssortingng[] args) { var input = "hello /* world */ oh \" '\\\" // ha/*i*/\" and // bai"; Console.WriteLine(input); var noComments = SsortingpComments(input); Console.WriteLine(noComments); } } } 

Sortie:

 hello /* world */ oh " '\" // ha/*i*/" and // bai hello oh " '\" // ha/*i*/" and 

J’ai trouvé celui-ci sur http://gskinner.com/RegExr/ (nommé “.Net Comments aspx”)

 (//[\t|\s|\w|\d|\.]*[\r\n|\n])|([\s|\t]*/\*[\t|\s|\w|\W|\d|\.|\r|\n]*\*/)|(\<[!%][ \r\n\t]*(--([^\-]|[\r\n]|-[^\-])*--[ \r\n\t%]*)\>) 

Lorsque je le teste, il semble supprimer tous les // commentaires et / * commentaires * / comme il se doit, laissant ces guillemets derrière.

Je ne l’ai pas beaucoup testé, mais semble fonctionner plutôt bien (même si c’est une ligne de regex horrible et monstrueuse).

Voir aussi mon projet de minification du code C #: CSharp-Minifier

En dehors de la suppression des commentaires, des espaces et des sauts de ligne du code, il est actuellement capable de compresser les noms de variables locales et d’effectuer d’autres minifications.

pour bloc Commentaires (/ * … * /) vous pouvez utiliser cette exp:

/\*([^\*/])*\*/

cela fonctionnera aussi avec des commentaires multilignes.