मैं आकार के द्वारा du -h आउटपुट कैसे सॉर्ट कर सकता हूं

Question

मुझे मानव पठनीय ड्यू आउटपुट की सूची प्राप्त करने की आवश्यकता है।

हालांकि, du"आकार के अनुसार" विकल्प नहीं है, और sortमानव पठनीय ध्वज के साथ काम करने के लिए पाइपिंग नहीं है।

उदाहरण के लिए, दौड़ना:

du | sort -n -r 

आकार द्वारा एक सॉर्ट की गई डिस्क आउटपुट (अवरोही):

du |sort -n -r
65108   .
61508   ./dir3
2056    ./dir4
1032    ./dir1
508     ./dir2

हालाँकि, इसे मानव पठनीय ध्वज के साथ चलाना, ठीक से नहीं सुलझता:

du -h | sort -n -r

508K    ./dir2
64M     .
61M     ./dir3
2.1M    ./dir4
1.1M    ./dir1

क्या किसी du -h को आकार के आधार पर हल करने का तरीका पता है ?

Comments

हेह ... मजेदार आपको पूछना चाहिए, क्योंकि यह मुझे परेशान कर रहा है ... अच्छी तरह से एक वर्ष में कम से कम। पिछले हफ्ते मैंने जीएनयू कोरुटिल्स (जिसमें से एक हिस्सा है) का कोड डाउनलोड किया है, और एक नज़र था, लेकिन फैसला किया कि मुझे अपने हाथों को थपथपाने में थोड़ा और समय लगेगा ... कोई भी? :)

— खोलना

यहाँ एक बहुत संबंधित प्रश्न है: serverfault.com/q/737537/35034

— क्रैगॉक्स

क्या आपने इसे देखा है? unix.stackexchange.com/questions/4681/… यह एक निकट डुप्लिकेट है और सोने के लायक है। आप एक सामान्य करते duहैं, लेकिन -h को sortकमांड में जोड़ते हैं । आप जोड़ सकते हैं -rhकि सबसे बड़ी फ़ाइल में पहले हैं, अन्यथा आपको tailअंतरिक्ष हॉग देखने की आवश्यकता है।

— एसडीसोलर

जब मैंने इस पर ध्यान दिया तो मुझे इस तरह के सवाल के इतने लोकप्रिय होने की उम्मीद नहीं थी।

— मतीन उल्हाक

Answer 1

के रूप में GNU coreutils 7.5 अगस्त 2009 में जारी की है, sortएक की अनुमति देता है -hपैरामीटर, जो एक तरह से न्यूमेरिक प्रत्यय द्वारा उत्पादित की अनुमति देता है du -h:

du -hs * | sort -h

यदि आप किसी ऐसे प्रकार का उपयोग कर रहे हैं जो समर्थन नहीं करता है -h, तो आप GNU Coreutils स्थापित कर सकते हैं। जैसे पुराने मैक OS X पर:

brew install coreutils
du -hs * | gsort -h

से sort मैनुअल :

-h, --human-numeric-sort compare human readable numbers (e.g., 2K 1G)

Comments

मैनुअल का प्रासंगिक अनुभाग: gnu.org/software/coreutils/manual/…

— wodow

होमब्रेव के साथ ओएस एक्स पर स्थापित करना आसान है - काढ़ा स्थापित करें कोरुटिल।

— रिचर्ड पॉयरियर

अच्छा था! मैंने व्यक्तिगत रूप से हमेशा du -BM | sort -nrएक वर्कअराउंड के रूप में किया - यह पर्याप्त रूप से मानव पठनीय है, और इसे क्रमबद्ध किया गया है, अगर कोई भी पुराने कोरुटिल्स के साथ फंस गया है।

— चुतज २४'१२ को

अगर Homebrew के माध्यम से OSX का उपयोग करते हैं, तो ध्यान दें कि अब आपको सॉर्ट के बजाय gsort का उपयोग करना होगा:du -hs * | gsort -h

— ब्रायन क्लाइन

@PaulDraper, du -BMमेगाबाइट में सब कुछ प्रिंट करता है, इसलिए 168K की एक फ़ाइल वास्तव में 0M के रूप में प्रदर्शित होगी। जब तक कि कुछ अन्य संस्करण विसंगति नहीं है, जिनके बारे में मुझे जानकारी नहीं है। duकेवल मेरा संस्करण पूर्णांक मेगाबाइट मान दिखाता है।

