it-swarm-ko.com

du -h 출력을 크기별로 정렬하는 방법

사람이 읽을 수있는 du 출력 목록을 가져와야합니다.

그러나 du에는 "크기별 정렬"옵션이 없으며 sort 로의 파이프는 사람이 읽을 수있는 플래그와 작동하지 않습니다.

예를 들어 다음을 실행합니다.

du | sort -n -r 

크기별로 정렬 된 디스크 사용량을 출력합니다 (내림차순).

du |sort -n -r
65108   .
61508   ./dir3
2056    ./dir4
1032    ./dir1
508     ./dir2

그러나 사람이 읽을 수있는 플래그로 실행하면 올바르게 정렬되지 않습니다.

du -h | sort -n -r

508K    ./dir2
64M     .
61M     ./dir3
2.1M    ./dir4
1.1M    ./dir1

누구든지 du -h 크기별로?

1029
Tom Feiner

2009 년 8 월에 릴리스 된 GNU coreutils 7.5 현재, sort-h 매개 변수를 허용합니다. du -h

du -hs * | sort -h

-h를 지원하지 않는 정렬을 사용하는 경우 GNU Coreutils. 예 : 이전 Mac OS X에 설치할 수 있습니다.

brew install coreutils
du -hs * | gsort -h

sortmanual 에서 :

-h, --human-numeric-sort compare human readable numbers (e.g., 2K 1G)

1444
ptman
du | sort -nr | cut -f2- | xargs du -hs
89
cadrian

@Douglas Leeder, 또 하나의 대답 : 다른 도구를 사용하여 du-h에서 사람이 읽을 수있는 출력을 정렬하십시오. 펄처럼!

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

EDIT : PerlMonks 에서 몇 번의 골프 라운드 후 최종 결과는 다음과 같습니다.

Perl -e'%h=map{/.\s/;99**(ord$&&7)-$`,$_}`du -h`;[email protected]{sort%h}'
62
Adam Bellaire

내가 사용하는 ncd 라는 매우 유용한 도구가 있습니다.이 도구는 성가신 디스크 사용량이 많은 폴더와 파일을 찾아서 제거하도록 설계되었습니다. 콘솔 기반의 빠르고 가벼우 며 모든 주요 배포판에 패키지가 있습니다.

57
neutral
du -k * | sort -nr | cut -f2 | xargs -d '\n' du -sh
44
chrisharris.

내가 알 수있는 한 세 가지 옵션이 있습니다.

  1. 표시하기 전에 du을 (를) 정렬하십시오.
  2. 숫자 정렬을 위해 사람 크기를 지원하도록 sort를 변경하십시오.
  3. 출력을 사후 처리하여 기본 출력을 사람이 읽을 수 있도록 변경합니다.

du -k를 수행하고 KiB 크기로도 살 수 있습니다.

옵션 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
21
Douglas Leeder

나는 그 문제도 있었고 현재 해결 방법을 사용하고 있습니다 :

du -scBM | sort -n

이렇게하면 크기 조정 된 값이 생성되지 않지만 항상 크기 (MB)가 생성됩니다. 그것은 덜 완벽하지만 나에게는 아무것도 아닌 것보다 낫습니다 (또는 바이트 단위로 크기를 표시하는 것).

20
Joachim Sauer

다른 곳에서 이 게시물 을 (를) 찾았습니다. 따라서이 셸 스크립트는 모든 것을 du으로 두 번 호출하지 않고 원하는 것을 수행합니다. 원시 바이트를 사람이 읽을 수있는 형식으로 변환하기 위해 awk를 사용합니다. 물론 서식은 약간 다릅니다 (모든 것은 소수점 이하 자릿수 1 자리로 인쇄 됨).

#/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의 색 구성표가 과도하지 않기를 바랍니다.)

19
Adam Bellaire

이 버전은 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

설명:

  • BEGIN-단위별로 그룹화하기 위해 K, M, G 대신 1, 2, 3을 대체 할 색인을 생성 할 문자열을 생성합니다. 단위가 없으면 (크기가 1K 미만) 일치하지 않고 0이 반환됩니다 (완벽! )
  • 새로운 필드-단위, 값 (알파 정렬이 제대로 작동하도록하기 위해 0으로 채워진 고정 길이 임)과 원래 줄을 인쇄하십시오.
  • 크기 필드의 마지막 문자를 색인
  • 크기의 숫자 부분을 당겨
  • 결과 정렬, 추가 열 삭제

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

