Usar ls para enumerar directorios y sus tamaños totales

¿Es posible usar lsen Unix para enumerar el tamaño total de un subdirectorio y todo su contenido en lugar de lo habitual 4Kque (supongo) es solo el archivo de directorio en sí?

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

Después de buscar en las páginas del manual, estoy vacío.

Intenta algo como:

du -sh *

versión corta de:

du --summarize --human-readable *

Explicación:

du: D isk U sage

-s: Muestra un resumen para cada archivo especificado. (Equivalente a -d 0)

-h: Salida "legible para humanos". Utilice sufijos de unidad: B yte, K ibibyte (KiB), M ebibyte (MiB), G ibibyte (GiB), T ebibyte (TiB) y P ebibyte (PiB). (BASE2)

du -sk * | sort -nclasificará las carpetas por tamaño. Útil cuando se busca espacio libre.

du -sh * | sort -h

Esto se mostrará en formato legible para humanos.

Para enumerar los directorios más grandes del directorio actual en formato legible por humanos:

du -sh * | sort -hr

Una mejor manera de restringir el número de filas puede ser

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

Donde puede aumentar el sufijo de -nbandera para restringir el número de filas enumeradas

Muestra:

[~]$ 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

Hace que sea más conveniente leer :)

Para mostrarlo en 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} }'

Código Awk explicado:

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
}

Salida de muestra:

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

El comando que desea es 'du -sk' du = "uso del disco"

El indicador -k le da salida en kilobytes, en lugar del du predeterminado de los sectores del disco (bloques de 512 bytes).

El indicador -s solo enumerará cosas en el directorio de nivel superior (es decir, el directorio actual, por defecto, o el directorio especificado en la línea de comando). Es extraño que du tenga el comportamiento opuesto de ls a este respecto. Por defecto, du le dará recursivamente el uso del disco de cada subdirectorio. Por el contrario, ls solo proporcionará archivos de lista en el directorio especificado. (ls -R te da un comportamiento recursivo).

Ponga esta declaración de función de shell en sus scripts de inicialización de shell:

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

Lo llamé dulsporque muestra la salida de ambos duy ls(en ese orden):

$ 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

Explicación:

La pasteutilidad crea columnas a partir de su entrada de acuerdo con la especificación que le proporcione. Dados dos archivos de entrada, los pone uno al lado del otro, con una pestaña como separador.

Le damos la salida de du -hs -- "$@" | cut -f1como el primer archivo (flujo de entrada realmente) y la salida de ls -ld -- "$@"como el segundo archivo.

En la función, "$@"evaluará la lista de todos los argumentos de la línea de comandos, cada uno entre comillas dobles. Por lo tanto, comprenderá los caracteres globales y los nombres de ruta con espacios, etc.

Las dobles desventajas ( --) señalan el final de las opciones de línea de comando a duy ls. Sin esto, decir duls -lconfundiría duy cualquier opción duque lsno tenga podría confundir ls(y las opciones que existen en ambas utilidades podrían no significar lo mismo, y sería un desastre).

El cutafter dusimplemente corta la primera columna de la du -hssalida (los tamaños).

Decidí poner el duresultado a la izquierda, de lo contrario habría tenido que administrar una columna tambaleante a la derecha (debido a las diferentes longitudes de los nombres de archivo).

El comando no aceptará banderas de línea de comando.

Esto ha sido probado en ambos bashy en ksh93. No funcionará con /bin/sh.

Siempre uso du -sk( -kmarca que muestra el tamaño del archivo en kilobytes) en su lugar.

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

ncdu maldiciones du

Esta increíble utilidad CLI le permite encontrar fácilmente los archivos y directorios grandes de forma interactiva.

Por ejemplo, desde el interior del árbol de un proyecto bien conocido hacemos:

sudo apt-get install ncdu
ncdu

El resultado es:

Luego, entro hacia abajo y hacia la derecha en mi teclado para ir a la /driverscarpeta, y veo:

ncdu solo calcula los tamaños de archivo de forma recursiva una vez al inicio para todo el árbol, por lo que es eficiente.

"Uso total del disco" versus "Tamaño aparente" es análogo a du, y lo he explicado en: ¿por qué la salida de `du` a menudo es tan diferente de` du -b`

Página de inicio del proyecto: https://dev.yorhel.nl/ncdu

Preguntas 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

Probado en Ubuntu 16.04.

ncdu uso no interactivo

Otra característica interesante ncdues que primero puede volcar los tamaños en un formato JSON y luego reutilizarlos.

Por ejemplo, para generar el archivo ejecutado:

ncdu -o ncdu.json

y luego examínelo interactivamente con:

ncdu -f ncdu.json

Esto es muy útil si se trata de un sistema de archivos muy grande y lento como NFS.

