Usando ls para listar diretórios e seus tamanhos totais

É possível usar lsno Unix para listar o tamanho total de um subdiretório e todo o seu conteúdo, em oposição ao habitual 4Kque (presumo) seja apenas o próprio arquivo de diretório?

total 12K
drwxrwxr-x  6 *** *** 4.0K 2009-06-19 10:10 branches
drwxrwxr-x 13 *** *** 4.0K 2009-06-19 10:52 tags
drwxrwxr-x 16 *** *** 4.0K 2009-06-19 10:02 trunk

Depois de vasculhar as páginas de manual, estou ficando vazio.

Tente algo como:

du -sh *

versão curta de:

du --summarize --human-readable *

Explicação:

du: D isk U sage

-s: Exibe um resumo para cada arquivo especificado. (Equivalente a -d 0)

-h: Saída "legível por humanos". Utilização sufixos unidade: B YTE, K ibibyte (KiB), H ebibyte (MIB), L ibibyte (GIB), T ebibyte (TiB) e P ebibyte (PIB). (BASE2)

du -sk * | sort -nordenará as pastas por tamanho. Útil ao procurar espaço livre ..

du -sh * | sort -h

Isso será exibido em formato legível por humanos.

Para listar os maiores diretórios do diretório atual no formato legível por humanos:

du -sh * | sort -hr

Uma maneira melhor de restringir o número de linhas pode ser

du -sh * | sort -hr | head -n10

Onde você pode aumentar o sufixo do -nsinalizador para restringir o número de linhas listadas

Amostra:

[~]$ du -sh * | sort -hr
48M app
11M lib
6.7M    Vendor
1.1M    composer.phar
488K    phpcs.phar
488K    phpcbf.phar
72K doc
16K nbproject
8.0K    composer.lock
4.0K    README.md

Torna mais conveniente a leitura :)

Para exibi-lo em ls -lhformato, use:

