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


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

हालाँकि, 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  आकार से?


831
2018-02-25 13:42


मूल


हे ... मजेदार आपको पूछना चाहिए, क्योंकि यह मुझे कम से कम एक साल से अधिक परेशान कर रहा है ... पिछले हफ्ते मैंने जीएनयू कोरुटिल्स (जिस तरह से एक हिस्सा है) को कोड डाउनलोड किया, और एक नज़र डाली, लेकिन फैसला किया कि मेरे हाथों से पैच करने के लिए थोड़ा और समय लगेगा ... कोई भी? :) - unwind
यहां एक बहुत संबंधित प्रश्न है: serverfault.com/q/737537/35034 - cregox
क्या आपने यह देखा है? unix.stackexchange.com/questions/4681/...  यह एक निकट डुप्लिकेट है और सोने के लायक है। आप सामान्य करते हैं du लेकिन -एच को जोड़ें sort आदेश। आप जोड़ सकते हो -rh इसलिए सबसे बड़ी फाइल में सबसे पहले हैं, अन्यथा आपको चाहिए tail अंतरिक्ष हॉग देखने के लिए। - SDsolar
मुझे इस तरह के एक सवाल को इतनी लोकप्रिय होने की उम्मीद नहीं थी जब मैंने इसे गुगल किया। - Mateen Ulhaq


जवाब:


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

du -hs * | sort -h

यदि आप ऐसे सॉर्ट का उपयोग कर रहे हैं जो समर्थन नहीं करता है -h, आप जीएनयू कोरुटिल्स स्थापित कर सकते हैं। जैसे पुराने मैक ओएस एक्स पर:

brew install coreutils
du -hs * | gsort -h

से sort मैनुअल:

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


1153
2017-07-01 12:29



मैनुअल का प्रासंगिक खंड: gnu.org/software/coreutils/manual/... - wodow
होमब्री के साथ ओएस एक्स पर स्थापित करने में आसान - ब्रूव कोर्यूटिल स्थापित करें। - Richard Poirier
अच्छा था! मैंने व्यक्तिगत रूप से हमेशा किया du -BM | sort -nr एक कामकाज के रूप में - यह मानव पढ़ने योग्य पर्याप्त है, और अगर कोई पुरानी कोरुटिल्स से फंस गया है तो इसे हल किया जाता है। - chutz
यदि होमब्री के माध्यम से ओएसएक्स पर उपयोग करना है, तो ध्यान दें कि अब आपको सॉर्ट करने के बजाय gsort का उपयोग करने की आवश्यकता होगी: du -hs * | gsort -h - Brian Cline
@PaulDraper, du -BM मेगाबाइट्स में सबकुछ प्रिंट करता है, इसलिए 168K की एक फ़ाइल वास्तव में 0 एम के रूप में प्रदर्शित होगी। जब तक कि कुछ अन्य संस्करण विसंगति नहीं है, मुझे पता नहीं है। मेरा संस्करण du केवल पूर्णांक मेगाबाइट मान दिखाता है। - chutz


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

82
2018-02-25 13:52



और यह डुप्लिकेट गिनती की एक बड़ी राशि करेगा। - Douglas Leeder
सबसे पहले यह सामान्य डु करता है - फिर प्रत्येक प्रविष्टि के लिए यह आकार को फिर से गणना करता है ताकि इसे मानव पठनीय रूप में मुद्रित किया जा सके। - Douglas Leeder
@ डगलस लीडर: आप डुप्लिकेट गिनती के लिए सही हैं, लेकिन लगता है कि दूसरा डु ठंडा कैश से शुरू नहीं होता है (ओएस के लिए धन्यवाद) @ हसन जे: xargs एक बहुत ही उपयोगी कमांड है, यह अपने stdin को विभाजित करता है और इसे तर्क के रूप में फ़ीड करता है दिए गए आदेश के लिए - cadrian
क्रिस वास्तव में बेहतर है क्योंकि यह व्हाइटस्पेस वाले पथों के साथ काम करता है। अपना रास्ता वोट फेंक दो, दोस्त। - rbright
बदसूरत, लेकिन पार मंच :)। - voretaq7


@ डगलस लीडर, एक और जवाब: किसी अन्य टूल का उपयोग करके 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}'

59
2018-02-25 21:04



