#!/usr/bin/perl

use strict;
use warnings;

my $path = "/tmp/dir1";
my %filesize = map { $_ => -s } <$path/d1*>;
my @sorted = sort { $filesize{$b} <=> $filesize{$a} } keys %files;

printf "Largest file: %s (%d bytes)\n", $sorted[0], $filesize{$sorted[
+0]};
[download]

#!/usr/bin/perl

use strict;
use warnings;

my $glob_pattern = shift || './*';
my %files;
for ( glob( $glob_pattern )) {
    $files{$_} = -s _ if ( -e );
}
if ( scalar keys %files == 0 ) {
    warn "No files matched $glob_pattern\nUsage: $0  [path/name*]\n";
    exit(1);
}
my @sorted = sort { $files{$b} <=> $files{$a} } keys %files;

printf( "Largest file that matches %s is %s (%d bytes)\n",
        $glob_pattern, $sorted[0], $files{$sorted[0]} );
[download]

show-biggest '/tmp/dir1/d1*'   # note the single quotes
# or:
show-biggest /tmp/dir1/d1\*   # note the backslash escape for "*"
[download]

my @files = <something>;
[download]

my $glob = "something";
my @files = glob( $glob );
[download]

I also learned that glob( $glob_pattern ) does the right thing, where <$glob_pattern> doesn't. (Perl treats the latter as an unopened file handle.)

You could use the core File::Find module and the stat function to scan a directory looking for the file taking up most disk blocks (512 bytes on many file systems though not all). Running the following code in my "Downloads" directory finds that a large CentOS ISO is the guilty culprit.

$ perl -MFile::Find -Mstrict -Mwarnings -E '
my %largest = ( name => q{}, size => 0 );
find( sub {
   my $blocks = ( stat )[ 12 ];
   do {
      $largest{ name } = $File::Find::name;
      $largest{ size } = $blocks;
      } if $blocks > $largest{ size };
   }, q{.}
   );

say qq{$largest{ name } - $largest{ size } blocks};'
CentOS-5.10-x86_64-bin-DVD-1of2.iso - 9125976 blocks
$
[download]

I hope this is helpful.

Update: Substituted $File::Find::name for $_ to store the full path rather than just the file name.

Your subject says that you want to use awk, which your code already does, and it works for me. You haven't indicated what the problem is?

Although you could just use the code you have, I'm guessing your question is how to do this in Perl.

Piece 1: List files with glob (there are other ways, such as readdir or Path::Tiny, but glob is good for simple tasks), e.g. glob('/tmp/dir1/d1*')

Piece 2: Get the size of a file with -s, e.g. -s $filename

Piece 3: Using an array of arrays to hold the filenames and sizes (see also perlreftut)

Piece 4: Sort numerically with sort, e.g. sort {$b<=>$a} @filesizes

Putting it all together:

my @filenames = glob '/tmp/dir1/d1*';

my @files_and_sizes;
for my $filename (@filenames) {
    my $filesize = -s $filename;
    push @files_and_sizes, [$filename, $filesize];
}

use Data::Dumper;                # just for demo & debugging
print Dumper \@files_and_sizes;  # just for demo & debugging

@files_and_sizes = sort { $$b[1] <=> $$a[1] } @files_and_sizes;

print Dumper \@files_and_sizes;  # just for demo & debugging

my $var1 = $files_and_sizes[0][0];

print $var1;
[download]

This could even be dramatically shortened into a one-liner, esp. if you replace the for with map. There are also several other ways to do this, e.g. with modules.

Check and see if File::Util is available to you. I believe it will provide you with what you want if it is available. You can find out by running instmodsh.

Hope that gives you a start...

!/usr/bin/perl
use strict;
use warnings;
use File::Util;
my($f) = File::Util->new();
sub filesize {
      my ( $selfdir, $subdirs, $files, $depth ) = @_;
      print  "$_  " . ( -s $_ ) . "\n" for sort { (-s $a) <=> (-s $b) 
+} @$files;
   }
$f->list_dir( '/tmp/dir1' => { recurse => 0, callback => \&filesize, p
+attern=>'\.pl$' } );
[download]

Update_2Forgot to mention that this code is right from the POD for the File::Util module. It is not mine!

use Path::Tiny qw/ path /;
my @all_files = path( $dir )->realpath->children();
my @done =  map  { $$_[1] }
            sort { $$a[0] <=> $$b[0] }
            map  { [ $_->stat->mtime, $_ ] }
            grep m{d2[^\\/]+$}, @all_files;
my @dtwo =  map  { $$_[1] }
            sort { $$a[0] <=> $$b[0] }
            map  { [ $_->stat->mtime, $_ ] }
            grep m{d1[^\\/]+$}, @all_files;
[download]