आप आकार के अनुसार डू आउटपुट कैसे क्रिएट करते हैं?

Question

आप du -sh /dir/*आकार के अनुसार कैसे क्रमबद्ध करते हैं ? मैंने एक साइट पढ़ी है जिसमें कहा गया है | sort -nलेकिन यह स्पष्ट रूप से सही नहीं है। यहाँ एक उदाहरण है जो गलत है।

[~]# du -sh /var/* | sort -n
0       /var/mail
1.2M    /var/www
1.8M    /var/tmp
1.9G    /var/named
2.9M    /var/run
4.1G    /var/log
8.0K    /var/account
8.0K    /var/crash
8.0K    /var/cvs
8.0K    /var/games
8.0K    /var/local
8.0K    /var/nis
8.0K    /var/opt
8.0K    /var/preserve
8.0K    /var/racoon
12K     /var/aquota.user
12K     /var/portsentry
16K     /var/ftp
16K     /var/quota.user
20K     /var/yp
24K     /var/db
28K     /var/empty
32K     /var/lock
84K     /var/profiles
224M    /var/netenberg
235M    /var/cpanel
245M    /var/cache
620M    /var/lib
748K    /var/spool

Comments

मुझे पता था कि मैंने इसे पहले देखा था । उच्चतम मतदान जवाब बहुत अच्छा नहीं है, लेकिन दूसरों रहे हैं बेहतर ।

— गिल्स

स्वीकृत उत्तर sort -hने मेरे लिए उबंटू 16.04 LTS में अगस्त 2017 में काम किया। सबसे पहले मैं अपने आरोहित ड्राइव को cd /mnt(फस्टैब में यूयूआईडी द्वारा माउंट किया गया) ढूंढता हूं । तब मैं है du >~/dumnt.out तो sort -h ~/dumnt.out >~/dumntsort.outफिर मैं `पूंछ ~ / dumntsort.out सबसे बड़ा अंतरिक्ष हॉग को देखने के लिए कर सकते हैं।

— एसडीसोलर

Answer 1

यदि आपके पास जीएनयू कोर्यूटिल्स (अधिकांश लिनक्स वितरण में आम) है, तो आप उपयोग कर सकते हैं

du -sh -- * | sort -h

-hविकल्प बताता है sortकि इनपुट मानव पठनीय प्रारूप है (यूनिट के साथ संख्या; 1024-आधारित ताकि 1023 की तुलना में कम 1K जो मैच के लिए क्या जीएनयू होता है माना जाता है du -hकरता है)।

यह सुविधा GNU कोर यूटिलिटीज 7.5 अगस्त 2009 में जोड़ी गई थी ।

ध्यान दें:

यदि आप मैक OSX के पुराने संस्करण का उपयोग कर रहे हैं, तो आपको कोर्यूटिल्स को brew install coreutils， के साथ स्थापित करने की आवश्यकता है , फिर gsortड्रॉप-इन प्रतिस्थापन के रूप में उपयोग करें sort।

MacOS के नए संस्करण (Mojave पर सत्यापित) sort -hमूल रूप से समर्थन करते हैं ।

Comments

नोट: -rयदि आप शीर्ष पर बड़े लोगों को चाहते हैं, तो सॉर्ट करें

— xenoterracide

पर OSX आप स्थापित कर सकते हैं coreutilsके माध्यम से brewऔर अपने को बिन फ़ोल्डर जोड़ने के PATHअपने में आर सी फ़ाइल, और -hउपलब्ध होना चाहिए।

— kenorb

ओह - -r अनुस्मारक के लिए धन्यवाद। इसका मतलब है कि मुझे tailहॉग देखने के लिए कमांड की आवश्यकता नहीं है ।

— एसडीसोलर

Answer 2

मानव-पठनीय का उपयोग करने के 1k ब्लॉकों को गिनने के लिए -k ध्वज का उपयोग करने का प्रयास करें। फिर, आपके पास एक सामान्य इकाई है और आसानी से एक संख्यात्मक प्रकार कर सकते हैं।

du -ck | sort -n

आपको मानव इकाइयों की आवश्यकता नहीं है, लेकिन यदि आपने किया है, तो इसे करने के तरीकों का एक समूह है। कई लोग ऊपर 1K ब्लॉक तकनीक का उपयोग करते हैं, और फिर डु को दूसरी कॉल करते हैं।

https://serverfault.com/questions/62411/how-can-i-sort-du-h-output-by-size

यदि आप KB इकाइयों को जोड़ा हुआ देखना चाहते हैं, तो उपयोग करें:

du -k | sed -e 's_^\([0-9]*\)_\1 KB_' | sort -n

Comments

अच्छा मुझे परिणाम प्राप्त करने के लिए कुछ और स्थापित करने की आवश्यकता नहीं है

— तारानकी

Answer 3

यदि आपके पास ग्नू कोरुटिल्स का हालिया संस्करण नहीं है , तो आप duबिना -hछांटे आउटपुट प्राप्त करने के लिए कॉल कर सकते हैं , और थोड़े पोस्टप्रोसेसिंग के साथ मानव-अनुकूल आउटपुट का उत्पादन कर सकते हैं। यहां तक ​​कि अगर आपके संस्करण में ध्वज duनहीं है, तो भी काम करने का यह फायदा है -h।

du -k | sort -n | awk '
    function human(x) {
        if (x<1000) {return x} else {x/=1024}
        s="kMGTEPZY";
        while (x>=1000 && length(s)>1)
            {x/=1024; s=substr(s,2)}
        return int(x+0.5) substr(s,1,1)
    }
    {gsub(/^[0-9]+/, human($1)); print}'

यदि आप SI प्रत्यय चाहते हैं (अर्थात 1024 के बजाय 1000 के गुणक), तो whileलूप बॉडी में 1024 से 1000 बदल दें । (ध्यान दें कि शर्त में 1000 का इरादा है, ताकि आपको 1Mइसके बजाय उदाहरण मिलें 1000k।)

यदि आपके duपास बाइट्स में आकार प्रदर्शित करने का विकल्प है (जैसे -bया -B 1- ध्यान दें कि यह डिस्क उपयोग के बजाय वास्तविक फ़ाइल आकारों की गणना का दुष्प्रभाव हो सकता है), s(यानी s=" kMGTEPYZ";) की शुरुआत में एक स्थान जोड़ें, या if (x<1000) {return x} else {x/=1024}शुरुआत में जोड़ें humanसमारोह।

1-10 की रेंज में संख्याओं के लिए एक दशमलव अंक प्रदर्शित करना एक अभ्यास के रूप में पाठक के लिए छोड़ दिया जाता है।

Comments

यह एक बॉक्स समाधान है जिसे मैंने लिनक्स और मैक दोनों पर काम करने के लिए पाया है। बहुत बहुत धन्यवाद!

— ब्रायन ग्राहम

Answer 4

यदि आपके पास नहीं है तो sort -hआप यह कर सकते हैं:

du -sh * | sed 's/\([[:digit:]]\)\t/\1B\t/' | sed 's/\(.\t\)/\t\1/' | sed 's/G\t/Z\t/' | sort -n -k 2d,2 -k 1n,1 | sed 's/Z\t/G\t/'

यह du सूची प्राप्त करता है, प्रत्यय को अलग करता है, और उस का उपयोग करके सॉर्ट करता है। चूंकि <1K के लिए कोई प्रत्यय नहीं है, पहली सीड एक बाइट (बाइट के लिए) जोड़ती है। दूसरी सीड अंक और प्रत्यय के बीच एक सीमांकक जोड़ता है। तीसरा सेड G को Z में परिवर्तित करता है ताकि यह M से बड़ा हो; यदि आपके पास टेराबाइट फ़ाइलें हैं, तो आपको G को Y और T को Z में बदलना होगा। अंत में, हम दो कॉलमों को क्रमबद्ध करते हैं, फिर हम G प्रत्यय को प्रतिस्थापित करते हैं।

Comments

बहुत बढ़िया प्रयास, लेकिन यह मेरे लिए काम करने के करीब नहीं है।

— jvriesem

Answer 5

ओएस एक्स पर, आप होमब्रे के माध्यम से आवश्यक कोरटिल्स स्थापित कर सकते हैं :

brew install coreutils

इस के साथ आप होगा gsortजो भी शामिल है, -hकमांड लाइन पैरामीटर।

Answer 6

यह थोड़ा पर्ल स्क्रिप्ट ट्रिक करती है। इसे duh(या जो आप चाहते हैं) के रूप में सहेजें और इसके साथ कॉल करेंduh /dir/*

#!/usr/bin/perl -w
use strict;

my @line;

sub to_human_readable {
        my ($number) = @_;
        my @postfix = qw( k M G T P );
        my $post;
        my $divide = 1;
        foreach (@postfix) {
                $post = $_;
                last if (($number / ($divide * 1024)) < 1);
                $divide = $divide * 1024;
        }
        $number = int($number/$divide + 0.5);
        return $number . $post;
}

sub trimlengthright {
        my ($txt, $len) = @_;
        if ( length($txt) >= $len ) {
                $txt = substr($txt,0,$len - 1) . " ";
        } else {
                $txt = $txt . " " x ($len - length($txt));
        }
        return $txt;
}

sub trimlengthleft {
        my ($txt, $len) = @_;
        if ( length($txt) >= $len ) {
                $txt = substr($txt,0,$len - 1) . " ";
        } else {
                $txt = " " x ($len - length($txt)) . $txt;
        }
        return $txt;
}

open(DF,"du -ks @ARGV | sort -n |");
while (<DF>) {
        @line = split;
        print &trimlengthleft(&to_human_readable($line[0]),5)," "; # size
        print &trimlengthright($line[1],70),"\n"; # directory
}
close DF;

Answer 7

चूंकि मैक ओएस एक्स में -hविकल्प नहीं है sort, इसलिए मैंने कोशिश की और सीखा sedऔर awkपहले प्रयास के लिए:

du -sk * | sort -g | awk '{ numBytes = $1 * 1024; numUnits = split("B K M G T P", unit); num = numBytes; iUnit = 0; while(num >= 1024 && iUnit + 1 < numUnits) { num = num / 1024; iUnit++; } $1 = sprintf( ((num == 0) ? "%6d%s " : "%6.1f%s "), num, unit[iUnit + 1]); print $0; }'

यह एक लंबी लाइन है। विस्तारित है, यह है:

du -sk * | sort -g | awk '{ 

    numBytes = $1 * 1024; 
    numUnits = split("B K M G T P", unit); 
    num = numBytes; 
    iUnit = 0; 

    while(num >= 1024 && iUnit + 1 < numUnits) { 
        num = num / 1024; 
        iUnit++; 
    } 

    $1 = sprintf( ((num == 0) ? "%6d%s " : "%6.1f%s "), num, unit[iUnit + 1]);
    print $0; 

}'

मैंने इसे मैक ओएस एक्स मावेरिक्स, योसेमाइट, उबंटू 2014-04 awkमें डिफ़ॉल्ट होने के साथ awk(जो है nawk, क्योंकि दोनों awkऔर nawkइंगित करने के लिए /usr/bin/mawk) या gawk की कोशिश की, और वे सभी काम करते हैं।

यहाँ एक मैक पर आउटपुट का एक नमूना है:

     0B  bar
     0B  foo
   4.0K  wah
  43.0M  Documents
   1.2G  Music
   2.5G  Desktop
   4.7G  Movies
   5.6G  VirtualBox VMs
   9.0G  Dropbox
  11.7G  Library
  21.2G  Pictures
  27.0G  Downloads

इसके बजाय du -sk *, मैंने @ स्टीफन के उत्तर में देखा, जहां कुल योग भी प्रदर्शित किए गए हैं, और बिना किसी फाइल सिस्टम माउंट किए बिना, उपयोग करकेdu -skcx *

Answer 8

यहाँ मैं Ubuntu 10.04, CentOS 5.5, FreeBSD और Mac OS X का उपयोग कर रहा हूँ।

मैंने www.geekology.co.za/ और earthinfo.org से विचार उधार लिया , साथ ही ओ'रिली द्वारा "लिनक्स सर्वर हैक्स" से कुख्यात बतख भी । मैं अभी भी इसे अपनी जरूरतों के लिए ढाल रहा हूं। यह अभी भी प्रगति पर काम है (जैसा कि, मैं आज सुबह ट्रेन पर काम कर रहा था।)

#! /usr/bin/env bash
ducks () {
    du -cks -x | sort -n | while read size fname; do
        for unit in k M G T P E Z Y; do
            if [ $size -lt 1024 ]; then
                echo -e "${size}${unit}\t${fname}"
                break
            fi
            size=$((size/1024))
        done
    done
}
ducks > .ducks && tail .ducks

यहाँ उत्पादन है:

stefan@darwin:~ $ ducks
32M src
42M .cpan
43M .macports
754M    doc
865M    Work
1G  .Trash
4G  Library
17G Downloads
30G Documents
56G total

stefan@darwin:~ $

Comments

मुझे लगता है कि आपका मतलब है du -cks -x *? (तारांकन के साथ)

— nopole

तारांकन इस उपयोग में निरर्थक है। कोशिश करो।

— स्टीफन लासिवस्की

क्या आपका मतलब कोड के पहले सेट को फाइल में डालना है ducks, और फिर इसे चलाने के लिए chmod a+x ducksउपयोग ./ducksकरना है? तब मुझे केवल मैक ओएस एक्स और उबंटू 2014-10 दोनों पर कुल डिस्क उपयोग दिखाई देता है। मैं भी डाल करने की कोशिश की ducks() { ...}में परिभाषा .bashrcऔर उसके बाद का उपयोग ducksइसे चलाने के लिए, और मैक ओएस एक्स पर एक ही बात है, केवल महायोग को देखने

— nopole

Answer 9

इस स्क्रिप्ट के साथ पागल हो जाओ -

$du -k ./* | 
> sort -nr |
> awk '
> {split("KB,MB,GB",size,",");}
> {x = 1;while ($1 >= 1024) {$1 = $1 / 1024;x = x + 1} $1 = sprintf("%-4.2f%s", $1, size[x]); print $0;}'

Answer 10

जीएनयू की अनुपस्थिति में sort -h, इसे अधिकांश यूनिक्स वातावरण में काम करना चाहिए:

join -1 2 -2 2 <(du -sk /dir/* 2>/dev/null | sort -k2,2) <(du -sh /dir/* 2>/dev/null | sort -k2,2) | sort -nk2,2 | awk '{ print $3 "\t" $1 }'

Answer 11

यह एक व्हाट्सएप या एपोस्ट्रोफ के साथ फाइलनाम को संभालता है, और उन प्रणालियों पर काम करता है जो समर्थन नहीं करते हैं : xargs -dयाsort -h

du -s * | sort -n | cut -f2 | tr '\n' '\0' | xargs -0 -I {} du -sh "{}"

जिसके परिणामस्वरूप:

368K    diskmanagementd
392K    racoon
468K    coreaudiod
472K    securityd
660K    sshd
3.6M    php-fpm

Answer 12

यह आकार के घटते क्रम में आउटपुट को क्रमबद्ध करेगा:

du -sh /var/* | sort -k 1rn

यह आकार के बढ़ते क्रम में आउटपुट को छाँटेगा:

du -sh /var/* | sort -k 1n

पुनश्च: इसका उपयोग किसी भी कॉलम को सॉर्ट करने के लिए किया जा सकता है लेकिन यह कॉलम मान एक ही प्रारूप में होना चाहिए

Comments

संख्या प्रत्येक रेखा पर दशमलव अंकों के प्रारंभिक अनुक्रम के आधार पर संख्यात्मक रूप sort -k1rnसे बराबर sort -rnऔर बस क्रमबद्ध होती है। यह चल बिन्दु नहीं समझती है, और यह नहीं समझती k, M, G... प्रत्यय। 10.1k को 1.23G से अधिक माना जाएगा

— स्टीफन चेज़लस

Answer 13

सोलारिस पर परीक्षण किया गया!

du -kh | sort -nk1 | grep [0-9]K && du -kh | sort -nk1 | grep [0-9]M && du -kh | sort -nk1 | grep [0-9]G

यह सभी निर्देशिका आकारों को पुनरावर्ती रूप से आउटपुट करेगा, सबसे नीचे गीगाबाइट्स में सबसे बड़ी निर्देशिका होगी और किलोबाइट्स में सबसे छोटे शीर्ष पर।

Answer 14

सबसे नीचे है:

du -sh * | sort -h

Answer 15

कमान:

du -ah . | sort -k1 -h | tail -n 50

स्पष्टीकरण:

• मानव-पठनीय रूप में वर्तमान निर्देशिका में पुनरावर्ती रूप से सभी फ़ाइलों / फ़ोल्डरों का आकार

du -ah .

• मानव-पठनीय आकार को सॉर्ट करें जो पहले कॉलम में मौजूद है और सबसे बड़ा 50 रखें

sort -k1 -h | tail -n 50

Answer 16

MB में आकार के अनुसार छाँटना

du --block-size=MiB --max-depth=1 path | sort -n

Comments

उपयोगकर्ता du -hसंख्यात्मक रूप से हल किए गए (मानव पठनीय आउटपुट) का आउटपुट प्राप्त करना चाहता है । आप इसका जवाब नहीं दे रहे हैं। आप अपने यूनिक्स-एसई खाते को अन्य एसई साइटों पर अन्य खातों के साथ जोड़ना चाह सकते हैं।

— टोनिन

Answer 17

यह स्क्रिप्ट और भी आसान है:

for i in G M K; do du -h -d1 / | grep [0-9]$i | sort -n; done

Answer 18

OSX के लिए

du -h -k  {PATH} | sort -n

Comments

-kसिर्फ रद्द करना नहीं है -hऔर यदि ऐसा है तो यह ओपी द्वारा अनुरोधित मानव पठनीय आउटपुट कैसे प्रदान करता है।

— एंथॉन