正则表达式：删除方括号的内容

Question

Is there a regular expression that can be used with search/replace to delete everything occurring within square brackets (and the brackets)?

I've tried \\[.*\\] which chomps extra stuff (eg "[chomps] extra [stuff]" )

Also, the same thing with lazy matching \\[.*?\\] doesn't work when there is a nested bracket (eg "stops [chomping [too] early]!" )

Answer 1

Try something like this:

$text = "stop [chomping [too] early] here!";
$text =~ s/\[([^\[\]]|(?0))*]//g;
print($text);

which will print:

stop  here!

A short explanation:

\[            # match '['
(             # start group 1
  [^\[\]]     #   match any char except '[' and ']'
  |           #   OR
  (?0)        #   recursively match group 0 (the entire pattern!)
)*            # end group 1 and repeat it zero or more times
]             # match ']'

The regex above will get replaced with an empty string.

You can test it online: http://ideone.com/tps8t

EDIT

As @ridgerunner mentioned, you can make the regex more efficiently by making the * and the character class [^\\[\\]] match once or more and make it possessive , and even by making a non capturing group from group 1:

\[(?:[^\[\]]++|(?0))*+]

But a real improvement in speed might only be noticeable when working with large strings (you can test it, of course!).

Answer 2

This is technically not possible with regular expressions because the language you're matching does not meet the definition of "regular". There are some extended regex implementations that can do it anyway using recursive expressions, among them are:

Greta:

http://easyethical.org/opensource/spider/regexp%20c++/greta2.htm#_Toc39890907

and

PCRE

http://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions

See "Recursive Patterns", which has an example for parentheses.

A PCRE recursive bracket match would look like this:

\[(?R)*\]

edit:

Since you added that you're using Perl, here's a page that explicitly describes how to match balanced pairs of operators in Perl:

http://perldoc.perl.org/perlfaq6.html#Can-I-use-Perl-regular-expressions-to-match-balanced-text%3f

Something like:

$string =~ m/(\[(?:[^\[\]]++|(?1))*\])/xg;

Answer 3

Since you're using Perl, you can use modules from the CPAN and not have to write your own regular expressions. Check out the Text::Balanced module that allows you to extract text from balanced delimiters. Using this module means that if your delimiters suddenly change to {} , you don't have to figure out how to modify a hairy regular expression, you only have to change the delimiter parameter in one function call.

Answer 4

If you are only concerned with deleting the contents and not capturing them to use elsewhere you can use a repeated removal from the inside of the nested groups to the outside.

my $string = "stops [chomping [too] early]!";
# remove any [...] sequence that doesn't contain a [...] inside it
# and keep doing it until there are no [...] sequences to remove
1 while $string =~ s/\[[^\[\]]*\]//g; 
print $string;

The 1 while will basically do nothing while the condition is true. If a s/// matches and removes a bracketed section the loop is repeated and the s/// is run again.

This will work even if your using an older version of Perl or another language that doesn't support the (?0) recursion extended pattern in Bart Kiers's answer.

Answer 5

You want to remove only things between the []s that aren't []s themselves. IE:

\[[^\]]*\]

Which is a pretty hairy mess of []s ;-)

It won't handle multiple nested []s though. IE, matching [foo[bar]baz] won't work.