Retrait du texte entre parenthèses (parenthèses entre parenthèses prob)

Question

J'essaie de supprimer le texte entre parenthèses (avec les parenthèses elles-mêmes) mais j'ai des problèmes avec le scénario où il y a des parenthèses entre parenthèses. C'est la méthode que je utilise (Ruby):

sentence.gsub(/\(.*?\)/, "") 

et qui fonctionne bien jusqu'à ce que j'ai une phrase telle que:

"This is (a test (string))" 

Ensuite, les bobines d'arrêt ci-dessus. Quelqu'un at-il une idée de comment faire cela? Je suis complètement perplexe.

Answer 1

Un approch est de remplacer les groupes parenthétiques de l'intérieur:

x = string.dup 
while x.gsub!(/\([^()]*\)/,""); end 
x 

Answer 2

On dirait que vous avez besoin d'être gourmand, en enlevant le ?

>> "This is (a test (string))".gsub(/\(.*\)/, "") 
=> "This is " 

Cela fait aller au dernier ) au lieu de la première. Cependant, il ne capture pas l'imbrication, car une regex ne peut pas le faire.

Answer 3

La réponse de jleedev fonctionnera s'il n'y a qu'un seul ensemble de parenthèses au niveau le plus externe; dans ce cas, rendre l'expression des entrailles de ces parenthèses gourmande devrait faire l'affaire.

Cependant, et peut-être un peu surprenant, regExps tel que défini dans Perl, Java, Ruby et quelques autres langues, mais aussi grep et sed ne conviennent pas à faire face à ce problème. Il n'y a pas d'expression rationnelle pour traiter le cas général des délimiteurs imbriqués. C'est une des raisons pour lesquelles les gens de SO vous crient quand vous voulez utiliser une expression rationnelle pour traiter du HTML ou du XML. Il est intéressant de noter que le créateur du langage Lua a résolu ce problème en ajoutant un nouveau motif correspondant au langage de motif par ailleurs plutôt simple. Regardez la poignée inférieure des lignes dans http://www.lua.org/pil/20.2.html!

Answer 4

Le Perl regex suivant va matcher entre parenthèses équilibrées:

/(\((?:[^\(\)]++|(?1))*\))/ 

Cependant, au moment où vous arrivez à ce point, vous n'êtes pas techniquement en utilisant des expressions « réguliers » plus.

Answer 5

Le problème est que les langues contenant des parenthèses imbriquées (ou bien quoi que ce soit imbriqué, quoi que ce soit OIEau qui nécessite la récursivité) ne sont pas réguliers, ils sont au moins sans contexte. Cela signifie qu'ils ne peuvent pas être décrits par une grammaire régulière. Les expressions régulières sont une notation compacte pour les grammaires régulières. Ergo, les parenthèses imbriquées ne peuvent pas être décrites par des expressions régulières.

Cependant, nous ne parlons pas d'expressions régulières ici, nous parlons de Regexp s. Alors que leur sémantique et leur syntaxe sont (très) vaguement basées sur des expressions régulières, elles sont assez différentes et surtout beaucoup plus puissantes. Selon la saveur particulière de Regexp que vous utilisez, ils peuvent ou non être en mesure d'exprimer la récursivité et donc d'analyser les parenthèses imbriquées. Perl Regex, par exemple peut parser des parenthèses imbriquées.Je ne suis pas sûr si le Regexp de Ruby peut, mais je m'en fous vraiment, parce que la façon dont Regexp est plus puissante que les expressions régulières est généralement accomplie en boulonnant de plus en plus de syntaxe sur eux.

Ceci transforme les expressions régulières, conçues pour être simples, en monstres incompréhensibles. (Si vous pouvez dire en un coup d'oeil ce que le Perl Regex posté par @Anon fait, alors allez-y, mais je ne peux pas et donc je préfère ne pas l'utiliser.)

Je préfère utiliser un analyseur plus puissant, plutôt que d'un complexe Regexp.

Dans ce cas, vous disposez d'un langage sans contexte, vous pouvez donc utiliser un analyseur de descente récursif très simple. Vous pouvez encore simplifier votre analyseur de descente récursif en traitant les sous-parties qui sont régulière avec une expression régulière. Enfin, si vous remplacez la récursion dans l'analyseur de descente récursive avec itération + mutation et faire une utilisation intelligente de la sémantique booléennes de Ruby, l'analyseur entier devient essentiellement condensé vers le bas pour cette seule ligne:

while str.gsub!(/\([^()]*?\)/, ''); end 

que je ne pense pas est trop mauvais.

est ici la chose entière avec un certain retrait supplémentaire de double espaces et (bien sûr) une suite de tests:

require 'test/unit' 
class TestParenthesesRemoval < Test::Unit::TestCase 
    def test_that_it_removes_even_deeply_nested_parentheses 
    str = 'This is (was?) some ((heavily) parenthesized (but not overly so 
      (I hope))) text with (superflous) parentheses:)(.' 
    res = 'This is some text with parentheses:)(.' 

    while str.gsub!(/\([^()]*?\)/, ''); end 
    str.squeeze!(' ') 

    assert_equal res, str 
    end 
end