Styjun

Another perl one, that displays total sizes sorted by user:

#!/usr/bin/perl
use warnings;
use strict;
use autodie;
use feature qw/say/;
use File::Spec;
use Fcntl qw/:mode/;

my $dir = shift;
my %users;

opendir(my $d, $dir);
while (my $file = readdir $d) 
 my $filename = File::Spec->catfile($dir, $file);
 my ($mode, $uid, $size) = (stat $filename)[2, 4, 7];
 $users$uid += $size if S_ISREG($mode);

closedir $d;

my @sizes = sort $a->[0] cmp $b->[0] 
 map [ getpwuid($_) // $_, $users$_ ] keys %users;
local $, = "t";
say @$_ for @sizes;

Parsing output from ls - bad idea.

How about using find instead?

• start in directory $dir
  
  
  • limit to that directory level (-maxdepth 1)
  
  
  • limit to files (-type f)
  
  
  • print a line with user name and file size in bytes (-printf "%u %sn")
  
  


• run the results through a perl filter
  
  
  • split each line (-a)
  
  
  • add to a hash under key (field 0) the size (field 1)
  
  
  • at the end (END ...) print out the hash contents, sorted by key, i.e. user name
  
  

$ find $dir -maxdepth 1 -type f -printf "%u %sn" | 
 perl -ane '$s$F[0] += $F[1]; END print "$_ $s$_n" foreach (sort keys %s); '
stefanb 263305714

A solution using Perl:

#!/usr/bin/perl
use strict;
use warnings;
use autodie;

use File::Spec;

my %users;
foreach my $dir (@ARGV) 
 opendir(my $dh, $dir);

 # files in this directory
 while (my $entry = readdir($dh)) 
 my $file = File::Spec->catfile($dir, $entry);

 # only files
 if (-f $file) 
 my($uid, $size) = (stat($file))[4, 7];
 $users$uid += $size
 
 

 closedir($dh);


print "$_ $users$_n" foreach (sort keys %users);

exit 0;

Test run:

$ perl dummy.pl .
1000 263618544

Interesting difference. The Perl solution discovers 3 more files in my test directory than the find solution. I have to ponder why that is...

Not sure why question is tagged perl when awk is being used.

Here's a simple perl version:

#!/usr/bin/perl

chdir($ARGV[0]) or die("Usage: $0 dirn");

map 
 if ( ! m/^[.][.]?$/o ) 
 ($s,$u) = (stat)[7,4];
 $h$u += $s;
 
 glob ".* *";

map 
 $s = $h$_;
 $u = !( $s >>10) ? ""
 : !(($s>>=10)>>10) ? "k"
 : !(($s>>=10)>>10) ? "M"
 : !(($s>>=10)>>10) ? "G"
 : ($s>>=10) ? "T"
 : undef
 ;
 printf "%-8s %12dt%sn", $s.$u, $h$_, getpwuid($_)//$_;
 keys %h;

• 
  glob gets our file list


• 
  m// discards . and ..
  


• 
  stat the size and uid


• accumulate sizes in %h
  


• compute the unit by bitshifting (>>10 is integer divide by 1024)


• map uid to username (// provides fallback)


• print results (unsorted)


• 
  NOTE: unlike some other answers, this code doesn't recurse into subdirectories

To exclude symlinks, subdirectories, etc, change the if to appropriate -X tests. (eg. (-f $_), (!-d $_ and !-l $_), etc). See perl docs on the _ filehandle optimisation for caching stat results.

Did I see some awk in the op? Here is one in GNU awk using filefuncs extension:

$ cat bar.awk
@load "filefuncs"
BEGIN 
 FS=":" # passwd field sep
 passwd="/etc/passwd" # get usernames from passwd
 while ((getline < passwd)>0)
 users[$3]=$1
 close(passwd) # close passwd

 if(path="") # set path with -v path=...
 path="." # default path is cwd
 pathlist[1]=path # path from the command line
 # you could have several paths
 fts(pathlist,FTS_PHYSICAL,filedata) # dont mind links (vs. FTS_LOGICAL)
 for(p in filedata) # p for paths
 for(f in filedata[p]) # f for files
 if(filedata[p][f]["stat"]["type"]=="file") # mind files only
 size[filedata[p][f]["stat"]["uid"]]+=filedata[p][f]["stat"]["size"]
 for(i in size)
 print (users[i]?users[i]:i),size[i] # print username if found else uid
 exit

Sample outputs:

$ ls -l
total 3623
drwxr-xr-x 2 james james 3690496 Mar 21 21:32 100kfiles/
-rw-r--r-- 1 root root 4 Mar 21 18:52 bar
-rw-r--r-- 1 james james 424 Mar 21 21:33 bar.awk
-rw-r--r-- 1 james james 546 Mar 21 21:19 bar.awk~
-rw-r--r-- 1 james james 315 Mar 21 19:14 foo.awk
-rw-r--r-- 1 james james 125 Mar 21 18:53 foo.awk~
$ awk -v path=. -f bar.awk
root 4
james 1410

Another:

$ time awk -v path=100kfiles -f bar.awk
root 4
james 342439926

real 0m1.289s
user 0m0.852s
sys 0m0.440s

Yet another test with a million empty files:

$ time awk -v path=../million_files -f bar.awk

real 0m5.057s
user 0m4.000s
sys 0m1.056s

Using datamash (and Stefan Becker's find code):

find $dir -maxdepth 1 -type f -printf "%ut%sn" | datamash -sg 1 sum 2