— चुतज

Answer 2

du | sort -nr | cut -f2- | xargs du -hs

Comments

और यह भारी मात्रा में डुप्लिकेट काउंटिंग करेगा।

— डगलस लीडर

पहले यह सामान्य डू करता है - फिर प्रत्येक प्रविष्टि के लिए यह आकार को केवल मानव पठनीय रूप में मुद्रित करने के लिए पुन: गणना करता है।

— डगलस लीडर

@ डगलस लीडर: आप डुप्लिकेट काउंटिंग के लिए सही हैं, लेकिन यह सोचें कि दूसरी जोड़ी कोल्ड कैश (OS के लिए धन्यवाद) से शुरू नहीं होती है @hasen j: xargs एक बहुत ही उपयोगी कमांड है, यह अपने स्टड को विभाजित करता है और इसे तर्क के रूप में फीड करता है दिए गए आदेश के लिए

— कैडरियन

क्रिस वास्तव में बेहतर है क्योंकि यह व्हाट्सएप वाले रास्तों के साथ काम करता है। एक वोट अपने रास्ते फेंक, दोस्त।

— rbright

बदसूरत, लेकिन क्रॉस-प्लेटफॉर्म :)।

— voretaq7

Answer 3

@ डगलस लीडर, एक और उत्तर: दुसरे टूल का उपयोग करके मानव-पठनीय आउटपुट को du -h से क्रमबद्ध करें। पर्ल की तरह!

du -h | perl -e 'sub h{%h=(K=>10,M=>20,G=>30);($n,$u)=shift=~/([0-9.]+)(\D)/;
return $n*2**$h{$u}}print sort{h($b)<=>h($a)}<>;'

डिस्प्ले को फिट करने के लिए दो लाइनों पर विभाजित करें। आप इसे इस तरह से उपयोग कर सकते हैं या इसे वन-लाइनर बना सकते हैं, यह किसी भी तरह से काम करेगा।

आउटपुट:

4.5M    .
3.7M    ./colors
372K    ./plugin
128K    ./autoload
100K    ./doc
100K    ./syntax

संपादित करें: गोल्फ के कुछ राउंड के बाद PerlMonks पर , अंतिम परिणाम निम्नलिखित है:

perl -e'%h=map{/.\s/;99**(ord$&&7)-$`,$_}`du -h`;die@h{sort%h}'

Comments

आपका लघु संस्करण आउटपुट के stderrकारण dieआप इसे इसे आउटपुट करने के लिए बदल सकते हैं stdout?

— डेनिस विलियमसन

बदले dieएक करने के लिए printऔर इसे करने के लिए जाना होगा stdout। यह सिर्फ दो और किरदार हैं।

— एडम बेलाएरे

ubuntu पर काम करता है!

— मारिनारा

प्रभावशाली perl hackistry

— nandoP

