Firstly, please cut and paste your code into your questions here, don't try to retype them as that can create bugs. I assume you retyped your code here as:

$exten=|\.txt|\.doc|\.xml
[download]

doesn't even compile.

Let's assume that you actually have:

$exten = '|\.txt|\.doc|\.xml';
[download]

Then the problem is not with the interpolation of the string in the match operator (as you think), it's actually a problem with your regular expression. See the following (which is based on your code):

my $exten = '|\.txt|\.doc|\.xml';

for (qw(foo.txt foo.csv foo.xml)) {
  print "$_: ";
  print /$exten/ ? "match" : "no match";
  print "\n";
}
[download]

This gives the following output:

foo.txt: match
foo.csv: match
foo.xml: match
[download]

See that everything matches, even foo.csv which looks like it shouldn't match.

Now compare with this:

my $exten = '\.txt|\.doc|\.xml';

for (qw(foo.txt foo.csv foo.xml)) {
  print "$_: ";
  print /$exten/ ? "match" : "no match";
  print "\n";
}
[download]

Which gives this output:

foo.txt: match
foo.csv: no match
foo.xml: match
[download]

The difference is that the first version has a '|' at the start of the regex. And that means that the alternatives will included the empty string. And everything matches the empty string.

So, to summarise, there's nothing wrong with using a variable as a regular expression as you have done, but you need to get the regex right :-)

#!/usr/bin/perl

use strict;
use warnings;

my $extensions = qr/\.doc|\.gif/;

my @files = qw(test.doc test.gif test.png test.jpg);

for(@files){
    if($_ =~ $extensions){
        print "yes\n";
    }
}
[download]

qr// doesn't change the way that the string is interpolated into a regex - it simply precompiles the string into a regex (see the documentation).

Using qr// with the code from the original post won't fix the problem. You have fixed the problem by dropping the spurious '|' from the start of the regex.

--
<http://dave.org.uk>

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

This doesn't really answer your question, but you may want to check out File::Find which addresses this problem space.

I'm not sure what problem you are having with the use of a scalar as a regex -- the following code snippet seems to work for me:

use strict;
use warnings;
my $exten = "(\\\.txt|\\\.csv)";
my @files = ('one.txt', 'two.html', 'three.csv', 'four.log');
foreach (@files) {
  if (/$exten/i) {
    print $_, "\n";
  }
}
[download]

... and the output:

one.txt
three.csv
[download]

Update: I concur with prasadbabu below, in that the judicious use of anchors can help your regex be more faithful to your intentions. Also, as davorg has noted, the main problem with your regex was the leading '|' character (which I assumed was a typo). As you probably know, the pipe character serves the function of 'or' within a regex.

Update 2: Fixed problem with backslashes and case insensitivity, as noted by ikegami. I wasn't sure about the OP's intention, so left out the anchor deliberately.

Your code will also match a file named pretxt.
my $exten = "(\.txt|\.csv)";
should be
my $exten = "(\\\.txt|\\\.csv)";  # (\.txt|\.csv)

There's no reason to force the user to specify the parens.
Why did you remove the case-insensitivity?
You also forgot to anchor the regexp.

use strict;
use warnings;

my $exten = "\\\.txt|\\\.csv";  #  \.txt|\.csv

my @files = qw(
   one.txt two.html three.csv four.log pretxt file.txt~ File.Txt
);

foreach (@files) {
  if (/($exten)\z/i) {
    print $_, "\n";
  }
}
[download]

Update: Or if you want to build $exten:

my @exten = qw( .txt .csv );
my $exten = join('|', map quotemeta, @exten);
[download]

Already reneeb++ and ptum++ has given solutions to solve your problem.

use strict;
use warnings;
my $exten = '(\.txt|\.csv)$';
my @files = ('one.txt.bak', 'two.html', 'three.csv', 'four.log', 'five
+.txt');
foreach (@files) {
  if (/$exten/) {
    print $_, "\n";
  }
}

prints:
three.csv
five.txt
[download]

This won't match 'one.txt.bak'.

updated: added code

Not the way to solve your problem (that would be using File::Find as ptum suggested), but if you find yourself wanting to combine several small, working regexes into a larger, still-working regex, or want to optimize matching several small text snippets, do have a look at grinder's Regexp::Assemble.

grinder has a sample of the module's usage on grinder's scratchpad, and you may also wish to have a look at Why machine-generated solutions will never cease to amaze me.

Purely as an example, say you wanted to optimize the regex in your original question. You might try something like:

use Regexp::Assemble;
[download]

my $ra = Regexp::Assemble->new->add(
    '.txt', 
    '.doc', 
    '.xml'
);
[download]

print $ra->re;
[download]

which prints:

(?-xism:.(?:doc|txt|xml))
[download]

Note that Regexp::Assemble has identified the repeated "." and placed that outside the "or" portion of the regex.

Extending this example to do something (more) useful is left as as exercise for the reader. :-)

HTH,