(du -sh ./*; ls -lh --color=no) | awk '{ if($1 == "total") {X = 1} else if (!X) {SIZES[$2] = $1} else { sub($5 "[ ]*", sprintf("%-7s ", SIZES["./" $9]), $0); print $0} }'

O código awk explicou:

if($1 == "total") { // Set X when start of ls is detected
  X = 1 
} else if (!X) { // Until X is set, collect the sizes from `du`
  SIZES[$2] = $1
} else {
  // Replace the size on current current line (with alignment)
  sub($5 "[ ]*", sprintf("%-7s ", SIZES["./" $9]), $0); 
  print $0
}

Saída de amostra:

drwxr-xr-x 2 root     root 4.0K    Feb 12 16:43 cgi-bin
drwxrws--- 6 root     www  20M     Feb 18 11:07 document_root
drwxr-xr-x 3 root     root 1.3M    Feb 18 00:18 icons
drwxrwsr-x 2 localusr www  8.0K    Dec 27 01:23 passwd

O comando que você deseja é 'du -sk' du = "uso do disco"

O sinalizador -k fornece saída em kilobytes, em vez do padrão dos setores do disco (blocos de 512 bytes).

O sinalizador -s listará apenas as coisas no diretório de nível superior (por exemplo, o diretório atual, por padrão, ou o diretório especificado na linha de comando). É estranho que du tenha o comportamento oposto de ls nesse sentido. Por padrão, du fornecerá recursivamente o uso do disco de cada subdiretório. Por outro lado, ls fornecerá apenas arquivos de lista no diretório especificado. (ls -R fornece um comportamento recursivo.)

Coloque esta declaração da função shell nos scripts de inicialização do shell:

function duls {
    paste <( du -hs -- "$@" | cut -f1 ) <( ls -ld -- "$@" )
}

Eu chamei dulsporque mostra a saída de ambos due ls(nessa ordem):

$ duls
210M    drwxr-xr-x  21 kk  staff  714 Jun 15 09:32 .

$ duls *
 36K    -rw-r--r--   1 kk  staff    35147 Jun  9 16:03 COPYING
8.0K    -rw-r--r--   1 kk  staff     6962 Jun  9 16:03 INSTALL
 28K    -rw-r--r--   1 kk  staff    24816 Jun 10 13:26 Makefile
4.0K    -rw-r--r--   1 kk  staff       75 Jun  9 16:03 Makefile.am
 24K    -rw-r--r--   1 kk  staff    24473 Jun 10 13:26 Makefile.in
4.0K    -rw-r--r--   1 kk  staff     1689 Jun  9 16:03 README
120K    -rw-r--r--   1 kk  staff   121585 Jun 10 13:26 aclocal.m4
684K    drwxr-xr-x   7 kk  staff      238 Jun 10 13:26 autom4te.cache
128K    drwxr-xr-x   8 kk  staff      272 Jun  9 16:03 build
 60K    -rw-r--r--   1 kk  staff    60083 Jun 10 13:26 config.log
 36K    -rwxr-xr-x   1 kk  staff    34716 Jun 10 13:26 config.status
264K    -rwxr-xr-x   1 kk  staff   266637 Jun 10 13:26 configure
8.0K    -rw-r--r--   1 kk  staff     4280 Jun 10 13:25 configure.ac
7.0M    drwxr-xr-x   8 kk  staff      272 Jun 10 13:26 doc
2.3M    drwxr-xr-x  28 kk  staff      952 Jun 10 13:26 examples
6.2M    -rw-r--r--   1 kk  staff  6505797 Jun 15 09:32 mrbayes-3.2.7-dev.tar.gz
 11M    drwxr-xr-x  42 kk  staff     1428 Jun 10 13:26 src

$ duls doc
7.0M    drwxr-xr-x  8 kk  staff  272 Jun 10 13:26 doc

$ duls [bM]*
 28K    -rw-r--r--  1 kk  staff  24816 Jun 10 13:26 Makefile
4.0K    -rw-r--r--  1 kk  staff     75 Jun  9 16:03 Makefile.am
 24K    -rw-r--r--  1 kk  staff  24473 Jun 10 13:26 Makefile.in
128K    drwxr-xr-x  8 kk  staff    272 Jun  9 16:03 build

Explicação:

O pasteutilitário cria colunas a partir de sua entrada de acordo com a especificação que você fornece. Dados dois arquivos de entrada, os coloca lado a lado, com uma guia como separador.

Damos a saída du -hs -- "$@" | cut -f1como o primeiro arquivo (realmente o fluxo de entrada) e a saída ls -ld -- "$@"como o segundo arquivo.

Na função, "$@"será avaliada a lista de todos os argumentos da linha de comando, cada um entre aspas duplas. Portanto, ele entenderá caracteres brilhantes e nomes de caminhos com espaços etc.

O duplo menos ( --) sinaliza o final das opções da linha de comando para due ls. Sem isso, dizer duls -lconfundiria due qualquer opção para duisso lsnão confundiria ls(e as opções que existem nos dois utilitários podem não significar a mesma coisa, e seria uma bagunça).

O cutdepois dusimplesmente corta a primeira coluna da du -hssaída (os tamanhos).

Decidi colocar a dusaída à esquerda, caso contrário eu teria que gerenciar uma coluna oscilante da direita (devido aos comprimentos variáveis ​​dos nomes dos arquivos).

O comando não aceita sinalizadores de linha de comando.

Isso foi testado em ambos bashe em ksh93. Não vai funcionar com /bin/sh.

Eu sempre uso du -sk( -ksinalizador mostrando o tamanho do arquivo em kilobytes).

du -h --max-depth=1 . | sort -n -r

ncdu maldições du

Este incrível utilitário CLI permite encontrar facilmente grandes arquivos e diretórios interativamente.

Por exemplo, de dentro da árvore de um projeto conhecido , fazemos:

sudo apt-get install ncdu
ncdu

O resultado é:

Então, eu entro no teclado e à direita no teclado para ir para a /driverspasta e vejo:

ncdu só calcula o tamanho do arquivo recursivamente uma vez na inicialização de toda a árvore, tornando-o eficiente.

"Uso total do disco" vs "Tamanho aparente" é análogo due expliquei-o em: por que a saída do `du` geralmente é tão diferente do` du -b`

Página inicial do projeto: https://dev.yorhel.nl/ncdu

Perguntas relacionadas:

• /unix/67806/how-to-recursively-find-the-amount-stored-in-directory/67808
• /unix/125429/tracking-down-where-disk-space-has-gone-on-linux
• /ubuntu/57603/how-to-list-recursive-file-sizes-of-files-and-directories-in-a-directory
• /server/43296/how-does-one-find-which-files-are-taking-up-80-of-the-space-on-a-linux-webserve

Testado no Ubuntu 16.04.

ncdu uso não interativo

Outro recurso interessante ncdué que você pode primeiro despejar os tamanhos em um formato JSON e depois reutilizá-los.

Por exemplo, para gerar o arquivo, execute:

ncdu -o ncdu.json

e, em seguida, examine-o interativamente com:

ncdu -f ncdu.json

Isso é muito útil se você estiver lidando com um sistema de arquivos muito grande e lento como o NFS.

Dessa forma, você pode exportar primeiro apenas uma vez, o que pode levar horas, e depois explorar os arquivos, sair, explorar novamente etc.

O formato de saída é apenas JSON, portanto, é fácil reutilizá-lo com outros programas, por exemplo:

ncdu -o -  | python -m json.tool | less

revela uma estrutura de dados simples da árvore de diretórios:

[
    1,
    0,
    {
        "progname": "ncdu",
        "progver": "1.12",
        "timestamp": 1562151680
    },
    [
        {
            "asize": 4096,
            "dev": 2065,
            "dsize": 4096,
            "ino": 9838037,
            "name": "/work/linux-kernel-module-cheat/submodules/linux"
        },
        {
            "asize": 1513,
            "dsize": 4096,
            "ino": 9856660,
            "name": "Kbuild"
        },
        [
            {
                "asize": 4096,
                "dsize": 4096,
                "ino": 10101519,
                "name": "net"
            },
            [
                {
                    "asize": 4096,
                    "dsize": 4096,
                    "ino": 11417591,
                    "name": "l2tp"
                },
                {
                    "asize": 48173,
                    "dsize": 49152,
                    "ino": 11418744,
                    "name": "l2tp_core.c"
                },

Testado no Ubuntu 18.04.

du -sch * no mesmo diretório.

Este é um que eu gosto

atualizar : Eu não gostei do anterior porque não mostrava arquivos no diretório atual, apenas listava os diretórios.

Exemplo de saída para /varno ubuntu:

sudo du -hDaxd1 /var | sort -h | tail -n10

4.0K    /var/lock
4.0K    /var/run
4.0K    /var/www
12K     /var/spool
3.7M    /var/backups
33M     /var/log
45M     /var/webmin
231M    /var/cache
1.4G    /var/lib
1.7G    /var

Essas são ótimas sugestões, mas a que eu uso é:

du -ksh * | sort -n -r

-ksh garante que os arquivos e pastas estejam listados em um formato legível por humanos e em megabytes, kilobytes, etc. Em seguida, você os classifica numericamente e inverte o tipo, para colocar os maiores em primeiro lugar.

A única desvantagem desse comando é que o computador não sabe que o Gigabyte é maior que o Megabyte; portanto, ele classificará apenas por números e, com frequência, você encontrará listagens como esta:

120K
12M
4G

Apenas tenha cuidado ao olhar para a unidade.

Este comando também funciona no Mac (enquanto sort -hque não funciona, por exemplo).

du -S

O du tem outra opção útil: -S, --separate-dirsdizer ao du não incluir o tamanho dos subdiretórios - útil em algumas ocasiões.

Exemplo 1 - mostra apenas os tamanhos de arquivo em um diretório:

du -Sh  * 
3,1G    10/CR2
280M    10

Exemplo 2 - mostra os tamanhos e subdiretórios do arquivo no diretório:

du -h  * 
3,1G    10/CR2 
3,4G    10

du -sm * | sort -nr

Saída por tamanho

olhe o ducomando para isso

apenas um aviso, se você quiser comparar tamanhos de arquivos. du produz resultados diferentes dependendo do sistema de arquivos, tamanho do bloco, ....

Pode acontecer que o tamanho dos arquivos seja diferente, por exemplo, comparando o mesmo diretório no disco rígido local e em um dispositivo de armazenamento em massa USB. Eu uso o seguinte script, incluindo ls para resumir o tamanho do diretório. O resultado é em bytes, considerando todos os subdiretórios.

echo "[GetFileSize.sh] target directory: \"$1\""

iRetValue=0

uiLength=$(expr length "$1")
if [ $uiLength -lt 2 ]; then
  echo "[GetFileSize.sh] invalid target directory: \"$1\" - exiting!"
  iRetValue=-1
else
  echo "[GetFileSize.sh] computing size of files..."

  # use ls to compute total size of all files - skip directories as they may
  # show different sizes, depending on block size of target disk / file system
  uiTotalSize=$(ls -l -R $1 | grep -v ^d | awk '{total+=$5;} END {print total;}')
  uiLength=$(expr length "$uiTotalSize")
  if [ $uiLength -lt 1 ]; then
    uiTotalSize=0
  fi
  echo -e "[GetFileSize.sh] total target file size: \"$uiTotalSize\""

fi

exit "$iRetValue"

Para exibir os tamanhos de arquivos e subdiretórios do diretório atual recursivamente:

du -h .

Para exibir as mesmas informações de tamanho, mas sem imprimir seus subdiretórios recursivamente (que pode ser uma lista enorme), basta usar a opção --max-depth :

du -h --max-depth=1 .

Por um tempo, usei o Nautilus (na área de trabalho do Gnome no RHEL 6.0) para excluir arquivos da minha pasta pessoal em vez de usar o rmcomando bash. Como resultado, o tamanho total mostrado por

du -sh

não correspondia à soma do uso do disco de cada subdiretório, quando eu usei

du -sh *

Demorei um pouco para perceber que o Nautilus envia os arquivos excluídos para a pasta Lixeira, e essa pasta não está listada no du -sh *comando. Então, só queria compartilhar isso, caso alguém enfrentasse o mesmo problema.

Hmm, a melhor maneira é usar este comando:

du -h -x / | sort -hr >> /home/log_size.txt

Você poderá obter pastas de todos os tamanhos em todo o servidor. Fácil de ajudá-lo a encontrar os maiores tamanhos.

É fácil lembrar o seguinte

ls -ltrapR

listar o conteúdo do diretório

-l uso um formato de listagem longo

-t ordenar por tempo de modificação, o mais novo primeiro

-r, - ordem inversa inversa ao classificar

-a, --all não ignora as entradas iniciadas por.

-p, --indicator-style = barra anexada / indicador aos diretórios

-R, - subdiretórios lista recursiva recursivamente

https://explainshell.com/explain?cmd=ls+-ltrapR

Se você deseja ter mais controle sobre o sizeque deseja listar os diretórios, poderá usar a opção threshold( -t) como em:

$ du -ht 1000000000 | sort --reverse

du- disk usage
h - formato legível por humanos
t - tamanho do limiar

Aqui, queremos listar todos os diretórios com tamanho superior a 1 GB.

$ du -ht 1G | sort --reverse

Explicação :

As unidades descritas no wiki são as seguintes:

K, M, G, T, P, E, Z, Y (potências de 1024) ou
KB, MB, GB, TB, PB, EB, ZB, YB (potências de 1000).

Corri para um problema semelhante ao que Martin Wilde descreveu, no meu caso, comparando o mesmo diretório em dois servidores diferentes após o espelhamento com o rsync.

Em vez de usar um script, adicionei o -bsinalizador ao duqual conta o tamanho em bytes e até onde posso determinar eliminou as diferenças nos dois servidores. Você ainda pode usar -s -hpara obter uma saída compreensível.

coloque no script init como .bashrc ... ajuste def conforme necessário.

duh() {
  # shows disk utilization for a path and depth level
  path="${1:-$PWD}"
  level="${2:-0}"
  du "$path" -h --max-depth="$level"
}

digite "ls -ltrh / path_to_directory"