Ls gebruiken om mappen en hun totale grootte weer te geven

Is het mogelijk om lsin Unix te gebruiken om de totale grootte van een submap en al zijn inhoud weer te geven, in tegenstelling tot de gebruikelijke 4Kdie (ik neem aan) is alleen het directorybestand zelf?

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

Na het doorzoeken van de man-pagina’s kom ik er leeg uit.

Antwoord 1, autoriteit 100%

Probeer zoiets als:

du -sh *

korte versie van:

du --summarize --human-readable *

Uitleg:

du: Disk Usage

-s: geef een samenvatting weer voor elk opgegeven bestand. (Equivalent aan -d 0)

-h: “door mensen leesbare” uitvoer. Gebruik eenheidsachtervoegsels: Byte, Kibibyte (KiB), Mebibyte (MiB), Gibibyte ( GiB), Tebibyte (TiB) en Pebibyte (PiB). (BASE2)

Antwoord 2, autoriteit 21%

du -sk * | sort -nsorteert de mappen op grootte. Handig als je ruimte wilt vrijmaken..

of du -sh * | sort -hgebruikt in door mensen leesbare modus

Antwoord 3, autoriteit 7%

du -sh * | sort -h

Dit wordt weergegeven in een voor mensen leesbaar formaat.

Antwoord 4, autoriteit 4%

Om de grootste mappen van de huidige map in een voor mensen leesbaar formaat weer te geven:

du -sh * | sort -hr

Een betere manier om het aantal rijen te beperken is

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

Waar u het achtervoegsel van de vlag -nkunt vergroten om het aantal weergegeven rijen te beperken

Voorbeeld:

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

Het maakt het gemakkelijker om te lezen 🙂

Antwoord 5, autoriteit 2%

Om het in ls -lhformaat weer te geven, gebruik je:

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

Awk-code uitgelegd:

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
}

Voorbeelduitvoer:

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

Antwoord 6

Het gewenste commando is ‘du -sk’ du = “schijfgebruik”

De vlag -k geeft je uitvoer in kilobytes, in plaats van de standaardwaarde van schijfsectoren (blokken van 512 bytes).

De vlag -s geeft alleen dingen weer in de map op het hoogste niveau (d.w.z. de huidige map, standaard, of de map die is opgegeven op de opdrachtregel). Het is vreemd dat du in dit opzicht het tegenovergestelde gedrag van ls heeft. Standaard geeft du u recursief het schijfgebruik van elke submap. Daarentegen geeft ls alleen lijstbestanden in de opgegeven map. (ls -R geeft recursief gedrag.)

Antwoord 7

Zet deze shell-functiedeclaratie in uw shell-initialisatiescripts:

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

Ik noemde het dulsomdat het de uitvoer toont van zowel duals ls(in die volgorde):

$ 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

Uitleg:

Het hulpprogramma pastemaakt kolommen van de invoer volgens de specificatie die u eraan geeft. Met twee invoerbestanden zet het ze naast elkaar, met een tab als scheidingsteken.

We geven het de output van du -hs -- "$@" | cut -f1als het eerste bestand (eigenlijk invoerstroom) en de uitvoer van ls -ld -- "$@"als het tweede bestand.

In de functie zal "$@"resulteren in de lijst van alle commandoregelargumenten, elk tussen dubbele aanhalingstekens. Het zal daarom globbing-tekens en padnamen met spaties enz. begrijpen.

De dubbele mintekens (--) geven het einde van de opdrachtregelopties aan voor duen ls. Zonder deze zou het zeggen van duls -lduverwarren en elke optie voor dudie lsniet heeft zou verwarren ls(en de opties die in beide hulpprogramma’s bestaan, betekenen misschien niet hetzelfde, en het zou een behoorlijke puinhoop zijn).

De cutna duknipt simpelweg de eerste kolom van de du -hsoutput (de maten).

Ik besloot om de du-uitvoer aan de linkerkant te plaatsen, anders had ik een wankele rechterkolom moeten beheren (vanwege de verschillende lengtes van bestandsnamen).

De opdracht accepteert geen opdrachtregelvlaggen.

Dit is getest in zowel bashals in ksh93. Het werkt niet met /bin/sh.

Antwoord 8

ncdu(ncurses du)

Met dit geweldige CLI-hulpprogramma kun je gemakkelijk interactief de grote bestanden en mappen (recursieve totale grootte) vinden.

Bijvoorbeeld vanuit de hoofdmap van een bekend open source-projectwij doen:

sudo apt install ncdu
ncdu

Het resultaat is:

Vervolgens typ ik naar beneden en naar rechts op mijn toetsenbord om naar de map /driverste gaan, en ik zie:

