Instead of doing the work yourself, use a module:

use File::Glob 'bsd_glob';

my @files= bsd_glob $dir;

print "$_\n" for @files;
[download]

* means one thing in filename wildcards and another in regexes. It does work in glob().

use Cwd;
my $dir = getcwd;
opendir DIR, $dir;
my $filter = shift;

$qfilter = quotemeta $filter;
$qfilter =~ s/\\\*/.*/;
$qfilter = qr($qfilter);
my @regfiles = grep { -f ; /$qfilter/ } readdir DIR;

seekdir DIR,0;
@globfiles = glob($filter);
closedir DIR;

print "$_\n" for @regfiles;
print "\n";
print "$_\n" for globfiles;
[download]

If you are only performing simple, ad hoc tasks then this is one of those great times when you can get away with writing on-the-fly one-liners. Let's say you wanted to do something like rename the files so that spaces are converted into underscores. You can incrementally change the one-liner to ensure you are changing the right things:

$ touch data/{1..5}\ with\ spaces.dat
$ perl -le'for(<data/*.dat>){print}'
$ perl -le'for(<data/*.dat>){$o=$_;tr/ /_/;print}'
$ perl -le'for(<data/*.dat>){$o=$_;tr/ /_/;rename $o,$_}'
[download]

I realize you are not using Unix, but the only function of the 1st command is to create some files that have spaces in their names. The 2nd command shows you the files you are going to change. The 3rd command shows you what their new names are going to be. The final command does the actual work. I use this kind of technique almost daily.

If you want to write production code, best to use the built in glob function instead of the <.. > construct. (See Perl::Critic::Policy::BuiltinFunctions::RequireGlobFunction.)

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

I use this kind of technique almost daily.

Heh. Me too. In fact, one of the first things I did when I started using Perl 20 years ago (seems like only yesterday - how time flies!) was to write a script that made this easier, and it quickly grew to do any manner of command-line stuff where I needed any sort of substitution to make an "output" name from an "input" name: shloop -- execute shell command on a list.

Here's how I eliminate those pesky spaces from file names:

ls | grep " " | shloop -e rename -s 'tr: :_:'
[download]

(Of course, there's a "-n" option for "no-op", to just print what would happen without actually doing it.)

It does get tricky when a directory has spaces in its name, and it also contains files with spaces in their names - renaming has to be done just one level at a time.

Path::Tiny is a very good interface to readedir, very good substitute for glob

use Path::Tiny qw/ path cwd /;
my $dir = cwd(); 
my( $first ) = @ARGV;
# my @prfiles = grep { $_ eq $first } path( $dir )->children;
my @prfiles = path('.')->children( qr/\Q$first\E/ );
[download]

File::Find::Rule is the next step up

use File::Find::Rule qw/ find rule /;
my( $first ) = @ARGV;
my @prfiles = find(file => name => $first, maxdepth => 1, in => '.');
[download]

'.' is common name for cwd :)

Now you know :)

Yeah  qr/\Q$first\E/ can just be $first as Path::Tiny uses Text::Glob#glob_to_regex

#!/usr/bin/perl

$folder = 'C:';
$input = $ARGV[0];

@array = `dir /b ${folder}\\${input}`;

foreach (@array) {
    print "$_";
}
[download]

Example script.pl *.txt C: would seach the C:\ directory for anything ending in .txt