परिणाम रिवर्स ऑर्डर में है :(

— RSFalcon7

Answer 4

एक बेहद उपयोगी उपकरण है जिसका उपयोग मैं ncdu के रूप में करता हूं जो उन pesky उच्च डिस्क-उपयोग फ़ोल्डर और फ़ाइलों को खोजने और उन्हें हटाने के लिए डिज़ाइन किया गया है। यह कंसोल आधारित, तेज और हल्का है, और सभी प्रमुख वितरणों पर इसके पैकेज हैं।

Comments

बहुत अच्छा ... अगर परिणाम मानक के लिए खिलाया जा सकता है तो मैं बहुत अच्छा लगा ... मैं इतना आलसी हूं कि मैं मैनुअल नहीं पढ़ सकता हूं

— ojblass

gt5 एक ही नस में है; इसकी हत्यारी विशेषता वृद्धि प्रदर्शित कर रही है।

— तोबू

यह वास्तव में अच्छा है! और duअगर आप सिर्फ बड़ी निर्देशिकाओं की पहचान करना चाहते हैं, तो साथ घूमने की तुलना में बहुत तेज़ है ।

— बर्निनलियो सेप

Answer 5

du -k * | sort -nr | cut -f2 | xargs -d '\n' du -sh

Comments

के साथ उपयोग नहीं कर सकते du -k --total, अंत में त्रुटि देता हैdu: cannot access 'total': No such file or directory

— लैगिंगसर्प्लेक्स

मुझे यह कोई और जवाब पसंद है। आप केवल पहले 50 परिणाम दिखाने के लिए कैसे जाएंगे?

— मऊ

@ मौरो - बस परिणाम headजोड़कर `| अंत में सिर -50`।

— सैमुअल लेलीवर

Answer 6

जहाँ तक मैं देख सकता हूँ आपके पास तीन विकल्प हैं:

1. बदल duप्रदर्शन से पहले सॉर्ट करने के लिए।
2. बदल sortसंख्यात्मक प्रकार के लिए मानव आकारों का समर्थन करने के लिए।
3. मूल आउटपुट को मानव पठनीय में बदलने के लिए आउटपुट को सॉर्ट से प्रोसेस करें।

आप du -kKiB में आकारों के साथ भी कर सकते हैं और रह सकते हैं ।

विकल्प 3 के लिए आप निम्नलिखित स्क्रिप्ट का उपयोग कर सकते हैं:

#!/usr/bin/env python

import sys
import re

sizeRe = re.compile(r"^(\d+)(.*)$")

for line in sys.stdin.readlines():
    mo = sizeRe.match(line)
    if mo:
        size = int(mo.group(1))
        if size < 1024:
            size = str(size)+"K"
        elif size < 1024 ** 2:
            size = str(size/1024)+"M"
        else:
            size = str(size/(1024 ** 2))+"G"

        print "%s%s"%(size,mo.group(2))
    else:
        print line

Answer 7

मुझे वह समस्या भी है और मैं वर्तमान में वर्कअराउंड का उपयोग कर रहा हूं:

du -scBM | sort -n

यह स्केल किए गए मूल्यों का उत्पादन नहीं करेगा, लेकिन हमेशा मेगाबाइट में आकार का उत्पादन करेगा। यह तब कम सही है, लेकिन मेरे लिए यह कुछ भी नहीं (या बाइट्स में आकार प्रदर्शित करना) से बेहतर है।

Comments

मुझे th -BM स्विच पसंद है, जो मूल रूप से -m जैसा ही है, लेकिन इसका आकार और M इसे पोस्ट करने के लिए प्रदर्शित करने का लाभ है, इसलिए आपको 10M मिलता है जो कि केवल 10 :) की तुलना में बहुत अधिक स्पष्ट है

— टॉम फीर्नर

यह इस पृष्ठ पर अब तक का सबसे सरल समाधान है, धन्यवाद!

— जेफ ओल्सन

Answer 8

यह पोस्टिंग कहीं और मिली । इसलिए, यह शेल स्क्रिप्ट वह करेगी जो आप duहर चीज पर दो बार कॉल किए बिना चाहते हैं । यह awkकच्चे बाइट्स को मानव-पठनीय प्रारूप में बदलने के लिए उपयोग करता है। बेशक, स्वरूपण थोड़ा अलग है (सब कुछ एक दशमलव स्थान परिशुद्धता के लिए मुद्रित होता है)।

#/bin/bash
du -B1 | sort -nr  |awk '{sum=$1;
hum[1024**3]="G";hum[1024**2]="M";hum[1024]="K";
for (x=1024**3; x>=1024; x/=1024){
        if (sum>=x) { printf "%.1f%s\t\t",sum/x,hum[x];print $2;break
}}}'

मेरी .vimनिर्देशिका पैदावार में यह चल रहा है:

4.4M            .
3.6M            ./colors
372.0K          ./plugin
128.0K          ./autoload
100.0K          ./syntax
100.0K          ./doc

(मुझे आशा है कि 3.6M रंग योजनाएँ अत्यधिक नहीं हैं।)

Comments

मेरे पास एक पर्ल उत्तर भी है, लेकिन मुझे लगता है कि इससे लोगों को मुझसे नफरत हो सकती है: du -B1 | सॉर्ट -nr | perl -e '% h = (0 => b, 1 => K, 2 => M, 3 => G); के लिए (<>) {($ s, @ f) = विभाजित / \ s + /; $ e = 3; $ e-- जबकि (1024 ** $ e> $ s); $ v = ($ s / (1024 ** e)); printf "% -8 s% s \ n", स्प्रिंटफ ($ v> = 100; "% d% s": "% .1f% s", $ s / (1024 ** $ e), $ h {$ e}), @ f;} '

— एडम बेलेयर

हालांकि पर्ल जवाब वास्तव में अपने स्वरूपण को डु के बहुत करीब देता है। हालांकि गोलाई बंद है ... ऐसा लग रहा है कि डु हमेशा राउंड () के बजाय सीइल () देता है

