it-swarm-id.com

Bagaimana Anda mengurutkan du output berdasarkan ukuran?

Bagaimana Anda menyortir du -sh /dir/* berdasarkan ukuran? Saya membaca satu situs yang mengatakan gunakan | sort -n tapi itu jelas tidak benar. Berikut ini contoh yang salah.

[~]# du -sh /var/* | sort -n
0       /var/mail
1.2M    /var/www
1.8M    /var/tmp
1.9G    /var/named
2.9M    /var/run
4.1G    /var/log
8.0K    /var/account
8.0K    /var/crash
8.0K    /var/cvs
8.0K    /var/games
8.0K    /var/local
8.0K    /var/nis
8.0K    /var/opt
8.0K    /var/preserve
8.0K    /var/racoon
12K     /var/aquota.user
12K     /var/portsentry
16K     /var/ftp
16K     /var/quota.user
20K     /var/yp
24K     /var/db
28K     /var/empty
32K     /var/lock
84K     /var/profiles
224M    /var/netenberg
235M    /var/cpanel
245M    /var/cache
620M    /var/lib
748K    /var/spool
209
xenoterracide

Jika Anda memiliki GNU coreutils (umum di sebagian besar distribusi Linux), Anda dapat menggunakan

du -sh -- * | sort -h

-h pilihan memberi tahu sort bahwa input adalah format yang dapat dibaca manusia (angka dengan unit; berbasis 1024 sehingga 1023 dianggap kurang dari 1K yang terjadi sesuai dengan apa yang GNU du -h tidak).

Fitur ini ditambahkan ke GNU Core Utilities 7.5 pada Agustus 2009 .

Catatan:

Jika Anda menggunakan versi Mac OSX yang lebih lama, Anda harus menginstal coreutils dengan brew install coreutils , Lalu gunakan gsort sebagai pengganti drop-in dari sort.

Dukungan MacOS versi terbaru (diverifikasi di Mojave) sort -h secara asli.

268
Shawn J. Goff

Coba gunakan flag -k untuk menghitung 1K blok sebelum menggunakan yang dapat dibaca manusia. Kemudian, Anda memiliki unit umum dan dapat dengan mudah melakukan pengurutan angka.

du -ck | sort -n

Anda tidak secara eksplisit membutuhkan unit manusia, tetapi jika Anda melakukannya, maka ada banyak cara untuk melakukannya. Banyak yang tampaknya menggunakan teknik blok 1K di atas, dan kemudian melakukan panggilan kedua ke du.

https://serverfault.com/questions/62411/how-can-i-sort-du-h-output-by-size

Jika Anda ingin melihat unit KB ditambahkan, gunakan:

du -k | sed -e 's_^\([0-9]*\)_\1 KB_' | sort -n
49
pboin

Jika Anda tidak memiliki versi terbaru dari GNU coreutils , Anda dapat memanggil du tanpa -h Untuk mendapatkan output yang dapat diurutkan, dan menghasilkan keluaran yang ramah manusia dengan sedikit postprocessing. Ini memiliki keuntungan bekerja bahkan jika versi du Anda tidak memiliki bendera -h.

du -k | sort -n | awk '
    function human(x) {
        if (x<1000) {return x} else {x/=1024}
        s="kMGTEPZY";
        while (x>=1000 && length(s)>1)
            {x/=1024; s=substr(s,2)}
        return int(x+0.5) substr(s,1,1)
    }
    {gsub(/^[0-9]+/, human($1)); print}'

Jika Anda ingin sufiks SI (mis. Kelipatan 1000 daripada 1024), ubah 1024 menjadi 1000 dalam tubuh loop while. (Perhatikan bahwa 1000 dalam kondisi ini dimaksudkan, sehingga Anda mendapatkan mis. 1M Daripada 1000k.)

Jika du Anda memiliki opsi untuk menampilkan ukuran dalam byte (mis. -b Atau -B 1 - perhatikan bahwa ini mungkin memiliki efek samping menghitung ukuran file aktual daripada penggunaan disk) , tambahkan spasi ke awal s (yaitu s=" kMGTEPYZ";), atau tambahkan if (x<1000) {return x} else {x/=1024} pada awal fungsi human.

Menampilkan angka desimal untuk angka dalam kisaran 1–10 dibiarkan sebagai latihan bagi pembaca.

Jika Anda tidak memiliki sort -h kamu bisa melakukan ini:

du -sh * | sed 's/\([[:digit:]]\)\t/\1B\t/' | sed 's/\(.\t\)/\t\1/' | sed 's/G\t/Z\t/' | sort -n -k 2d,2 -k 1n,1 | sed 's/Z\t/G\t/'

Ini mendapatkan daftar du, memisahkan akhiran, dan mengurutkan menggunakan itu. Karena tidak ada akhiran untuk <1K, sed pertama menambahkan B (untuk byte). Sed kedua menambahkan pembatas antara digit dan sufiks. Sed ketiga mengkonversi G ke Z sehingga lebih besar dari M; jika Anda memiliki file terabyte, Anda harus mengonversi G ke Y dan T ke Z. Akhirnya, kami mengurutkan berdasarkan dua kolom, lalu kami mengganti akhiran G.

9
Shawn J. Goff

Pada OS X, Anda dapat menginstal coreutils yang dibutuhkan melalui Homebrew :

brew install coreutils

Dengan ini Anda akan memiliki gsort, yang mencakup -h parameter baris perintah.

6
Roland

Script Perl kecil ini berhasil. Simpan sebagai duh (atau apa pun yang Anda inginkan) dan sebut dengan duh /dir/*

#!/usr/bin/Perl -w
use strict;

my @line;

sub to_human_readable {
        my ($number) = @_;
        my @postfix = qw( k M G T P );
        my $post;
        my $divide = 1;
        foreach (@postfix) {
                $post = $_;
                last if (($number / ($divide * 1024)) < 1);
                $divide = $divide * 1024;
        }
        $number = int($number/$divide + 0.5);
        return $number . $post;
}

sub trimlengthright {
        my ($txt, $len) = @_;
        if ( length($txt) >= $len ) {
                $txt = substr($txt,0,$len - 1) . " ";
        } else {
                $txt = $txt . " " x ($len - length($txt));
        }
        return $txt;
}

sub trimlengthleft {
        my ($txt, $len) = @_;
        if ( length($txt) >= $len ) {
                $txt = substr($txt,0,$len - 1) . " ";
        } else {
                $txt = " " x ($len - length($txt)) . $txt;
        }
        return $txt;
}

open(DF,"du -ks @ARGV | sort -n |");
while (<DF>) {
        @line = split;
        print &trimlengthleft(&to_human_readable($line[0]),5)," "; # size
        print &trimlengthright($line[1],70),"\n"; # directory
}
close DF;
4
ddeimeke

Karena Mac OS X tidak memiliki -h pilihan untuk sort, jadi saya mencoba dan mempelajari sed dan awk untuk percobaan pertama:

du -sk * | sort -g | awk '{ numBytes = $1 * 1024; numUnits = split("B K M G T P", unit); num = numBytes; iUnit = 0; while(num >= 1024 && iUnit + 1 < numUnits) { num = num / 1024; iUnit++; } $1 = sprintf( ((num == 0) ? "%6d%s " : "%6.1f%s "), num, unit[iUnit + 1]); print $0; }'

itu adalah garis panjang. Diperluas, yaitu:

du -sk * | sort -g | awk '{ 

    numBytes = $1 * 1024; 
    numUnits = split("B K M G T P", unit); 
    num = numBytes; 
    iUnit = 0; 

    while(num >= 1024 && iUnit + 1 < numUnits) { 
        num = num / 1024; 
        iUnit++; 
    } 

    $1 = sprintf( ((num == 0) ? "%6d%s " : "%6.1f%s "), num, unit[iUnit + 1]);
    print $0; 

}'

Saya mencobanya di Mac OS X Mavericks, Yosemite, Ubuntu 2014-04 dengan awk menjadi default awk (yaitu nawk, karena keduanya awk dan nawk arahkan ke /usr/bin/mawk) atau melongo, dan mereka semua bekerja.

Berikut adalah contoh dari output pada Mac:

     0B  bar
     0B  foo
   4.0K  wah
  43.0M  Documents
   1.2G  Music
   2.5G  Desktop
   4.7G  Movies
   5.6G  VirtualBox VMs
   9.0G  Dropbox
  11.7G  Library
  21.2G  Pictures
  27.0G  Downloads

dari pada du -sk *, Saya melihat jawaban @ Stefan di mana total keseluruhan juga ditampilkan, dan tanpa melintasi titik mount sistem file apa pun, dengan menggunakan du -skcx *

4
nonopolarity

Inilah yang saya gunakan di Ubuntu 10.04, CentOS 5.5, FreeBSD dan Mac OS X.

Saya meminjam ide dari www.geekology.co.za/ dan earthinfo.org , dan juga yang terkenal bebek dari "Linux Server Hacks "oleh O'Reilly. Saya masih menyesuaikannya dengan kebutuhan saya. Ini masih dalam proses (Seperti, saya sedang mengerjakan ini di kereta pagi ini.):

#! /usr/bin/env bash
ducks () {
    du -cks -x | sort -n | while read size fname; do
        for unit in k M G T P E Z Y; do
            if [ $size -lt 1024 ]; then
                echo -e "${size}${unit}\t${fname}"
                break
            fi
            size=$((size/1024))
        done
    done
}
ducks > .ducks && tail .ducks

Inilah hasilnya:

[email protected]:~ $ ducks
32M src
42M .cpan
43M .macports
754M    doc
865M    Work
1G  .Trash
4G  Library
17G Downloads
30G Documents
56G total

[email protected]:~ $
1

Dengan tidak adanya GNU sort -h, ini seharusnya berfungsi di sebagian besar lingkungan UNIX:

join -1 2 -2 2 <(du -sk /dir/* 2>/dev/null | sort -k2,2) <(du -sh /dir/* 2>/dev/null | sort -k2,2) | sort -nk2,2 | awk '{ print $3 "\t" $1 }'
1
friedl.otto

Gila dengan skrip ini -

$du -k ./* | 
> sort -nr |
> awk '
> {split("KB,MB,GB",size,",");}
> {x = 1;while ($1 >= 1024) {$1 = $1 / 1024;x = x + 1} $1 = sprintf("%-4.2f%s", $1, size[x]); print $0;}'
1
jaypal singh

Perintah:

du -ah . | sort -k1 -h | tail -n 50

Penjelasan:

  • Daftar ukuran semua file/folder secara rekursif dalam direktori saat ini dalam bentuk yang dapat dibaca manusia

du -ah .

  • Urutkan ukuran yang bisa dibaca manusia yang ada di kolom pertama dan pertahankan yang terbesar 50

sort -k1 -h | tail -n 50

0
Rohan Ghige

Yang terbesar ada di bawah:

du -sh * | sort -h
0
Meskan

Yang ini menangani nama file dengan spasi putih atau apostrof, dan bekerja pada sistem yang tidak mendukung xargs -d atau sort -h:

du -s * | sort -n | cut -f2 | tr '\n' '\0' | xargs -0 -I {} du -sh "{}"

yang mengakibatkan:

368K    diskmanagementd
392K    racoon
468K    coreaudiod
472K    securityd
660K    sshd
3.6M    php-fpm
0
Mark Crossfield

Ini akan mengurutkan output dengan mengurangi urutan ukuran:

du -sh /var/* | sort -k 1rn

Ini akan mengurutkan output dalam urutan ukuran yang meningkat:

du -sh /var/* | sort -k 1n

PS: ini dapat digunakan untuk mengurutkan berdasarkan kolom mana pun tetapi nilai kolom itu harus dalam format yang sama

0
user5337995

Diuji pada Solaris!

du -kh | sort -nk1 | grep [0-9]K && du -kh | sort -nk1 | grep [0-9]M && du -kh | sort -nk1 | grep [0-9]G

Ini akan menampilkan semua ukuran direktori secara rekursif, di bagian bawah akan menjadi direktori terbesar dalam Gigabytes dan di bagian atas terkecil di Kilobyte.

0
Chuguniy