다음은 디렉토리를보다 간결한 요약 형식으로 표시하는 예입니다. 디렉토리/파일 이름의 공백을 처리합니다.

% 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
15
slm

크기를 MB 단위로 파일 정렬

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

간단하지만 유용한 python du의 래퍼 dutop 라고합니다. 직접 출력합니다.

9
pixelbeat

또 하나있어 :

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

나는 Perl을 좋아하기 시작했다. 당신은해야 할 수도 있습니다

$ cpan Number::Bytes::Human

먼저. 모든 Perl 해커들에게 : 예, 나는 정렬 부분이 Perl에서도 가능하다는 것을 알고 있습니다. 아마 뒤 부분 일 것입니다.

9
0x89

이 스 니펫은 http://www.unix.com/Shell-programming-scripting/32555-du-h-sort.html 의 'Jean-Pierre'에서 부끄러워하지 않았습니다. 내가 더 잘 신용 할 수있는 방법이 있습니까?

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

"-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
7
Mick T

이것을 온라인에서 찾았습니다 ... 작동하는 것 같습니다

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
5
Peter Nunn

여기에 내가 사용하는 간단한 방법, 매우 낮은 리소스 사용량이 있으며 필요한 것을 얻을 수 있습니다.

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
4
JacobN

나는 어제이 예를 구체화함으로써 어색함을 배웠다. 시간이 좀 걸렸지 만 재미 있었고 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 }'

소수점 이하 1 자리로 10 미만의 숫자를 표시합니다.

4
marlar

다른 것:

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
  } <>'
4
Dimitre Radoulov

du -cka --max-depth = 1/var/log | 정렬 -rn | 머리 -10 | awk '{print ($ 1)/1024, "MB", $ 2'}

3
Patrick

공백을 처리 해야하는 경우 다음을 사용할 수 있습니다

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

추가 sed 문은 응용 프로그램 지원과 같은 이름을 가진 폴더의 문제를 완화하는 데 도움이됩니다.

2
Chealion

Voilà :

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

여기에 많은 답변이 있으며, 그중 다수는 중복입니다. 세 가지 트렌드가 있습니다. 두 번째 통화를 통한 파이핑, 복잡한 Shell/awk 코드 및 다른 언어 사용.

다음은 모든 시스템에서 작동해야하는 dawk 을 사용하는 POSIX 호환 솔루션 입니다.

동일한 파일 시스템을 유지하기 위해 -x를 추가하여 약간 다른 접근 방식을 취했습니다 (디스크 공간이 부족할 때만이 작업이 필요합니다. 이 FS 트리 또는 이동 및 심볼릭 링크?) 및 상수 단위를 표시하여보다 쉽게 ​​시각적 구문 분석 할 수 있습니다.이 경우 일반적으로 not 계층 구조를 더 잘 볼 수 있습니다.

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

(이것은 일관된 단위이므로, sort ed 결과를 원한다면 | sort -n를 추가 할 수 있습니다.)

이렇게하면 (누적) 컨텐츠가 512MB를 초과하지 않는 디렉토리를 필터링 한 다음 크기 (GB)를 표시합니다. du는 기본적으로 512 바이트 블록 크기를 사용합니다.20 블록은 512MB이며 221 divisor는 단위를 GB로 변환합니다. du -kx$1 > 512*1024s/1024^2와 함께 사용하면 사람이보다 쉽게 ​​읽을 수 있습니다). awk 조건 안에서 s를 크기로 설정하여 행에서 제거 할 수 있습니다 ($0). 이렇게하면 구분 기호 (단일 공백으로 축소됨)가 유지되므로 마지막 %s는 공백과 집계 된 디렉터리 이름을 나타냅니다. %7s는 반올림 된 %.2f GB 크기를 정렬합니다 (10TB보다 크면 %8s로 증가).