— एडम बेलायर

अरे, मैंने वहां हैश का इस्तेमाल क्यों किया? एक सरणी होनी चाहिए ... सुबह-मस्तिष्क की गड़गड़ाहट ....

— एडम बेलाएरे

एक और जवाब के रूप में एक बेहतर पर्ल समाधान जोड़ा गया।

— एडम बेलाएरे

फ़ाइलनाम में रिक्त स्थान होने पर दोनों संस्करण विफल हो जाते हैं

— Vi।

Answer 9

यह संस्करण awkसॉर्ट कीज़ के लिए अतिरिक्त कॉलम बनाने के लिए उपयोग करता है। यह केवल duएक बार कॉल करता है । आउटपुट बिल्कुल वैसा ही दिखना चाहिए du।

मैंने इसे कई लाइनों में विभाजित किया है, लेकिन इसे एक-लाइनर में पुन: संयोजित किया जा सकता है।

du -h |
  awk '{printf "%s %08.2f\t%s\n", 
    index("KMG", substr($1, length($1))),
    substr($1, 0, length($1)-1), $0}' |
  sort -r | cut -f2,3

स्पष्टीकरण:

• BEGIN - इकाइयों द्वारा समूहीकरण के लिए K, M, G के लिए 1, 2, 3 को अनुक्रमित करने के लिए एक स्ट्रिंग बनाते हैं, यदि कोई इकाई नहीं है (आकार 1K से कम है), तो कोई मेल नहीं है और एक शून्य लौटा है (एकदम सही! )
• नए फ़ील्ड्स प्रिंट करें - यूनिट, मान (अल्फा-सॉर्ट काम को ठीक से बनाने के लिए यह शून्य-गद्देदार, निश्चित-लंबाई) और मूल लाइन है
• आकार क्षेत्र के अंतिम वर्ण को अनुक्रमित करें
• आकार के संख्यात्मक भाग को बाहर निकालें
• परिणामों को क्रमबद्ध करें, अतिरिक्त कॉलमों को छोड़ दें

यह cutकमांड के बिना यह देखने की कोशिश करें कि यह क्या कर रहा है।

यहां एक संस्करण है जो AWK स्क्रिप्ट के भीतर छंटनी करता है और इसकी आवश्यकता नहीं है cut:

du -h |
   awk '{idx = sprintf("%s %08.2f %s", 
         index("KMG", substr($1, length($1))),
         substr($1, 0, length($1)-1), $0);
         lines[idx] = $0}
    END {c = asorti(lines, sorted);
         for (i = c; i >= 1; i--)
           print lines[sorted[i]]}'

Comments

धन्यवाद! यह पहला उदाहरण है जो ओएस एक्स 10.6 में मेरे लिए काम करता है न कि पर्ल / फाइटॉन-स्क्रिप्ट की गिनती। और अच्छी व्याख्या के लिए फिर से धन्यवाद। हमेशा कुछ नया सीखने के लिए अच्छा है। awk यकीन है कि एक शक्तिशाली उपकरण है।

— वुल्फ

उसके लिए बहुत धन्यवाद। मैंने du -sh *पुनरावर्ती वंश के बिना सिर्फ तत्काल फ़ाइलों और निर्देशिकाओं को दिखाने के लिए डु को बदल दिया ।

— हांकाका

Answer 10

यहां एक उदाहरण दिया गया है जो निर्देशिकाओं को अधिक कॉम्पैक्ट संक्षेप रूप में दिखाता है। यह निर्देशिका / फ़ाइल नाम में रिक्त स्थान को संभालता है।

% du -s * | sort -rn | cut -f2- | xargs -d "\n" du -sh

53G  projects
21G  Desktop
7.2G VirtualBox VMs
3.7G db
3.3G SparkleShare
2.2G Dropbox
272M apps
47M  incoming
14M  bin
5.7M rpmbuild
68K  vimdir.tgz

Comments

macOS / OSX उपयोगकर्ताओं को चेतावनी दी जाती है कि xargs का मैक संस्करण -d ध्वज का समर्थन नहीं करता है, और यदि आप इसे छोड़ देते हैं, तो किसी भी निर्देशिका वाले स्थान में प्रत्येक शब्द अलग-अलग पार्स होता है, जो निश्चित रूप से विफल रहता है।

— जसनोलॉजी जूल

Answer 11

MB में आकार के अनुसार फाइलें छांटें

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