ncduberekent de bestandsgrootte slechts eenmaal recursief bij het opstarten voor de hele boomstructuur, dus het is efficiënt.

“Totaal schijfgebruik” versus “schijnbare grootte” is analoog aan du, en ik heb het uitgelegd op: waarom verschilt de output van `du` vaak zo van `du -b`

Startpagina van het project: https://dev.yorhel.nl/ncdu

Verwante vragen:

• https://unix.stackexchange .com/questions/67806/hoe-recursief-het-opgeslagen-bedrag-in-directory-vinden/67808
• https://unix.stackexchange.com /questions/125429/tracking-down-where-disk-space-has-gone-on-linux
• https:/ /askubuntu.com/questions/57603/how-to-list-recursive-file-sizes-of-files-and-directories-in-a-directory
• https://serverfault.com/questions/43296/how-does-one-find-which-files-are-taking-up-80-of-the-space-on-a-linux-webserve

Getest in Ubuntu 16.04.

Ubuntu-lijst root

U wilt waarschijnlijk:

ncdu --exclude-kernfs -x /

waar:

• -xstopt met het overschrijden van bestandssysteembarrières
• --exclude-kernfsslaat speciale bestandssystemen over, zoals /sys

MacOS 10.15.5 lijst root

Om root /correct weer te geven op dat systeem, had ik ook --exclude-firmlinksnodig, bijvoorbeeld:

brew install ncdu
cd /
ncdu --exclude-firmlinks

anders leek het in een oneindige lus te gaan, waarschijnlijk als gevolg van: https://www.swiftforensics.com/2019/10/macos-1015-volumes-firmlink-magic.html

De dingen die we leren uit liefde.

ncduniet-interactief gebruik

Een andere leuke functie van ncduis dat je de formaten eerst in een JSON-indeling kunt dumpen en ze later opnieuw kunt gebruiken.

Bijvoorbeeld om de bestandsrun te genereren:

ncdu -o ncdu.json

en bekijk het dan interactief met:

ncdu -f ncdu.json

Dit is erg handig als je te maken hebt met een erg groot en traag bestandssysteem zoals NFS.

Op deze manier kunt u eerst maar één keer exporteren, wat uren kan duren, en vervolgens de bestanden verkennen, afsluiten, opnieuw verkennen, enz.

Het uitvoerformaat is alleen JSON, dus het is gemakkelijk om het ook met andere programma’s opnieuw te gebruiken, bijvoorbeeld:

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

onthult een eenvoudige directory-boomgegevensstructuur:

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

Getest in Ubuntu 18.04.

Antwoord 9

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

Antwoord 10

Ik gebruik in plaats daarvan altijd du -sk(-kvlag met bestandsgrootte in kilobytes).

Antwoord 11

Dit is er een die ik leuk vind

update: ik vond de vorige niet leuk omdat er geen bestanden in de huidige map werden weergegeven, maar alleen mappen.

Voorbeelduitvoer voor /varop 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

Antwoord 12

Om de bestanden en submappen van de huidige map recursief weer te geven:

du -h .

Om dezelfde grootte-informatieweer te geven, maar zonderhun submappen recursief af te drukken (wat een enorme lijst kan zijn), gebruikt u gewoon de –max-depth optie:

du -h --max-depth=1 .

Antwoord 13

du -sch * in dezelfde map.

Antwoord 14

Dit zijn allemaal geweldige suggesties, maar degene die ik gebruik is:

du -ksh * | sort -n -r

-kshzorgt ervoor dat de bestanden en mappen worden weergegeven in een voor mensen leesbaar formaat en in megabytes, kilobytes, enz. Vervolgens sorteert u ze numeriek en keert u de sortering om zodat de grotere eerst worden geplaatst .

Het enige nadeel van dit commando is dat de computer niet weet dat Gigabyte groter is dan Megabyte, dus het sorteert alleen op nummer en je zult vaak lijsten als deze vinden:

120K
12M
4G

Wees voorzichtig om naar het apparaat te kijken.

Dit commando werkt ook op de Mac (terwijl sort -hdat bijvoorbeeld niet doet).

Antwoord 15

du -S

duhebben nog een andere handige optie: -S, --separate-dirsvertellend dat dude grootte van subdirectories niet moet opnemen – soms handig .

Voorbeeld 1 – toont alleende bestandsgroottes in een map:

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

Voorbeeld 2 – toont de bestandsgroottes en submappen in de map:

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

Antwoord 16

du -sm * | sort -nr

Uitvoer op grootte

Antwoord 17

slechts een waarschuwing, als u de grootte van bestanden wilt vergelijken. du produceert verschillende resultaten afhankelijk van bestandssysteem, blokgrootte, … .

