Как я могу отсортировать du-h произведенный размером

du | sort -nr | cut -f2- | xargs du -hs

@Douglas Leeder, еще один ответ: Отсортируйте человекочитаемый вывод от du-h использующий другой инструмент. Как Perl!

du -h | perl -e 'sub h{%h=(K=>10,M=>20,G=>30);($n,$u)=shift=~/([0-9.]+)(\D)/;
return $n*2**$h{$u}}print sort{h($b)<=>h($a)}<>;'

Разделение на две строки для установки дисплею. Можно использовать его этот путь или сделать его остротой, это будет работать так или иначе.

Вывод:

4.5M    .
3.7M    ./colors
372K    ./plugin
128K    ./autoload
100K    ./doc
100K    ./syntax

Править: После нескольких партий в гольф в PerlMonks, конечный результат следующий:

perl -e'%h=map{/.\s/;99**(ord$&&7)-$`,$_}`du -h`;die@h{sort%h}'

Существует очень полезный инструмент, я использую названный ncdu, который разработан для нахождения тех противных высоких папок использования диска и файлов и удаления их. Это - базирующаяся консоль, быстро и свет, и имеет пакеты на всех основных дистрибутивах.

du -k * | sort -nr | cut -f2 | xargs -d '\n' du -sh

Насколько я вижу, что у Вас есть три опции:

1. Измениться du к виду перед дисплеем.
2. Измениться sort поддерживать человеческие размеры для числового вида.
3. Процесс сообщения вывод от вида для изменения основного вывода на человекочитаемый.

Вы могли также сделать du -k и живите с размерами в кибибайте.

Для опции 3 Вы могли использовать следующий сценарий:

#!/usr/bin/env python

import sys
import re

sizeRe = re.compile(r"^(\d+)(.*)$")

for line in sys.stdin.readlines():
    mo = sizeRe.match(line)
    if mo:
        size = int(mo.group(1))
        if size < 1024:
            size = str(size)+"K"
        elif size < 1024 ** 2:
            size = str(size/1024)+"M"
        else:
            size = str(size/(1024 ** 2))+"G"

        print "%s%s"%(size,mo.group(2))
    else:
        print line

У меня была та проблема также, и я в настоящее время использую обходное решение:

du -scBM | sort -n

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

Найденный этой регистрацией в другом месте. Поэтому этот сценарий оболочки сделает то, что Вы хотите без вызова du на всем дважды. Это использует awk преобразовать необработанные байты в человекочитаемый формат. Конечно, форматирование немного отличается (все печатается к одной точности десятичного разряда).

#/bin/bash
du -B1 | sort -nr  |awk '{sum=$1;
hum[1024**3]="G";hum[1024**2]="M";hum[1024]="K";
for (x=1024**3; x>=1024; x/=1024){
        if (sum>=x) { printf "%.1f%s\t\t",sum/x,hum[x];print $2;break
}}}'

Выполнение этого в моем .vim урожаи каталога:

4.4M            .
3.6M            ./colors
372.0K          ./plugin
128.0K          ./autoload
100.0K          ./syntax
100.0K          ./doc

(Я надеюсь 3.6M цветовых схем, не является чрезмерным.)

Эта версия использование awk создать дополнительные столбцы для ключей сортировки. Это только звонит du однажды. Вывод должен посмотреть точно как du.

Я разделил его на несколько строк, но это может быть повторно объединено в остроту.

du -h |
  awk '{printf "%s %08.2f\t%s\n", 
    index("KMG", substr($1, length($1))),
    substr($1, 0, length($1)-1), $0}' |
  sort -r | cut -f2,3

Объяснение:

• НАЧНИТЕ - создают строку для индексации для замены 1, 2, 3 для K, M, G для группировки единицами, если нет никакой единицы (размер является меньше, чем 1K), то там не идет ни в какое сравнение, и нуль возвращается (прекрасный!)
• распечатайте новые поля - единица, значение (чтобы заставить альфа-вид работать правильно, это дополнено нулем, фиксированная длина), и исходная строка
• индексируйте последний знак поля размера
• вытащите числовую часть размера
• отсортируйте результаты, отбросьте дополнительные столбцы

Попробуйте его без cut команда для наблюдения то, что это делает.

Вот версия, которая делает сортировку в рамках сценария AWK и не нужна cut:

du -h |
   awk '{idx = sprintf("%s %08.2f %s", 
         index("KMG", substr($1, length($1))),
         substr($1, 0, length($1)-1), $0);
         lines[idx] = $0}
    END {c = asorti(lines, sorted);
         for (i = c; i >= 1; i--)
           print lines[sorted[i]]}'

У меня есть простая, но полезная обертка Python для du, названного dutop. Обратите внимание, что мы (coreutils специалисты по обслуживанию) полагаем, что добавление функциональности к виду сортирует "человеческий" вывод непосредственно.

Получил другой:

$ du -B1 | sort -nr | perl -MNumber::Bytes::Human=format_bytes -F'\t' -lane 'print format_bytes($F[0])."\t".$F[1]'

Я начинаю любить жемчуг. Вам, возможно, придется сделать a

$ cpan Number::Bytes::Human

сначала. Всем хакерам жемчуга там: Да, я знаю, что часть вида может также быть сделана в жемчуге. Вероятно, du часть, также.

Этот отрывок был бесстыден пойманный от 'Jean-Pierre' из http://www.unix.com/shell-programming-scripting/32555-du-h-sort.html. Существует ли способ, которым я могу лучше поверить ему?

du -k | sort -nr | awk '
     BEGIN {
        split("KB,MB,GB,TB", Units, ",");
     }
     {
        u = 1;
        while ($1 >= 1024) {
           $1 = $1 / 1024;
           u += 1
        }
        $1 = sprintf("%.1f %s", $1, Units[u]);
        print $0;
     }
    '

Вот пример, который показывает каталоги в более компактной итоговой форме. Это обрабатывает пробелы в каталоге/именах файлов.

% du -s * | sort -rn | cut -f2- | xargs -d "\n" du -sh

53G  projects
21G  Desktop
7.2G VirtualBox VMs
3.7G db
3.3G SparkleShare
2.2G Dropbox
272M apps
47M  incoming
14M  bin
5.7M rpmbuild
68K  vimdir.tgz

сортировать файлы по размеру в МБ

du --block-size=MiB --max-depth=1 path | sort -n

По крайней мере, с обычными инструментами, это будет твердо из-за формата, человекочитаемые числа находятся в (обратите внимание, что вид делает "хорошее задание" здесь, поскольку это сортирует числа - 508, 64, 61, 2, 2 - это просто не может отсортировать числа с плавающей точкой с дополнительным множителем).

Я попробовал бы его наоборот - используют вывод от "du | вид-n-r" и впоследствии преобразовывают числа в человекочитаемый формат с некоторым сценарием или программой.

То, что можно попробовать:

for i in `du -s * | sort -n | cut -f2`
do
  du -h $i;
done

Надежда, которая помогает.

du | sort -nr | awk '{ cmd = "du -h -d0 "$2"| cut -f1"; cmd | getline human; close(cmd); print human"\t"$2 }'

Если необходимо обработать пробелы, можно использовать следующее

 du -d 1| sort -nr | cut -f2 | sed 's/ /\\ /g' | xargs du -sh

Дополнительный sed оператор поможет облегчить проблемы с папками с именами, такими как Поддержка приложений

Используйте флаг "-g"

 -g, --general-numeric-sort
              compare according to general numerical value

И на моем/usr/local каталоге производит вывод как это:

$ du |sort -g

0   ./lib/site_ruby/1.8/rubygems/digest
20  ./lib/site_ruby/1.8/rubygems/ext
20  ./share/xml
24  ./lib/perl
24  ./share/sgml
44  ./lib/site_ruby/1.8/rubygems/package
44  ./share/mime
52  ./share/icons/hicolor
56  ./share/icons
112 ./share/perl/5.10.0/YAML
132 ./lib/site_ruby/1.8/rubygems/commands
132 ./share/man/man3
136 ./share/man
156 ./share/perl/5.10.0
160 ./share/perl
488 ./share
560 ./lib/site_ruby/1.8/rubygems
604 ./lib/site_ruby/1.8
608 ./lib/site_ruby

Другой:

du -h | perl -e'
@l{ K, M, G } = ( 1 .. 3 );
print sort {
    ($aa) = $a =~ /(\w)\s+/;
    ($bb) = $b =~ /(\w)\s+/;
    $l{$aa} <=> $l{$bb} || $a <=> $b
  } <>'

Найденный этим на строке..., кажется, работает хорошо

du -sh * | tee /tmp/duout.txt | grep G | sort -rn ; cat /tmp/duout.txt | grep M | sort -rn ; cat /tmp/duout.txt | grep K | sort -rn ; rm /tmp/duout.txt