Answer 12

मैं डु के लिए ड्यूपॉप नामक एक सरल लेकिन उपयोगी अजगर रैपर हूं । ध्यान दें कि हम (coreutils अनुचर) "मानव" आउटपुट को सीधे सॉर्ट करने के लिए कार्यक्षमता जोड़ने पर विचार कर रहे हैं।

Comments

"एक काम और इसे सही करने के लिए दुर्लभ, मान्य अपवादों में से एक के लिए +1।" जब तक कोई SI- उपसर्ग और / या बाइनरी उपसर्गों को समझने के लिए हल नहीं करता है।

— जोकिम सॉर

और जैसा कि पीटमैन नीचे उल्लेख करता है: टा डा ! (नया sortध्वज)

— तोबू

Answer 13

एक और मिल गया:

$ du -B1 | sort -nr | perl -MNumber::Bytes::Human=format_bytes -F'\t' -lane 'print format_bytes($F[0])."\t".$F[1]'

मैं पर्ल को पसंद करने लगा हूं। आपको करना पड़ सकता है

$ cpan Number::Bytes::Human

प्रथम। सभी पर्ल हैकर्स के लिए वहाँ: हाँ, मुझे पता है कि क्रमबद्ध भाग भी पर्ल में किया जा सकता है। शायद डु हिस्सा भी।

Answer 14

यह स्निपेट 'जीन-पियरे' से http://www.unix.com/shell-programming-scripting/32555-du-h-sort.html से बेशर्म हो गया था । क्या कोई तरीका है जिससे मैं उसे बेहतर श्रेय दे सकूं?

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

Comments

मुझे लगता है कि अगर यह एक बहुत बड़ी संख्या है, तो इकाई चली गई है और प्रदर्शित संख्या छोटी है ... कोशिश करें23423423432423

— nopole

Answer 15

"-G" ध्वज का उपयोग करें

 -g, --general-numeric-sort
              compare according to general numerical value

और मेरी / usr / स्थानीय निर्देशिका इस तरह से उत्पादन का उत्पादन करती है:

$ du |sort -g

0   ./lib/site_ruby/1.8/rubygems/digest
20  ./lib/site_ruby/1.8/rubygems/ext
20  ./share/xml
24  ./lib/perl
24  ./share/sgml
44  ./lib/site_ruby/1.8/rubygems/package
44  ./share/mime
52  ./share/icons/hicolor
56  ./share/icons
112 ./share/perl/5.10.0/YAML
132 ./lib/site_ruby/1.8/rubygems/commands
132 ./share/man/man3
136 ./share/man
156 ./share/perl/5.10.0
160 ./share/perl
488 ./share
560 ./lib/site_ruby/1.8/rubygems
604 ./lib/site_ruby/1.8
608 ./lib/site_ruby

Comments

यह मानव-पठनीय आउटपुट नहीं देता है, हालांकि, वही है जो ओपी देख रहा था।

Answer 16

और एक:

du -h | perl -e'
@l{ K, M, G } = ( 1 .. 3 );
print sort {
    ($aa) = $a =~ /(\w)\s+/;
    ($bb) = $b =~ /(\w)\s+/;
    $l{$aa} <=> $l{$bb} || $a <=> $b
  } <>'

Answer 17

यहां मैं सरल विधि का उपयोग करता हूं, बहुत कम संसाधन उपयोग और आपको वह मिलता है जिसकी आपको आवश्यकता है:

du --max-depth=1 | sort -n | awk 'BEGIN {OFMT = "%.0f"} {print $1/1024,"MB", $2}'

0 MB ./etc
1 MB ./mail
2 MB ./tmp
123 MB ./public_html

Answer 18

यह एक लाइन पर मिला ... ठीक काम करने लगता है

du -sh * | tee /tmp/duout.txt | grep G | sort -rn ; cat /tmp/duout.txt | grep M | sort -rn ; cat /tmp/duout.txt | grep K | sort -rn ; rm /tmp/duout.txt

Comments

इस एक-लाइनर के आधार पर, मैंने एक मानव-पठनीय, क्रमबद्ध du (1) आउटपुट प्रदान करने के लिए एक स्क्रिप्ट बनाई। कृपया मेरे उत्तर, serverfault.com/a/937459/218692 पर देखें ।

— ट्रिप्ट कैनेटिक्स

Answer 19