Het kan voorkomen dat de grootte van de bestanden verschilt, b.v. vergelijken van dezelfde map op uw lokale harde schijf en een USB-apparaat voor massaopslag. Ik gebruik het volgende script, inclusief ls om de mapgrootte samen te vatten. Het resultaat in bytes, rekening houdend met alle subdirectories.

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"

Antwoord 18

Als u meer controle wilt over de sizewaarover u de mappen wilt weergeven, kunt u de threshold(-t) gebruiken schakelen als in:

$ du -ht 1000000000 | sort --reverse

du– disk usage
h– door mensen leesbare indeling
t– drempelgrootte

Hier willen we alle mappen weergeven die groter zijn dan 1 GB.

$ du -ht 1G | sort --reverse

Uitleg:

Eenheden die beschreven zijn in wikivolgen:

K, M, G, T, P, E, Z, Y (machten van 1024) of
KB, MB, GB, TB, PB, EB, ZB, YB (machten van 1000).

Antwoord 19

kijk daarvoor naar de opdracht du

Antwoord 20

Een tijdje heb ik Nautilus (op Gnome-desktop op RHEL 6.0) gebruikt om bestanden in mijn thuismap te verwijderen in plaats van de opdracht rmin bash te gebruiken. Als gevolg hiervan wordt de totale grootte weergegeven door

du -sh

kwam niet overeen met de som van het schijfgebruik van elke submap, toen ik gebruikte

du -sh *

Het duurde even voordat ik me realiseerde dat Nautilus de verwijderde bestanden naar de Prullenbak stuurt, en die map staat niet in de du -sh *-opdracht. Dus ik wilde dit gewoon delen, voor het geval iemand hetzelfde probleem zou hebben.

Antwoord 21

Hmm, de beste manier is om dit commando te gebruiken:

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

Dan kun je mappen van alle formaten op je hele server krijgen. Makkelijk om je te helpen om de grootste maten te vinden.

Antwoord 22

Ik kwam een probleem tegen dat vergelijkbaar is met wat Martin Wilde beschreef, in mijn geval het vergelijken van dezelfde map op twee verschillende servers na spiegelen met rsync.

In plaats van een script te gebruiken, heb ik de vlag -btoegevoegd aan de dudie de grootte in bytes telt en voor zover ik kan bepalen de verschillen tussen de twee geëlimineerd servers. Je kunt nog steeds -s -hgebruiken om een begrijpelijke uitvoer te krijgen.

Antwoord 23

Het volgende is gemakkelijk te onthouden

ls -ltrapR

map inhoud weergeven

-l gebruik een lange notatie-indeling

-t sorteer op wijzigingstijd, nieuwste eerst

-r, –reverse
omgekeerde volgorde tijdens het sorteren

-a, –all
negeer geen vermeldingen die beginnen met .

-p, –indicator-style=slash
toevoegen / indicator aan mappen

-R, –recursief
submappen recursief weergeven

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

Antwoord 24

plaats in init-script zoals .bashrc … pas def aan waar nodig.

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

Antwoord 25

Haal alleen de grootte op in bytes, van ls.

ls -ltr | head -n1 | cut -d' ' -f2

Antwoord 26

Het is belangrijk op te merken dat duu schijfgebruik geeft. Verschillende machines kunnen verschillende blokgroottes gebruiken, dus op één machine kan een blok 4096 bytes zijn en een andere machine kan blokgroottes van 2048 bevatten. Als ik 10 1 byte-bestanden in een machine stop met blokken van 4096 bytes en 10 1 byte-bestand in een machine met blokken van 2048 bytes, zou du -hrespectievelijk ~40k en ~20k rapporteren.

Als u de grootte van alle bestanden in een map wilt weten, kunt u voor elke map iets doen als:

for x in ./*;
do
    if [[ -f "$x" ]]; then
        ls -al "$x"
    fi
done | awk '{print $6}' | awk '{s+=$1}END{print s}'

Dit geeft je de totale grootte van alle bestanden in een map.

Antwoord 27

find . -maxdepth 1 -exec du --apparent-size --max-depth=0 --null '{}' ';' |\
  sort -k1 -nr --zero-terminated |\
  cut -f2 --zero-terminated |\
  xargs --null -n 1 du -h --apparent-size --max-depth=0

Kenmerken:

• Aangezien Linux-bestandsnamen nieuwe regels of spaties kunnen hebben, gebruiken we null-tekens om bestands-/mapnamen af te bakenen.
• We sorteren de bestanden/mappen op grootte.
• We gebruiken --apparent-sizemet duom een soortgelijk gedrag te krijgen als ls.

Antwoord 28

typ “ls -ltrh /path_to_directory”