여기에있는 대부분의 솔루션과 달리 이것은 이름에 공백이있는 디렉토리를 올바르게 지원합니다 (every 하나, 줄 바꿈이 포함 된 디렉토리 이름을 잘못 처리합니다).

1
Adam Katz

다른 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
1
user96753

http://dev.yorhel.nl/ncd

명령 : ncdu

디렉토리 탐색, 정렬 (이름 및 크기), 그래프, 사람이 읽을 수있는 내용 등.

1
Adam Eickhoff

@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);
}'
1
Keith Yoder

du -s * | 정렬 -nr | 컷 -f2 | xargs du -sh

1
ageek2remember

여기에 예가 있습니다

du -h /folder/subfolder --max-depth=1 | sort -hr

보고:

233M    /folder/subfolder
190M    /folder/subfolder/myfolder1
15M     /folder/subfolder/myfolder4
6.4M    /folder/subfolder/myfolder5
4.2M    /folder/subfolder/myfolder3
3.8M    /folder/subfolder/myfolder2

| head -10는 지정된 디렉토리에서 상위 10 개 또는 임의의 수의 하위 폴더를 찾습니다.

1
ode2k

이것은 내 .profile에있는 별칭입니다.

별칭 du = 'Sudo du -xh --max-depth = 1 | 정렬 -h '

sort -h는 질문에 도움이되는 것입니다.

또 다른 유용한 옵션은 du -x로 동일한 파일 시스템에 남아 있습니다. 또한 Sudo는 세계적으로 읽을 수없는 디렉토리가있는 경우 오류를 보지 못하게합니다. 또한, 나는 항상 du --max-depth = 1을 한 다음 더 드릴 다운합니다.

0
Tagar

또 다른 du 스크립트!

이미 많은 답변이 있으므로 여기에 자체 스크립트를 게시하십시오. 나는 지금 8 년 이상을 사용합니다.

이것은 다음에 의해 실행될 수 있습니다.

/somepath/rdu.sh [-b] [/somepath] [minSize]

어디

  • 선택적 플래그 -b블록 수 대신 바이트 수을 사용하도록 지시하십시오
  • 선택적인 path 첫 번째 인수로, 기본값 인 경우 현재 디렉토리입니다.
  • 두 번째 인수가 없으면 인쇄 할 최소 크기는 256Mb.

결과는 다음과 같습니다.

\___   3.01G                 21.67%                .cache
|   \___   1.37G                 45.54%                mozilla
|   |   \___   1.37G                100.00%                firefox
|   |   |   \___ 581.71M                 41.48%                billiethek.default
|   |   |   |   \___ 522.64M                 89.85%                cache2
|   |   |   |   |   \___ 522.45M                 99.96%                entries
...

스크립트가 있습니다 :

#!/bin/bash

if [ "$1" == "-b" ] ;then
    shift
    units=(b K M G T P)
    duargs="-xbs"
    minsize=${2:-$((256*1024**2))}
else
    units=(K M G T P)
    duargs="-xks"
    minsize=${2:-$((256*1024))}
fi