Voilà:

du -sk /var/log/* | sort -rn | awk '{print $2}' | xargs -ia du -hs "a"

Я узнал о awk из фабрикации этого примера вчера. Это заняло время, но это было отличное развлечение, и я изучил, как использовать awk.

Это работает только du однажды, и это имеет вывод, очень подобный du-h

du --max-depth=0 -k * | sort -nr | awk '{ if($1>=1024*1024) {size=$1/1024/1024; unit="G"} else if($1>=1024) {size=$1/1024; unit="M"} else {size=$1; unit="K"}; if(size<10) format="%.1f%s"; else format="%.0f%s"; res=sprintf(format,size,unit); printf "%-8s %s\n",res,$2 }'

Это показывает числа ниже 10 с одной десятичной точкой.

Вот простой метод, который я использую, очень низкое использование ресурсов, и получает Вас, в чем Вы нуждаетесь:

du --max-depth=1 | sort -n | awk 'BEGIN {OFMT = "%.0f"} {print $1/1024,"MB", $2}'

0 MB ./etc
1 MB ./mail
2 MB ./tmp
123 MB ./public_html

du -cka --max-depth = 1 / var / log | sort -rn | голова -10 | awk '{print (1 доллар США) / 1024, «МБ», 2 доллара США'}

http://dev.yorhel.nl/ncdu

команда: ncdu

Навигация по каталогам, сортировка (имя и размер), построение графиков, удобочитаемость и т. д.

Другое решение awk -

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


[jaypal~/Desktop/Reference]$ 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;}'
15.92MB ./Personal
13.82MB ./Personal/Docs
2.35MB ./Work Docs
1.59MB ./Work Docs/Work
1.46MB ./Personal/Raa
584.00KB ./scan 1.pdf
544.00KB ./Personal/Resume
44.00KB ./Membership.xlsx
16.00KB ./Membership Transmittal Template.xlsx

Я использовал решение, предоставленное @ptman, но недавнее изменение сервера сделало его более непригодным. Вместо этого я использую следующий сценарий bash:

#!/bin/bash
# File: duf.sh
# list contents of the current directory by increasing 
#+size in human readable format

# for some, "-d 1" will be "--maxdepth=1"
du -k -d 1 | sort -g | awk '
{
if($1<1024)
    printf("%.0f KB\t%s",$1,$2);
else if($1<1024*1024)
    printf("%.1f MB\t%s",$1/1024,$2);
else
    printf("%.1f GB\t%s",$1/1024/1024,$2);
}'

du -s * | sort -nr | вырезать -f2 | xargs du -sh

Здесь много ответов, многие из которых дублируются. Я вижу три тенденции: выполнение второго вызова du, использование сложного кода оболочки / awk и использование других языков.

Вот POSIX-совместимое решение с использованием du и awk , которое должно работать в каждой системе.

Я применил немного другой подход, добавив -x к убедитесь, что мы остаемся в той же файловой системе (мне нужна эта операция только тогда, когда у меня мало места на диске, так зачем отсеивать то, что я смонтировал в этом дереве FS или переместил и связал обратно?) более легкий визуальный разбор. В этом случае я обычно выбираю , а не для сортировки, чтобы лучше видеть иерархическую структуру.

sudo du -x | awk '
  $1 > 2^20 { s=$1; $1=""; printf "%7sG%s\n", sprintf("%.2f",s/2^21), $0 }'

(Поскольку это единообразные единицы, вы можете добавить | sort -n если вы действительно хотите сортировать результаты.)

Это отфильтровывает любой каталог, чье (совокупное) содержимое не превышает 512 МБ, а затем отображает размеры в гигабайтах. По умолчанию du использует размер блока 512 байт (так что условие awk для 2 ²⁰ блоков составляет 512 МБ, а его делитель 2 ²¹ преобразует единицы в ГБ - мы могли бы использовать du -kx с $ 1> 512 * 1024 и s / 1024 ^ 2 , чтобы было удобнее читать). Внутри условия awk мы устанавливаем s равным размеру, чтобы мы могли удалить его из строки ( $ 0 ). При этом сохраняется разделитель (который свернут до одного пробела), поэтому последний % s представляет собой пробел, а затем имя агрегированного каталога. % 7s выравнивает округленный размер %. 2f ГБ (увеличьте до % 8s , если у вас> 10 ТБ).

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