it-swarm-tr.com

Du çıktısını boyuta göre nasıl sıralıyorsunuz?

Nasıl sıralıyorsunuz du -sh /dir/* boyuta göre? | sort -n ama bu doğru değil. İşte yanlış olan bir örnek.

[~]# 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

GNU coreutils (çoğu Linux dağıtımında ortaktır) varsa,

du -sh -- * | sort -h

-h seçeneği sort girişinin insan tarafından okunabilir biçim olduğunu söyler (birim içeren sayı; 1024 tabanlı, böylece 1023 değeri 1K'dan az kabul edilir ve bu da GNU du -h yapar).

Bu özellik GNU Çekirdek Yardımcı Programlar 7.5 Ağustos 2009'da eklenmiştir .

Not:

Mac OSX'in daha eski bir sürümünü kullanıyorsanız, coreutils'i brew install coreutils , Sonra gsort 'ın drop-in yerine sort kullanın.

MacOS'un daha yeni sürümleri (Mojave'da doğrulandı) desteği sort -h doğal olarak.

268
Shawn J. Goff

İnsan tarafından okunabilir kullanmak yerine 1K bloklarını saymak için -k bayrağını kullanmayı deneyin. Ardından, ortak bir birime sahipsiniz ve kolayca sayısal bir sıralama yapabilirsiniz.

du -ck | sort -n

Açıkça insan birimlerine ihtiyaç duymazsınız, ama eğer öyleyse, bunu yapmanın bir çok yolu vardır. Birçoğu yukarıdaki 1K blok tekniğini kullanıyor ve sonra du'ya ikinci bir çağrı yapıyor gibi görünüyor.

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

KB birimlerinin eklendiğini görmek istiyorsanız şunu kullanın:

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

Son sürüm GNU coreutils yoksa, sıralanabilir çıktı almak için _-h_ olmadan du numaralı telefonu arayabilirsiniz ve biraz postprocessing ile insan dostu çıktı üretmek du sürümünüzde _-h_ bayrağı olmasa bile çalışma avantajı vardır.

_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}'
_

SI sonekleri istiyorsanız (yani 1024 yerine 1000'in katları), while döngü gövdesinde 1024 değerini 1000 olarak değiştirin. (Bu durumda 1000'in amaçlandığını unutmayın, böylece _1M_ yerine _1000k_ elde edersiniz.)

du cihazınızın boyutları bayt cinsinden görüntüleme seçeneği varsa (örn. _-b_ veya _-B 1_ - bunun disk kullanımı yerine gerçek dosya boyutlarını saymanın yan etkisi olabileceğini unutmayın) s (yani _s=" kMGTEPYZ";_) başına bir boşluk ekleyin veya human işlevinin başına if (x<1000) {return x} else {x/=1024} ekleyin.

1-10 aralığındaki sayılar için ondalık basamağın gösterilmesi okuyucuya alıştırma olarak bırakılır.

Eğer yoksa sort -h Bunu yapabilirsiniz:

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/'

Bu, du listesini alır, soneki ayırır ve bunu kullanarak sıralar. <1K için sonek olmadığından, ilk sed bir B (bayt için) ekler. İkinci sed, rakam ve sonek arasına bir sınırlayıcı ekler. Üçüncü sed, G'den Z'ye dönüştürür, böylece M'den daha büyüktür; terabayt dosyalarınız varsa, G'yi Y'ye ve T'yi Z'ye dönüştürmeniz gerekir. Son olarak, iki sütuna göre sıralarız, ardından G son ekini değiştiririz.

9
Shawn J. Goff

OS X'te, gerekli coreutils'i Homebrew ile yükleyebilirsiniz:

brew install coreutils

Bununla, -h Komut satırı parametresini içeren gsort olacaktır.

6
Roland

Bu küçük Perl betiği hile yapar. duh (veya istediğinizi) olarak kaydedin ve 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

Mac OS X'te -h $ seçeneği sort, bu yüzden ilk denemede sed ve awk öğrendim:

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; }'

uzun bir çizgi. Genişletilmiş, bu:

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; 

}'

Mac OS X Mavericks, Yosemite, Ubuntu 2014-04'te denedim awk varsayılan awk (nawk, çünkü awk ve nawk, /usr/bin/mawk) veya gawk ve hepsi çalıştı.

Mac'teki çıktının bir örneği:

     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

onun yerine du -sk *, @ Stefan'ın cevabında genel toplamın da görüntülendiği yerde ve herhangi bir dosya sistemi bağlama noktasını geçmeden du -skcx *

4
nonopolarity

İşte Ubuntu 10.04, CentOS 5.5, FreeBSD ve Mac OS X'te kullandığım şeyler.

Bu fikri www.geekology.co.za/ ve earthinfo.org ve aynı zamanda rezil ördekler 'den "Linux Server Hacks" den ödünç aldım. "O'Reilly tarafından. Hâlâ ihtiyaçlarıma uyarlıyorum. Bu hala devam eden bir çalışma (olduğu gibi, bu sabah trende bunun üzerinde çalışıyordum.):

#! /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

İşte çıktı:

[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

GNU sort -h Yokluğunda, bunun çoğu UNIX ortamında çalışması gerekir:

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

Bu senaryo ile deliye dön -

$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

Komut:

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

Açıklama:

  • Geçerli dizindeki tüm dosyaların/klasörlerin boyutunu, okunabilir biçimde özyinelemeli olarak listeleme

du -ah .

  • İlk sütunda bulunan okunabilir boyutu sıralayın ve en büyük 50

sort -k1 -h | tail -n 50

0
Rohan Ghige

En büyüğü altta:

du -sh * | sort -h
0
Meskan

Bu, boşluk adlarını veya kesme işaretlerini içeren dosya adlarını işler ve xargs -d veya sort -h:

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

sonuç:

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

Bu, çıktıyı azalan boyut sırasına göre sıralar:

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

Bu, çıktıyı artan boyut sırasına göre sıralar:

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

Not: Bu herhangi bir sütuna göre sıralamak için kullanılabilir, ancak bu sütun değerleri aynı biçimde olmalıdır

0
user5337995

Solaris'te test edildi!

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

Bu, tüm dizin boyutlarını özyinelemeli olarak verir, altta Gigabyte'ın en büyük ve Kilobayt'ın en küçük dizinidir.

0
Chuguniy