आपका लघु संस्करण आउटपुट करता है stderr जिस वजह से die क्या आप इसे आउटपुट करने के लिए इसे बदल सकते हैं stdout? - Dennis Williamson
बदलाव die ए के लिए print और यह जाएगा stdout। यह सिर्फ दो और पात्र हैं। - Adam Bellaire
उबंटू पर काम करता है! - marinara
प्रभावशाली पर्ल हैकस्ट्री - nandoP
परिणाम रिवर्स ऑर्डर में है :( - RSFalcon7


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


50
2018-02-25 20:39



बहुत अच्छा ... मुझे आश्चर्य है कि परिणाम मानक आउट को खिलाया जा सकता है ... मैं बहुत आलसी हूं कि मैं मैनुअल पढ़ नहीं सकता - ojblass
GT5 एक ही नस में है; इसकी हत्यारा सुविधा विकास प्रदर्शित कर रही है। - Tobu
यह वास्तव में अच्छा है! और साथ लटकने से बहुत तेज है du, यदि आप बस बड़ी निर्देशिकाओं को पहचानना चाहते हैं। - BurninLeo


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

43
2018-02-25 14:01



बस मैं धन्यवाद के लिए क्या देख रहा था - Edward Tanguay
के साथ उपयोग नहीं कर सकते du -k --total, अंत में त्रुटि देता है du: cannot access 'total': No such file or directory - laggingreflex
मुझे यह एक और जवाब पसंद है। आप केवल पहले 50 परिणामों को दिखाने के लिए कैसे जाएंगे? - Mauro
@Mauro - परिणाम को पाइप करें head जोड़कर '| अंत में सिर -50`। - Samuel Lelièvre


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

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

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

विकल्प 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

20
2018-02-25 13:53





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

du -scBM | sort -n

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


19
2018-02-25 13:56



मुझे थ-बीएम स्विच पसंद है, जो मूल रूप से -एम जैसा ही है, लेकिन इसका आकार और एम को प्रदर्शित करने का लाभ है, इसलिए आपको 10 एम मिलता है जो केवल 10 की तुलना में अधिक स्पष्ट है :) - Tom Feiner
यह अब तक का सबसे आसान समाधान है जिसे मैंने इस पृष्ठ पर देखा है, धन्यवाद! - Jeff Olson


मिल गया यह पोस्टिंग कहीं। इसलिए, यह शेल स्क्रिप्ट वह करेगा जो आप कॉल किए बिना करना चाहते हैं 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.6 एम रंग योजनाएं अत्यधिक नहीं हैं।)


18
2018-02-25 14:09



मेरे पास एक पर्ल जवाब भी है, लेकिन मुझे लगता है कि इससे लोगों को मुझसे नफरत हो सकती है: du-b1 | sort -nr | perl -e '% h = (0 => बी, 1 => के, 2 => एम, 3 => जी); (<>) {($ s, @ f) = विभाजन / \ s; / $ ई = 3; $ ई-- जबकि (1024 ** $ ई> $ एस); $ वी = ($ एस / (1024 ** $ ई)); printf "% -8s% s \ n", sprintf ($ v> = 100? "% d% s": "% .1f% s", $ s / (1024 ** $ e), $ h {$ e}), @ f;} ' - Adam Bellaire
भले ही पर्ल उत्तर वास्तव में अपने स्वरूपण को डु के करीब देता है। हालांकि गोलाकार बंद है ... ऐसा लगता है कि डु हमेशा गोल () के बजाय छत () देता है - Adam Bellaire
अरे, मैंने वहां एक हैश का उपयोग क्यों किया? एक सरणी होनी चाहिए ... सुबह-मस्तिष्क बड़बड़ाना.... - Adam Bellaire
एक और जवाब के रूप में एक बेहतर पर्ल समाधान जोड़ा गया। - Adam Bellaire
दोनों संस्करण विफल होते हैं जब फ़ाइल नामों में रिक्त स्थान होते हैं - Vi.


यह संस्करण उपयोग करता है 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 - इकाइयों द्वारा समूहित करने के लिए के, एम, जी के लिए 1, 2, 3 के लिए प्रतिस्थापन के लिए एक स्ट्रिंग बनाएं, यदि कोई इकाई नहीं है (आकार 1K से कम है), तो कोई मिलान नहीं है और शून्य वापस आ गया है (सही! )
  • नए फ़ील्ड मुद्रित करें - यूनिट, वैल्यू (अल्फा-सॉर्ट को ठीक से काम करने के लिए यह शून्य-गद्देदार, निश्चित-लंबाई) और मूल रेखा
  • आकार क्षेत्र के अंतिम चरित्र सूचकांक
  • आकार के संख्यात्मक भाग खींचें
  • परिणामों को सॉर्ट करें, अतिरिक्त कॉलम को छोड़ दें

इसके बिना कोशिश करो cut यह देखने के लिए आदेश है कि यह क्या कर रहा है।

यहां एक संस्करण है जो एडब्ल्यूके स्क्रिप्ट के भीतर सॉर्टिंग करता है और इसकी आवश्यकता नहीं है 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]]}'

14
2017-09-04 17:06



धन्यवाद! यह पहला उदाहरण है जो ओएस एक्स 10.6 में मेरे लिए काम करता है जो पर्ल / फीथन-स्क्रिप्ट्स की गणना नहीं करता है। और अच्छी व्याख्या के लिए फिर से धन्यवाद। कुछ नया सीखना हमेशा अच्छा लगा। बहुत यकीन है कि एक शक्तिशाली उपकरण है। - Wolf
इसके लिए बहुत अच्छा धन्यवाद। मैंने डु को बदल दिया du -sh * बिना रिकर्सिव वंश के तत्काल फ़ाइलों और निर्देशिकाओं को दिखाने के लिए। - HankCa


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

% 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

13
2018-03-18 22:10



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