it-swarm.com.de

Wie kann ich feststellen, was so viel Platz beansprucht?

Ich habe df -h verwendet, um die Verwendung von lesbaren Festplatten auszudrucken. Ich möchte herausfinden, was so viel Platz einnimmt. Gibt es beispielsweise eine Möglichkeit, diesen Befehl so weiterzuleiten, dass Dateien gedruckt werden, die größer als 1 GB sind? Andere Ideen?

Vielen Dank

30
syn4k

Ich benutze dieses oft.

du -kscx *

Die Ausführung kann eine Weile dauern, zeigt Ihnen jedoch an, wo der Speicherplatz verwendet wird.

26
toppledwagon

Vielleicht möchten Sie das Dienstprogramm ncdu ausprobieren, das sich unter folgender Adresse befindet: http://dev.yorhel.nl/ncd

Der Inhalt eines Dateisystems oder eines Verzeichnisbaums wird schnell summiert und die Ergebnisse werden nach Größe sortiert gedruckt. Es ist eine wirklich gute Möglichkeit, interaktiv einen Drilldown durchzuführen und zu sehen, was Speicherplatz beansprucht.

Außerdem kann es schneller sein als einige du Kombinationen.

Die typische Ausgabe sieht wie folgt aus:

ncdu 1.7 ~ Use the arrow keys to navigate, press ? for help                                                         
--- /data ----------------------------------------------------------------------------------------------------------
  163.3GiB [##########] /docimages                                                                                  
   84.4GiB [#####     ] /data
   82.0GiB [#####     ] /sldata
   56.2GiB [###       ] /prt
   40.1GiB [##        ] /slisam
   30.8GiB [#         ] /isam
   18.3GiB [#         ] /mail
   10.2GiB [          ] /export
    3.9GiB [          ] /edi   
    1.7GiB [          ] /io     
    1.2GiB [          ] /dmt
  896.7MiB [          ] /src
  821.5MiB [          ] /upload
  691.1MiB [          ] /client
  686.8MiB [          ] /cocoon
  542.5MiB [          ] /hist
  358.1MiB [          ] /savsrc
  228.9MiB [          ] /help
  108.1MiB [          ] /savbin
  101.2MiB [          ] /dm
   40.7MiB [          ] /download
35
ewwhite

Sie können den Befehl find verwenden. Beispiel:

find /home/ -size +1073700000c -print
8
ChriSxStyles

Ich selbst benutze

 Du -c --max-Tiefe = 4/dir | sort -n 

dies gibt den von einem Verzeichnis und seinen Unterverzeichnissen bis zu 4 tiefen Speicherplatz zurück, sort -n setzt den größten letzten.

Neue Versionen von sort können "lesbare" Größen verarbeiten, sodass viel besser lesbare verwendet werden können

du -hc --max-depth=4 /dir | sort -h
6
Hubert Kario

Suchen Sie rekursiv nach großen Dateien in einem Verzeichnis

Da ich feststellen musste, was so viel Platz beansprucht? viel Zeit, schrieb ich dieses kleine Skript, um nach einer großen Beschäftigung auf einem zu suchen bestimmtes Gerät (ohne Argument wird das aktuelle Verzeichnis durchsucht und nach > 256 MB Verzeichniseinträgen gesucht):

#!/bin/bash

humansize() {
    local _c=$1 _i=0 _a=(b K M G T P)
    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} ${_a[_i]}
}

export device=$(stat -c %d "${1:-.}")
export minsize=${2:-$((256*1024**2))}

rdu() {
    local _dir="$1" _spc="$2" _crt _siz _str
    while read _crt;do
    if [ $(stat -c %d "$_crt") -eq $device ];then
            _siz=($(du -xbs "$_crt"))
            if [ $_siz -gt $minsize ];then
        humansize $_siz _str
        printf "%s%12s%14s_%s\n" "$_spc" "$_str" \\ "${_crt##*/}"
        [ $d "$_crt" ] && rdu "$_crt" "  $_spc"
        fi
    fi
    done < <(
    find "$_dir" -mindepth 1 -maxdepth 1 -print
    )
}

rdu "${1:-.}"

Anwendungsbeispiel:

./rdu.sh /usr 100000000
       1.53G             \_lib
       143.52M             \_i386-linux-gnu
       348.16M             \_x86_64-linux-gnu
       107.80M             \_jvm
         100.20M             \_Java-6-openjdk-AMD64
           100.17M             \_jre
              99.65M             \_lib
       306.63M             \_libreoffice
         271.75M             \_program
       107.98M             \_chromium
      99.57M             \_lib32
     452.47M             \_bin
       2.50G             \_share
       139.63M             \_texlive
         129.74M             \_texmf-dist
       478.36M             \_locale
       124.49M             \_icons
       878.09M             \_doc
         364.02M             \_texlive-latex-extra-doc
           359.36M             \_latex

Kleiner Scheck:

du -bs /usr/share/texlive/texmf-dist
136045774   /usr/share/texlive/texmf-dist
echo 136045774/1024^2 | bc -l
129.74336051940917968750

Hinweis: Wenn Sie -b Anstelle von -k Verwenden, teilen Sie du mit, dass nur verwendete Bytes, aber kein effektiver reservierter Speicherplatz (nach 512-Byte-Block) zusammengefasst werden sollen. Um über die Blockgröße zu arbeiten, müssen Sie die Zeile du -xbs ... Durch du -xks Ändern, b in _a=(K M G T P) unterdrücken und die Argumentgröße durch 1024 teilen.

... Es gibt eine modifizierte Version (die ich für mich behalten werde), die standardmäßig Blockgrößen verwendet, aber als erstes Argument -b Akzeptiert für die Byteberechnung:

Bearbeiten: Neue Version

Nach einigen Arbeiten gibt es eine viel neuere Version schneller und mit Ausgabe in absteigender Größenreihenfolge sortiert:

#!/bin/bash

if [ "$1" == "-b" ] ;then
    shift
    export units=(b K M G T P)
    export duargs="-xbs"
    export minsize=${2:-$((256*1024**2))}
else
    export units=(K M G T P)
    export duargs="-xks"
    export 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]}
}

export device=$(stat -c %d "${1:-.}")

rdu() {
    local _dir="$1" _spc="$2" _crt _siz _str
    while read _siz _crt;do
        if [ $_siz -gt $minsize ];then
        humansize $_siz _str
        printf "%s%12s%14s_%s\n" "$_spc" "$_str" \\ "${_crt##*/}"
        [ -d "$_crt" ] &&
        [ $(stat -c %d "$_crt") -eq $device ] &&
            rdu "$_crt" "  $_spc"
    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 |
        sort -nr
    )
}

rdu "${1:-.}"
1
F. Hauri

Mit vom Menschen lesbaren Größen:

du -hscx *
1
Jekis

Verwenden Sie den folgenden Einzeiler, um die größten Top-20-Verzeichnisse im aktuellen Ordner anzuzeigen:

du -ah . | sort -rh | head -20

oder:

du -a . | sort -rn | head -20

Für die 20 größten Dateien im aktuellen Verzeichnis (rekursiv):

ls -1Rs | sed -e "s/^ *//" | grep "^[0-9]" | sort -nr | head -n20

oder mit lesbaren Größen:

ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20

Der zweite Befehl, um unter OSX/BSD ordnungsgemäß zu arbeiten (da sort kein -h Hat), müssen Sie sort von coreutils installieren. Fügen Sie dann den Ordner bin zu Ihrem PATH hinzu.

Diese Aliase sind also nützlich, um sie in Ihren rc -Dateien zu haben (jedes Mal, wenn Sie sie benötigen):

alias big='du -ah . | sort -rh | head -20'
alias big-files='ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20'
0
kenorb