humansize() {
    local _c=$1 _i=0
    while [ ${#_c} -gt 3 ] ;do
        ((_i++))
        _c=$((_c>>10))
    done
    _c=$(( ( $1*1000 ) >> ( 10*_i ) ))
    printf ${2+-v} $2 "%.2f%s" ${_c:0:${#_c}-3}.${_c:${#_c}-3} ${units[_i]}
}
percent() {
    local p=000$((${1}00000/$2))
    printf ${3+-v} $3 "%.2f%%" ${p:0:${#p}-3}.${p:${#p}-3}
}

device=$(stat -c %d "${1:-.}")
printf -v sep "%16s" ""

rdu() {
    local _dir="$1" _spc="$2" _crt _siz _str _tot _pct
    while read _siz _crt;do
        if [ "$_crt" = "total"  ]; then
            _tot=$_siz
        else
            [ "$_tot" ] || _tot=$_siz
            if [ $_siz -gt $minsize ];then
                humansize $_siz _str
                percent $_siz $_tot _pct
                printf "%s\___ %7s%s%7s%s%s\n" \
                    "$_spc" $_str "$sep" $_pct "$sep" "${_crt##*/}"
                [ -d "$_crt" ] &&
                [ $(stat -c %d "$_crt") -eq $device ] &&
                rdu "$_crt" "|   $_spc"
            fi
        fi
    done < <(
        find "$_dir" -mindepth 1 -maxdepth 1 -xdev \
            \( -type f -o -type d \) -printf "%D;%p\n" |
            sed -ne "s/^${device};//p" |
            tr \\n \\0 |
            xargs -0 du ${duargs}c |
            sort -nr
    )
}

rdu "${1:-.}"

아니요, Git***.xxx.

여기에 표시 또는 여기에 스크립트 다운로드

0
F. Hauri

내 솔루션은 du를 한 번만 호출하고 1MB 이상의 디렉토리 만 표시하는 간단한 bash 스크립트입니다.

#!/bin/env bash
# Usage: my_du.sh [subdirectory levels]
#   For efficiency, only calls "du" once, and stores results in a temp file
#   Stephen Becker, 2/23/2010

if [ $# -gt 0 ]; then
# You may prefer, as I do, to just summarize the contents of a directory
# and not view the size of its subdirectories, so use this:
    du -h --max-depth $1 > temp_du_file
else
    du -h > temp_du_file
fi


# Show all directories of size > 1 GB:
cat temp_du_file | grep "^\([0-9]\|\.\)\+G" | sort -nr
# Show all directories of size > 1 MB:
cat temp_du_file | grep "^\([0-9]\|\.\)\+M" | sort -nr

rm temp_du_file
0
Stephen

적어도 일반적인 도구를 사용하면 사람이 읽을 수있는 숫자 형식이기 때문에 이것은 어려울 것입니다. 추가 승수로 부동 소수점 숫자를 정렬 할 수는 없습니다).

다른 방법으로 시도해보십시오- "du | sort -n -r"의 출력을 사용하고 나중에 스크립트 또는 프로그램을 사용하여 숫자를 사람이 읽을 수있는 형식으로 변환하십시오.

0
schnaader

시도 할 수있는 것은 :

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

희망이 도움이됩니다.

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

다음 솔루션은 cadrian의 원래 솔루션과 유사하지만 트리의 각 디렉토리마다 하나의 du와 반대로 2 개의 du 명령 만 실행합니다.

du -hs `du |sort -g |cut -f2- `

그러나 Cardrian의 솔루션은 위의 매우 많이 채워진 나무에서 작동하지 않으므로 du에 전달되는 인수의 크기 제한을 초과 할 수 있으므로 더 강력합니다.

0
Steve Weet

this one-liner 의 논리를 느슨하게 기반으로 정렬 된 사람이 읽을 수있는 du (1) 출력을 제공하는 스크립트를 작성했습니다. -h 인간이 읽을 수있는 플래그이며 POSIX 호환이 아닌 다른 명령이 필요하지 않습니다.

https://github.com/pleappleappleap/sorted-human-d 에서 사용할 수 있습니다.

0
Tripp Kinetics

왜 다른 모자를 고리에 넣지 않습니까? ... 이것은 오래된 질문이지만, 여기에 (대부분) 순수한 쉘 스크립트 (fwiw)가 있습니다. 그래서 그런 의미에서 그것은 토론에 새로운 것을 제공 할 수도 있고 그렇지 않을 수도 있습니다. 파일 크기를 한 번만 계산하지만 다양한 단위로 인쇄합니다 (내 환경 설정). 단순화되지 않은 버전에는 원하지 않는 경우 "GB"를 제외한 getopts가 포함됩니다.

#!/bin/bash

printf -- ' %9s %9s %9s       %-30s\n' 'K'        'M'        'G'        'Path'
printf -- ' %9s %9s %9s       %-30s\n' '--------' '--------' '--------' '-----------'
du -sk "[email protected]" | while read val; do
    file=$(echo "$val" | cut -f2-)
    size_k=$(echo "$val"  | cut -f1)
    printf ' %9s %9s %9s       %-30s\n' \
          ${size_k}  \
          $(( size_k / 1024 ))  \
          $(( size_k / 1024 / 1024 ))  \
          "$file"
  done | sort -n
0
michael

내림차순으로 정렬합니다.

du -s ./* | sort -n| cut -f 2-| xargs du -sh {}
0
Peter Nduati