Utilisation de ls pour répertorier les répertoires et leur taille totale

Est-il possible d'utiliser lssous Unix pour lister la taille totale d'un sous-répertoire et tout son contenu par opposition à l'habituel 4Kqui (je suppose) n'est que le fichier de répertoire lui-même?

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

Après avoir parcouru les pages de manuel, je monte vide.

Essayez quelque chose comme:

du -sh *

version courte de:

du --summarize --human-readable *

Explication:

du: D isk U sage

-s: Afficher un résumé pour chaque fichier spécifié. (Équivalent à -d 0)

-h: Sortie "lisible par l'homme". Utilisez les suffixes unitaires: B yte, K ibibyte (KiB), M ebibyte (MiB), G ibibyte (GiB), T ebibyte (TiB) et P ebibyte (PiB). (BASE2)

du -sk * | sort -ntriera les dossiers par taille. Utile lorsque vous cherchez à libérer de l'espace ..

du -sh * | sort -h

Cela sera affiché dans un format lisible par l'homme.

Pour répertorier les répertoires les plus volumineux du répertoire actuel au format lisible par l'homme:

du -sh * | sort -hr

Une meilleure façon de limiter le nombre de lignes peut être

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

Où vous pouvez augmenter le suffixe de l' -nindicateur pour limiter le nombre de lignes répertoriées

Échantillon:

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

Cela rend la lecture plus pratique :)

Pour l'afficher au ls -lhformat, utilisez:

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

Code awk expliqué:

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
}

Exemple de sortie:

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

La commande que vous voulez est 'du -sk' du = "utilisation du disque"

L'indicateur -k vous donne la sortie en kilo-octets, plutôt que la valeur par défaut des secteurs de disque (blocs de 512 octets).

L'indicateur -s répertorie uniquement les éléments du répertoire de niveau supérieur (c'est-à-dire le répertoire actuel, par défaut, ou le répertoire spécifié sur la ligne de commande). C'est étrange que du a le comportement opposé de ls à cet égard. Par défaut, du vous donnera récursivement l'utilisation du disque de chaque sous-répertoire. En revanche, ls ne donnera que les fichiers de liste dans le répertoire spécifié. (ls -R vous donne un comportement récursif.)

Mettez cette déclaration de fonction shell dans vos scripts d'initialisation shell:

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

Je l'ai appelé dulscar il montre la sortie des deux duet ls(dans cet ordre):

$ 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

Explication:

L' pasteutilitaire crée des colonnes à partir de son entrée selon la spécification que vous lui donnez. Étant donné deux fichiers d'entrée, il les place côte à côte, avec un onglet comme séparateur.

Nous lui donnons la sortie du du -hs -- "$@" | cut -f1premier fichier (flux d'entrée vraiment) et la sortie du ls -ld -- "$@"deuxième fichier.

Dans la fonction, "$@"sera évalué dans la liste de tous les arguments de ligne de commande, chacun entre guillemets. Il comprendra donc les caractères globbing et les noms de chemin avec des espaces, etc.

Le double moins ( --) signale la fin des options de ligne de commande à duet ls. Sans cela, dire duls -lserait confus duet toute option pour ducela lsn'aurait pas confondu ls(et les options qui existent dans les deux utilitaires pourraient ne pas signifier la même chose, et ce serait un joli gâchis).

L' cutaprès ducoupe simplement la première colonne de la du -hssortie (les tailles).

J'ai décidé de mettre la dusortie sur la gauche, sinon j'aurais dû gérer une colonne de droite bancale (en raison de la longueur variable des noms de fichiers).

La commande n'acceptera pas d'indicateurs de ligne de commande.

Cela a été testé à la fois bashet en ksh93. Cela ne fonctionnera pas avec /bin/sh.

J'utilise toujours du -sk( -kindicateur indiquant la taille du fichier en kilo-octets) à la place.

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

ncdu ncurses du

Cet utilitaire CLI génial vous permet de trouver facilement les gros fichiers et répertoires de manière interactive.

Par exemple, depuis l'intérieur d' un arbre d' un projet bien connu, nous faisons:

sudo apt-get install ncdu
ncdu

Le résultat est:

Ensuite, j'entre en bas et à droite sur mon clavier pour aller dans le /driversdossier, et je vois:

ncdu ne calcule la taille des fichiers récursivement qu'une seule fois au démarrage pour l'arborescence entière, il est donc efficace.

"Utilisation totale du disque" vs "Taille apparente" est analogue à du, et je l'ai expliqué à: pourquoi la sortie de `du` est-elle souvent si différente de` du -b`

Page d'accueil du projet: https://dev.yorhel.nl/ncdu

Questions connexes:

• /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

Testé dans Ubuntu 16.04.

ncdu utilisation non interactive

Une autre fonctionnalité intéressante de ncduest que vous pouvez d'abord vider les tailles au format JSON, puis les réutiliser.

Par exemple, pour générer le fichier exécuté:

ncdu -o ncdu.json

puis l'examiner de manière interactive avec:

ncdu -f ncdu.json

Ceci est très utile si vous avez affaire à un système de fichiers très volumineux et lent comme NFS.

De cette façon, vous pouvez d'abord exporter une seule fois, ce qui peut prendre des heures, puis explorer les fichiers, quitter, explorer à nouveau, etc.

Le format de sortie est juste JSON, il est donc facile de le réutiliser avec d'autres programmes, par exemple:

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

révèle une structure de données d'arborescence de répertoires 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"
                },