मैंने कल इस उदाहरण को व्यक्त करने से जागना सीखा। इसमें कुछ समय लगा, लेकिन यह बहुत मजेदार था, और मैंने सीखा कि कैसे जागना है।

यह केवल एक बार डु चलता है, और इसका आउटपुट du -h के समान है

du --max-depth=0 -k * | sort -nr | awk '{ if($1>=1024*1024) {size=$1/1024/1024; unit="G"} else if($1>=1024) {size=$1/1024; unit="M"} else {size=$1; unit="K"}; if(size<10) format="%.1f%s"; else format="%.0f%s"; res=sprintf(format,size,unit); printf "%-8s %s\n",res,$2 }'

यह एक दशमलव बिंदु के साथ 10 से नीचे की संख्या दिखाता है।

Answer 20

du -cka --max-गहराई = 1 / var / लॉग | sort -rn | सिर -10 | awk '{प्रिंट ($ 1) / 1024, "एमबी", $ 2'}

Answer 21

यदि आपको रिक्त स्थान को संभालने की आवश्यकता है तो आप निम्नलिखित का उपयोग कर सकते हैं

 du -d 1| sort -nr | cut -f2 | sed 's/ /\\ /g' | xargs du -sh

अतिरिक्त सेड स्टेटमेंट, एप्लिकेशन सपोर्ट जैसे नामों वाले फ़ोल्डर्स के साथ मुद्दों को कम करने में मदद करेगा

Comments

बस macOS सिएरा पर यह कोशिश की। उम्मीद के मुताबिक काम करता है। अच्छा!

— जसनोलॉजी

Answer 22

Voilà:

du -sk /var/log/* | sort -rn | awk '{print $2}' | xargs -ia du -hs "a"

Answer 23

http://dev.yorhel.nl/ncdu

आदेश: ncdu

निर्देशिका नेविगेशन, छंटाई (नाम और आकार), रेखांकन, मानव पठनीय, आदि ...

Comments

महान उपयोगिता, लेकिन किसी भी ओएस पर डिफ़ॉल्ट रूप से स्थापित नहीं हूं जिनसे मैं अवगत हूं। जरूरी नहीं कि एक समस्या हो, लेकिन एक और कार्यक्रम की देखरेख करना हो ...

— voretaq7

Answer 24

एक और awkउपाय -

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


[jaypal~/Desktop/Reference]$ 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;}'
15.92MB ./Personal
13.82MB ./Personal/Docs
2.35MB ./Work Docs
1.59MB ./Work Docs/Work
1.46MB ./Personal/Raa
584.00KB ./scan 1.pdf
544.00KB ./Personal/Resume
44.00KB ./Membership.xlsx
16.00KB ./Membership Transmittal Template.xlsx

Answer 25

मैं @ptman द्वारा प्रदान किए गए समाधान का उपयोग कर रहा था, लेकिन एक हालिया सर्वर परिवर्तन ने इसे अब व्यवहार्य नहीं बनाया। इसके बजाय, मैं निम्नलिखित बैश स्क्रिप्ट का उपयोग कर रहा हूं:

#!/bin/bash
# File: duf.sh
# list contents of the current directory by increasing 
#+size in human readable format

# for some, "-d 1" will be "--maxdepth=1"
du -k -d 1 | sort -g | awk '
{
if($1<1024)
    printf("%.0f KB\t%s",$1,$2);
else if($1<1024*1024)
    printf("%.1f MB\t%s",$1/1024,$2);
else
    printf("%.1f GB\t%s",$1/1024/1024,$2);
}'

Comments

बीएसडी du -d 1सिंटैक्स को जीएनयू डु द्वारा समर्थित किया गया है क्योंकि कोरुटिल्स 8.6 को 2010 में जारी किया गया था (हालांकि इसकी पहली रेड हैट उपलब्धता 2014 में आरएचईएल 7 थी), इसलिए आपको अब आवश्यकता नहीं है --maxdepth=1। मुझे केवल इस बारे में हाल ही में पता चला है ।

— एडम काटज़

Answer 26

du- एस * | सॉर्ट -nr | कट -f2 | xargs डु -श

Comments

यह एक महान समाधान नहीं है, क्योंकि यह दो बार फाइल सिस्टम का पता लगाता है।

— पॉल गियर

Answer 27

यहां बहुत सारे उत्तर हैं, जिनमें से कई डुप्लिकेट हैं। मुझे तीन प्रवृत्तियां दिखाई देती हैं: दूसरी शेल कॉल के माध्यम से पाइपिंग करना, जटिल शेल / awk कोड का उपयोग करना, और अन्य भाषाओं का उपयोग करना।

यहां डु और ऑक का उपयोग करके एक पोसिक्स-अनुरूप समाधान है जो हर सिस्टम पर काम करना चाहिए।

मैंने थोड़ा अलग दृष्टिकोण लिया है, -xयह सुनिश्चित करने के लिए कि हम एक ही फाइल सिस्टम पर बने रहें (मुझे केवल इस ऑपरेशन की आवश्यकता तब होती है जब मैं डिस्क स्थान पर छोटा होता हूं, इसलिए क्यों मैंने इस एफएस पेड़ के भीतर घुड़सवार सामान को बाहर निकाल दिया है या स्थानांतरित कर दिया है सहानुभूति वापस?) और आसान दृश्य पार्सिंग बनाने के लिए निरंतर इकाइयों को प्रदर्शित करना। इस मामले में, मैं आम तौर पर चयन नहीं सुलझाने के लिए तो मैं बेहतर सौपानिक संरचना देख सकते हैं।

sudo du -x | awk '
  $1 > 2^20 { s=$1; $1=""; printf "%7sG%s\n", sprintf("%.2f",s/2^21), $0 }'

(चूंकि यह सुसंगत इकाइयों में है, तो आप फिर से जोड़ सकते हैं | sort -nयदि आप वास्तव में क्रमबद्ध विज्ञापन परिणाम चाहते हैं ।)

यह किसी भी निर्देशिका को फ़िल्टर करता है जिसकी (संचयी) सामग्री 512MB से अधिक नहीं है और फिर गीगाबाइट में आकार प्रदर्शित करता है। डिफ़ॉल्ट रूप से, du 512-बाइट ब्लॉक आकार का उपयोग करता है (इसलिए 2 ²⁰ ब्लॉकों की awk स्थिति 512MB है और इसके 2 ²¹ विभाजक इकाइयों को GB में कनवर्ट करते हैं - हम इसके du -kxसाथ $1 > 512*1024और s/1024^2अधिक मानव पठनीय हो सकते हैं)। अजीब स्थिति के अंदर, हम sआकार पर सेट करते हैं ताकि हम इसे लाइन ( $0) से हटा सकें । यह सीमांकक (जो एक एकल स्थान पर ढह गया है) को बरकरार रखता है, इसलिए अंतिम %sएक स्थान और फिर एकत्रित निर्देशिका का नाम दर्शाता है। %7sगोल %.2fआकार ( %8sयदि आपके पास 10TB है तो वृद्धि) को संरेखित करता है ।

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

Answer 28

कम से कम सामान्य साधनों के साथ, यह कठिन होगा क्योंकि प्रारूप में मानव-पठनीय संख्याएं होती हैं (ध्यान दें कि एक "अच्छा काम" यहां होता है क्योंकि यह संख्याओं को क्रमबद्ध करता है - 508, 64, 61, 2, 2 - 2 बस एक अतिरिक्त गुणक के साथ फ्लोटिंग पॉइंट नंबर को सॉर्ट नहीं किया जा सकता)।

मैं इसे दूसरे तरीके से आज़माऊँगा - "du | Sort -n -r" से आउटपुट का उपयोग करें और बाद में कुछ स्क्रिप्ट या प्रोग्राम के साथ संख्याओं को मानव-पठनीय प्रारूप में परिवर्तित करें।

Answer 29

आप क्या कोशिश कर सकते हैं:

for i in `du -s * | sort -n | cut -f2`
do
  du -h $i;
done

उम्मीद है की वो मदद करदे।

Comments

कि xargs क्या करता है ;-)

— कैडरियन

हे, मैं हमेशा xargs के बारे में भूल जाता हूं। ;) दिन के अंत में, जो कुछ भी किया जाता है वह काम करता है।

डिफ़ॉल्ट रूप से MacOSX (यानी घर के बाहर काढ़ा) एक उचित समर्थन नहीं करता है xargsइसलिए यह फॉर्म आवश्यक था। हालाँकि उनमें रिक्त स्थान वाली फ़ाइलों के लिए आपको IFS:IFS=$'\n'

— HankCa

Answer 30

du | sort -nr | awk '{ cmd = "du -h -d0 "$2"| cut -f1"; cmd | getline human; close(cmd); print human"\t"$2 }'