De esta forma, primero puede exportar solo una vez, lo que puede llevar horas, y luego explorar los archivos, salir, explorar nuevamente, etc.

El formato de salida es solo JSON, por lo que también es fácil reutilizarlo con otros programas, por ejemplo:

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

revela una estructura de datos de árbol de directorio simple:

[
    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"
                },

Probado en Ubuntu 18.04.

du -sch * en el mismo directorio.

Este es uno que me gusta

actualización : no me gustó el anterior porque no mostraba archivos en el directorio actual, solo enumeraba directorios.

Ejemplo de salida para /varen 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

Estas son todas excelentes sugerencias, pero la que uso es:

du -ksh * | sort -n -r

-ksh se asegura de que los archivos y las carpetas se enumeren en un formato legible por humanos y en megabytes, kilobytes, etc. Luego, los ordena numéricamente y revierte el orden para que los primeros sean los más grandes.

El único inconveniente de este comando es que la computadora no sabe que Gigabyte es más grande que Megabyte, por lo que solo ordenará por números y a menudo encontrará listados como este:

120K
12M
4G

Solo tenga cuidado de mirar la unidad.

Este comando también funciona en Mac (mientras sort -hque no lo hace, por ejemplo).

du -S

du tienen otra opción útil: -S, --separate-dirsnarración du no incluye el tamaño de subdirectorios - práctico en algunas ocasiones.

Ejemplo 1: muestra solo los tamaños de archivo en un directorio:

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

Ejemplo 2: muestra los tamaños de archivo y subdirectorios en el directorio:

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

du -sm * | sort -nr

Salida por tamaño

mira el ducomando para eso

solo una advertencia, si desea comparar tamaños de archivos. du produce diferentes resultados dependiendo del sistema de archivos, tamaño de bloque, ....

Puede suceder que el tamaño de los archivos sea diferente, por ejemplo, comparando el mismo directorio en su disco duro local y un dispositivo de almacenamiento masivo USB. Utilizo el siguiente script, incluido ls para resumir el tamaño del directorio. El resultado es en bytes teniendo en cuenta todos los subdirectorios.

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 visualizar los archivos del directorio actual y los tamaños de subdirectorios de forma recursiva:

du -h .

Para mostrar la misma información de tamaño pero sin imprimir sus subdirectorios de forma recursiva (que puede ser una lista enorme), solo use la opción --max-depth :

du -h --max-depth=1 .

Durante un tiempo, usé Nautilus (en el escritorio de Gnome en RHEL 6.0) para eliminar archivos en mi carpeta de inicio en lugar de usar el rmcomando en bash. Como resultado, el tamaño total mostrado por

du -sh

no coincidía con la suma del uso del disco de cada subdirectorio, cuando usé

du -sh *

Me tomó un tiempo darme cuenta de que Nautilus envía los archivos eliminados a su carpeta Papelera, y esa carpeta no aparece en el du -sh *comando. Entonces, solo quería compartir esto, en caso de que alguien enfrentara el mismo problema.

Hmm, la mejor manera es usar este comando:

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

Entonces podrá obtener carpetas de todos los tamaños en todo su servidor. Fácil de ayudarlo a encontrar los tamaños más grandes.

Lo siguiente es fácil de recordar

ls -ltrapR

listar el contenido del directorio

-l uso un formato de listado largo

-t ordenar por tiempo de modificación, el más nuevo primero

-r, - orden inverso inverso al ordenar

-a, --todos no ignoran las entradas que comienzan con.

-p, --indicator-style = barra anexa / indicador a directorios

-R, - subdirectorios de lista recursiva recursivamente

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

Si desea más control sobre el sizeque desea enumerar los directorios, puede usar el modificador threshold( -t) como en:

$ du -ht 1000000000 | sort --reverse

du- disk usage
h - formato legible por humanos
t - tamaño del umbral

Aquí, queremos enumerar todos los directorios que tengan un tamaño superior a 1 GB.

$ du -ht 1G | sort --reverse

Explicacion :

Las unidades que se describen en la wiki son las siguientes:

K, M, G, T, P, E, Z, Y (potencias de 1024) o
KB, MB, GB, TB, PB, EB, ZB, YB (potencias de 1000).

Me encontré con un problema similar al descrito por Martin Wilde, en mi caso comparando el mismo directorio en dos servidores diferentes después de duplicar con rsync.

En lugar de usar un script, agregué el -bindicador al duque cuenta el tamaño en bytes y, por lo que puedo determinar, eliminé las diferencias en los dos servidores. Todavía puede usar -s -hpara obtener una salida comprensible.

colóquelo en el script de inicio como .bashrc ... ajuste def según sea necesario.

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

escriba "ls -ltrh / path_to_directory"