Testé dans Ubuntu 18.04.

du -sch * dans le même répertoire.

C'est celui que j'aime

mise à jour : je n'ai pas aimé le précédent car il n'affichait pas les fichiers du répertoire courant, il ne listait que les répertoires.

Exemple de sortie pour /varsur 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

Ce sont toutes d'excellentes suggestions, mais celle que j'utilise est:

du -ksh * | sort -n -r

-ksh s'assure que les fichiers et les dossiers sont répertoriés dans un format lisible par l'homme et en mégaoctets, kilo-octets, etc. Ensuite, vous les triez numériquement et inversez le tri afin qu'il place les plus gros en premier.

Le seul inconvénient de cette commande est que l'ordinateur ne sait pas que Gigabyte est plus grand que Megabyte donc il ne triera que par numéros et vous trouverez souvent des listes comme celle-ci:

120K
12M
4G

Faites juste attention à regarder l'unité.

Cette commande fonctionne également sur Mac (contrairement à sort -hpar exemple).

du -S

du a une autre option utile: -S, --separate-dirsdire à du ne pas inclure la taille des sous-répertoires - pratique à certaines occasions.

Exemple 1 - affiche uniquement les tailles de fichier dans un répertoire:

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

Exemple 2 - montre la taille des fichiers et les sous-répertoires du répertoire:

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

du -sm * | sort -nr

Sortie par taille

regardez la ducommande pour cela

juste un avertissement, si vous voulez comparer les tailles de fichiers. du produit des résultats différents selon le système de fichiers, la taille du bloc, ....

Il peut arriver que la taille des fichiers soit différente, par exemple en comparant le même répertoire sur votre disque dur local et un périphérique de stockage de masse USB. J'utilise le script suivant, y compris ls pour résumer la taille du répertoire. Le résultat en octets tenant compte de tous les sous-répertoires.

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"

Pour afficher récursivement la taille des fichiers et des sous-répertoires du répertoire actuel:

du -h .

Pour afficher les mêmes informations de taille mais sans imprimer leurs sous-répertoires de manière récursive (ce qui peut être une énorme liste), utilisez simplement l' option --max-depth :

du -h --max-depth=1 .

Pendant un certain temps, j'ai utilisé Nautilus (sur le bureau Gnome sur RHEL 6.0) pour supprimer les fichiers de mon dossier personnel au lieu d'utiliser la rmcommande dans bash. Par conséquent, la taille totale indiquée par

du -sh

ne correspond pas à la somme de l'utilisation du disque de chaque sous-répertoire, lorsque j'ai utilisé

du -sh *

Il m'a fallu un certain temps pour réaliser que Nautilus envoie les fichiers supprimés dans son dossier Corbeille, et que ce dossier n'est pas répertorié dans la du -sh *commande. Donc, je voulais juste partager cela, au cas où quelqu'un serait confronté au même problème.

Hmm, la meilleure façon est d'utiliser cette commande:

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

Ensuite, vous pourrez obtenir tous les dossiers de tailles sur tout votre serveur. Facile à vous aider à trouver les plus grandes tailles.

Ce qui suit est facile à retenir

ls -ltrapR

lister le contenu du répertoire

-l utilise un format de liste longue

-t tri par heure de modification, le plus récent en premier

-r, - inverser l'ordre inverse lors du tri

-a, --all n'ignore pas les entrées commençant par.

-p, --indicator-style = barre oblique ajouter / indicateur aux répertoires

-R, --recursive liste les sous-répertoires récursivement

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

Si vous voulez plus de contrôle sur les sizerépertoires sur lesquels vous souhaitez lister, vous pouvez utiliser le commutateur threshold( -t) comme dans:

$ du -ht 1000000000 | sort --reverse

du- disk usage
h - format lisible par l'homme
t - taille du seuil

Ici, nous voulons répertorier tous les répertoires dont la taille est supérieure à 1 Go.

$ du -ht 1G | sort --reverse

Explication :

Les unités décrites dans le wiki sont les suivantes:

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

J'ai rencontré un problème similaire à celui décrit par Martin Wilde, dans mon cas, en comparant le même répertoire sur deux serveurs différents après la mise en miroir avec rsync.

Au lieu d'utiliser un script, j'ai ajouté le -bdrapeau à celui duqui compte la taille en octets et autant que je peux déterminer, éliminé les différences sur les deux serveurs. Vous pouvez toujours utiliser -s -hpour obtenir une sortie compréhensible.

placez dans le script init comme .bashrc ... ajustez def si nécessaire.

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

tapez "ls -ltrh / path_to_directory"