Início / server / Perguntas / 62411
Accepted
Tom Feiner
Asked: 2009-02-26 05:42:42 +0800 CST

Como posso classificar a saída du -h por tamanho

  • 772

Eu preciso obter uma lista de saída du legível por humanos.

No entanto, dunão possui uma opção "classificar por tamanho" e a tubulação para sortnão funciona com o sinalizador legível por humanos.

Por exemplo, executando:

du | sort -n -r

Gera um uso de disco classificado por tamanho (decrescente):

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

No entanto, executá-lo com o sinalizador legível por humanos não classifica corretamente:

du -h | sort -n -r

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

Alguém sabe uma maneira de classificar du -h por tamanho?

linux bash du gnu

30 respostas

  1. Best Answer

    A partir do GNU coreutils 7.5 lançado em agosto de 2009, sortpermite um -hparâmetro, que permite sufixos numéricos do tipo produzido por du -h:

    du -hs * | sort -h

    Se você estiver usando um tipo que não suporta -h, você pode instalar o GNU Coreutils. Por exemplo, em um Mac OS X mais antigo:

    brew install coreutils
du -hs * | gsort -h

    Do sort manual :

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

    • 1893 
  2. du | sort -nr | cut -f2- | xargs du -hs
    • 105

  3. Existe uma ferramenta imensamente útil que eu uso chamada ncdu que é projetada para encontrar essas pastas e arquivos de alto uso de disco e removê-los. É baseado em console, rápido e leve, e possui pacotes em todas as principais distribuições.

    • 79

  4. @Douglas Leeder, mais uma resposta: Classifique a saída legível por humanos de du -h usando outra ferramenta. Como 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)}<>;'

    Dividido em duas linhas para caber na tela. Você pode usá-lo dessa maneira ou torná-lo um one-liner, funcionará de qualquer maneira.

    Resultado:

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

    EDIT: Depois de algumas rodadas de golfe no PerlMonks , o resultado final é o seguinte:

    perl -e'%h=map{/.\s/;99**(ord$&&7)-$`,$_}`du -h`;die@h{sort%h}'
    • 70 
  5. du -k * | sort -nr | cut -f2 | xargs -d '\n' du -sh
    • 47

  6. Pelo que vejo, você tem três opções:

    1. Altere dupara classificar antes da exibição.
    2. Alter sortpara suportar tamanhos humanos para classificação numérica.
    3. Pós-processe a saída de classificação para alterar a saída básica para legível por humanos.

    Você também pode fazer du -ke viver com tamanhos em KiB.

    Para a opção 3, você pode usar o seguinte script:

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

  7. Eu também tive esse problema e atualmente estou usando uma solução alternativa:

    du -scBM | sort -n

    Isso não produzirá valores dimensionados, mas sempre produzirá o tamanho em megabytes. Isso é menos perfeito, mas para mim é melhor que nada (ou exibir o tamanho em bytes).

    • 24

  8. Encontrei esta postagem em outro lugar. Portanto, este script de shell fará o que você deseja sem chamar dutudo duas vezes. Ele usa awkpara converter os bytes brutos em um formato legível por humanos. Claro, a formatação é um pouco diferente (tudo é impresso com precisão de uma casa decimal).

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

    Executando isso no meu .vimdiretório produz:

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

    (Espero que 3,6 milhões de esquemas de cores não sejam excessivos.)

    • 21

  9. Aqui está um exemplo que mostra os diretórios em uma forma resumida mais compacta. Ele lida com espaços em diretórios/nomes de arquivos.

    % 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
    • 20

  10. Esta versão usa awkpara criar colunas extras para chaves de classificação. Só liga duuma vez. A saída deve ser exatamente como du.

    Eu o dividi em várias linhas, mas pode ser recombinado em uma linha.

    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

    Explicação:

    • BEGIN - crie uma string para indexar para substituir 1, 2, 3 por K, M, G para agrupamento por unidades, se não houver unidade (o tamanho é menor que 1K), então não há correspondência e um zero é retornado (perfeito! )
    • imprima os novos campos - unidade, valor (para fazer a classificação alfa funcionar corretamente, é preenchido com zeros, comprimento fixo) e linha original
    • indexar o último caractere do campo de tamanho
    • retire a parte numérica do tamanho
    • classifique os resultados, descarte as colunas extras

    Experimente sem o cutcomando para ver o que está fazendo.

    Aqui está uma versão que faz a classificação dentro do script AWK e não precisa 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]]}'
    • 20

relate perguntas