it-swarm-ru.tech

Как вы сортируете вывод по размеру?

Как вы сортируете du -sh /dir/* по размеру? Я прочитал один сайт, который сказал использовать | sort -n но это явно не правильно. Вот пример, который не так.

[~]# 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 (обычно в большинстве дистрибутивов Linux)), вы можете использовать

du -sh -- * | sort -h

-h опция сообщает sort, что ввод является читаемым человеком форматом (число с единицей измерения; основано на 1024, так что 1023 считается менее 1 КБ, что соответствует тому, что GNU) du -h делает).

Эта функция была добавлена ​​в GNU Core Utilities 7.5 в августе 2009 г. .

Примечание:

Если вы используете более старую версию Mac OSX, вам нужно установить coreutils с brew install coreutils , Затем используйте gsort в качестве замены sort.

Более новые версии macOS (проверено на Mojave) поддерживают sort -h изначально.

268
Shawn J. Goff

Попробуйте использовать флаг -k для подсчета блоков размером в 1 КБ, понятных человеку. Тогда у вас есть общая единица и вы можете легко выполнить числовую сортировку.

du -ck | sort -n

Вы явно не требуете человеческих юнитов, но если вы это сделали, то есть множество способов сделать это. Многие, кажется, используют вышеописанную технику блока 1K, а затем делают второй вызов du.

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

Если вы хотите увидеть добавленные единицы КБ, используйте:

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

Если у вас нет последняя версия GNU coreutils , вы можете вызвать du без _-h_, чтобы получить сортируемый вывод, и создайте удобный для пользователя вывод с небольшой постобработкой, что дает преимущество в работе, даже если ваша версия du не имеет флага _-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}'
_

Если вам нужны суффиксы SI (то есть, кратные 1000, а не 1024), измените 1024 на 1000 в теле цикла while. (Обратите внимание, что значение 1000 в условии предназначено, поэтому вы получите, например, _1M_ вместо _1000k_.)

Если ваш du имеет возможность отображать размеры в байтах (например, _-b_ или _-B 1_ - обратите внимание, что это может иметь побочный эффект при подсчете фактических размеров файлов, а не использования диска), добавьте пробел в начале s (т. е. _s=" kMGTEPYZ";_) или добавьте if (x<1000) {return x} else {x/=1024} в начале функции human.

Отображение десятичной цифры для чисел в диапазоне 1–10 оставлено читателю в качестве упражнения.

16

Если у вас нет sort -h ты можешь сделать это:

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

Это получает список du, отделяет суффикс и сортирует по нему. Так как для <1K нет суффикса, первый sed добавляет B (для байта). Второй sed добавляет разделитель между цифрой и суффиксом. Третий седь преобразует G в Z, так что он больше, чем M; если у вас есть терабайтные файлы, вам придется конвертировать G в Y и T в Z. Наконец, мы сортируем по двум столбцам, затем заменяем суффикс G.

9
Shawn J. Goff

В OS X вы можете установить необходимые coreutils через Homebrew :

brew install coreutils

С этим у вас будет gsort, который включает в себя -h параметр командной строки.

6
Roland

Этот маленький скрипт на Perl делает свое дело. Сохраните его как duh (или как хотите) и назовите его с помощью 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 не имеет -h опция для sort, поэтому я попробовал и выучил sed и ​​awk для первой попытки:

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

это длинная очередь. Расширено это:

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, где awk является значением по умолчанию awk (то есть nawk, потому что и awk, и nawk указывает на /usr/bin/mawk) или поглазеть, и все они работали.

Вот пример вывода на 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

вместо du -sk *, Я видел в ответе @ Stefan, где также отображается общий итог без обхода точки монтирования файловой системы с помощью du -skcx *

4
nonopolarity

Вот что я использую в Ubuntu 10.04, CentOS 5.5, FreeBSD и Mac OS X.

Я позаимствовал эту идею у www.geekology.co.za/ и earthinfo.org , а также у печально известных ducks у "Linux Server Hacks" "О'Рейли. Я все еще приспосабливаю это к моим потребностям. Это все еще в стадии разработки (как, я работал над этим в поезде этим утром.):

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

Вот вывод:

[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
Stefan Lasiewski

В отсутствие GNU sort -h, это должно работать в большинстве сред 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

Сойти с ума с этим сценарием -

$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

Command:

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

Пояснение:

  • Размер списка всех файлов/папок рекурсивно в текущем каталоге в удобочитаемой форме

du -ah .

  • Сортируйте удобочитаемый размер, который присутствует в первом столбце, и оставьте наибольшее 50

sort -k1 -h | tail -n 50

0
Rohan Ghige

Самое большое внизу:

du -sh * | sort -h
0
Meskan

Он обрабатывает имена файлов с пробелами или апострофами и работает в системах, которые не поддерживают xargs -d или sort -h:

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

что приводит к:

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

Это отсортирует вывод в порядке убывания размера:

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

Это позволит отсортировать вывод в порядке увеличения размера:

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

PS: это может быть использовано для сортировки по любому столбцу, но значения этого столбца должны быть в том же формате

0
user5337995

Проверено на солярисе!

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

Это приведет к рекурсивному выводу всех размеров каталогов, внизу будет самый большой каталог в гигабайтах, а вверху самый маленький в килобайтах.

0
Chuguniy