मैं कमांड लाइन से निर्देशिका (फ़ोल्डर) का कुल आकार कैसे निर्धारित करूं?

क्या निर्देशिका (फ़ोल्डर) में सभी फ़ाइलों के कुल कुल आकार (डिस्क उपयोग) को प्रदर्शित करने के लिए एक सरल आदेश है?

मैंने ये कोशिश की है, और वे वह नहीं करते जो मैं चाहता हूं:

  • ls -l, जो केवल एक निर्देशिका में व्यक्तिगत फ़ाइलों के आकार को प्रदर्शित करता है, न ही
  • df -h, जो केवल मेरे डिस्क पर खाली और उपयोग किए गए स्थान को प्रदर्शित करता है ।

आदेश du "प्रत्येक फ़ाइल के डिस्क उपयोग को सारांशित करता है, निर्देशिकाओं के लिए पुनरावर्ती," उदाहरण के लिए,

du -hs /path/to/directory
  • -h संख्याओं को "मानव पठनीय" प्राप्त करना है, उदाहरण के लिए प्राप्त करें 140M के बजाय 143260 (आकार में KBytes)
  • -s सारांश के लिए है (अन्यथा आपको न केवल फ़ोल्डर का आकार मिलेगा, बल्कि हर चीज के लिए भी में फ़ोल्डर अलग से)

जैसा कि आप उपयोग कर रहे हैं -h आप मानव पठनीय मूल्यों का उपयोग करके सॉर्ट कर सकते हैं

du -h | sort -h

-h पर ध्वज sort "मानव पठनीय" आकार मूल्यों पर विचार करेंगे ।


यदि सभी फ़ाइलों और निर्देशिकाओं को पुनरावर्ती रूप से सूचीबद्ध करने से बचना चाहते हैं, तो आप आपूर्ति कर सकते हैं --max-depth कितने आइटम प्रदर्शित किए जाते हैं, इसे सीमित करने के लिए पैरामीटर । सबसे अधिक, --max-depth=1

du -h --max-depth=1 /path/to/directory

हाल ही में मुझे एक महान, एनसीआरएसईएस आधारित इंटरैक्टिव टूल मिला, जो आपको निर्देशिका आकारों के बारे में एक सिंहावलोकन देता है । साल के लिए उपकरण के उस तरह के लिए खोज की.

  • फ़ाइल पदानुक्रम के माध्यम से जल्दी से ड्रिलडाउन
  • आप टूल के अंदर से बड़ी अस्थायी फ़ाइलों को हटा सकते हैं
  • बेहद तेज

इसके बारे में सोचो बाओबाब कमांड लाइन के लिए:

apt-get install ncdu

यह आकार को पुनरावर्ती रूप से पाता है और इसे प्रत्येक फ़ोल्डर नाम के बगल में रखता है, साथ ही नीचे कुल आकार के साथ, सभी मानव प्रारूप में

du -hsc *

आनंद लें!

du foldername

उस आदेश पर अधिक जानकारी यहाँ

नीचे मैं कुल, फ़ोल्डर और फ़ाइल आकार प्रिंट करने के लिए क्या उपयोग कर रहा हूं:

$ du -sch /home/vivek/* | sort -rh

विवरण

 ------------------------------------------------------------   -c, --total          produce a grand total   -h, --human-readable          print sizes in human readable format (e.g., 1K 234M 2G)   -s, --summarize          display only a total for each argument -------------------------------------------------------------   -h, --human-numeric-sort          compare human readable numbers (e.g., 2K 1G)   -r, --reverse          reverse the result of comparisons

आउटपुट

 70M    total 69M    /home/vivek/Downloads/gatling-charts-highcharts-bundle-2.2.2/lib992K    /home/vivek/Downloads/gatling-charts-highcharts-bundle-2.2.2/results292K    /home/vivek/Downloads/gatling-charts-highcharts-bundle-2.2.2/target 52K    /home/vivek/Downloads/gatling-charts-highcharts-bundle-2.2.2/user-files

tree इस नौकरी के लिए एक और उपयोगी आदेश है:

बस इसे स्थापित करें sudo apt-get install tree और निम्नलिखित टाइप करें:

tree --du -h /path/to/directory......33.7M used in 0 directories, 25 files

से मैन ट्री:

-h    Print  the size of each file but in a more human readable way, e.g. appending a size letter for kilo‐      bytes (K), megabytes (M), gigabytes (G), terabytes (T), petabytes (P) and exabytes (E).--du  For each directory report its size as the accumulation of sizes of all its files and  sub-directories      (and their files, and so on). The total amount of used space is also given in the final report (like      the 'du -c' command.)

उत्तरों ने यह स्पष्ट कर दिया है कि du एक निर्देशिका के कुल आकार को खोजने के लिए उपकरण है । हालांकि, विचार करने के लिए कुछ कारक हैं:

  • कभी-कभी, du आउटपुट भ्रामक हो सकता है क्योंकि यह फाइल सिस्टम द्वारा आवंटित स्थान की रिपोर्ट करता है, जो व्यक्तिगत फ़ाइलों के आकार के योग से भिन्न हो सकता है । आम तौर पर फाइल सिस्टम फ़ाइल के लिए 40 9 6 बाइट्स आवंटित करेगा, भले ही आपने इसमें केवल एक वर्ण संग्रहीत किया हो!

  • 2 की शक्ति और 10 इकाइयों की शक्ति के कारण आउटपुट अंतर । द -h पर स्विच करें du बाइट्स की संख्या को विभाजित करता है 2^10 (1024), 2^20 (1048576) मानव पठनीय आउटपुट देने के लिए आदि । बहुत से लोगों को 10 की शक्तियों को देखने की अधिक आदत हो सकती है (उदाहरण के लिए 1क = 1000, 1म = 1000000) और परिणाम से आश्चर्यचकित हो सकते हैं ।

एक निर्देशिका में सभी फ़ाइलों के आकार का कुल योग खोजने के लिए, बाइट्स में, करें:

find <dir> -ls | awk '{sum += $7} END {print sum}'

उदाहरण:

$ du -s -B 1255729664$ find .  -ls | awk '{sum += $7} END {print sum}'249008169

आप उपकरण का उपयोग कर सकते हैं धूल:

PS C:\git> dust   0B       ┌── templates           │                                      █ │   0%   0B     ┌─┴ git-core              │                                      █ │   0%   0B   ┌─┴ share                   │                                      █ │   0%  76B   ├── readme.md               │                                      █ │   0% 156K   │   ┌── less.exe            │▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒█ │   2% 2.7M   │   ├── git-remote-https.exe│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒█████████████████ │  42% 3.6M   │   ├── git.exe             │▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒██████████████████████ │  56% 6.5M   │ ┌─┴ git-core              │███████████████████████████████████████ │ 100% 6.5M   ├─┴ libexec                 │███████████████████████████████████████ │ 100% 6.5M ┌─┴ .                         │███████████████████████████████████████ │ 100%

मेरा उदाहरण विंडोज से है, लेकिन लिनक्स और ऐप्पल भी समर्थित हैं:

https://github.com/bootandy/dust

मैं करने के लिए वातानुकूलित हूँ ll आदेश जो अलियास है ls -alF. यह सिर्फ एक फ़ाइल गिनती और नीचे फ़ाइलों का आकार याद कर रहा है । मैं के साथ खेला du और tree लेकिन मुझे जरूरत के योग नहीं मिल सके । तो मैंने बनाया lll मेरे लिए ऐसा करना ।

अपने में ~/.bashrc निम्नलिखित रखें:

lll () {    ls -alF "$@"    arr=($(ls -alF "$@" | awk '{TOTAL+=$5} END {print NR, TOTAL}'))    printf " \33[1;31m ${arr[0]}\33[m line(s).  "    printf "Total size: \33[1;31m ${arr[1]}\33[m\n"#    printf "Total size: \33[1;31m $(BytesToHuman <<< ${arr[1]})\33[m\n"}

फ़ाइल को सहेजें और इसका उपयोग करके संसाधन करें . ~/.bashrc (या आप अपने टर्मिनल को पुनरारंभ कर सकते हैं) ।


नमूना आउटपुट

के बारे में अच्छी बात ll आउटपुट यह रंग है । इसके साथ बनाए रखा है lll लेकिन उपयोग करते समय खो गया find या du:

lll sample output.png


TL, डॉ

एक बोनस फ़ंक्शन जिसे आप जोड़ सकते हैं ~/.bashrc कहा जाता है BytesToHuman(). यह वही करता है जो अधिकांश कंसोल उपयोगकर्ता बड़ी संख्या को एमआईबी, जीआईबी, आदि में परिवर्तित करने की अपेक्षा करेंगे:

function BytesToHuman() {    # https://unix.stackexchange.com/questions/44040/a-standard-tool-to-convert-a-byte-count-into-human-kib-mib-etc-like-du-ls1/259254#259254    read StdIn    b=${StdIn:-0}; d=''; s=0; S=(Bytes {K,M,G,T,E,P,Y,Z}iB)    while ((b > 1024)); do        d="$(printf ".%02d" $((b % 1024 * 100 / 1024)))"        b=$((b / 1024))        let s++    done    echo "$b$d ${S[$s]}"} # BytesToHuman ()

अगला टिप्पणी को दो पंक्तियों के बीच फ्लिप करें lll () इस तरह दिखने के लिए समारोह:

#    printf "Total size: \33[1;31m ${arr[1]}\33[m\n"    printf "Total size: \33[1;31m $(BytesToHuman <<< ${arr[1]})\33[m\n"

अब आपका आउटपुट इस तरह दिखता है:

lll sample output 2.png

हमेशा की तरह फिर से स्रोत के साथ मत भूलना . ~/.bashrc जब भी बदलाव करते हैं । (या पाठ्यक्रम के टर्मिनल को पुनरारंभ करें)

पुनश्च-स्व-संगरोध में दो सप्ताह के अंत में मुझे इस पांच साल पुराने लक्ष्य पर काम करने का समय दिया ।

du /foldername एक फ़ोल्डर का आकार जानने के लिए मानक कमांड है । मैन पेज को पढ़कर विकल्प ढूंढना सबसे अच्छा अभ्यास है:

man du

आपको मैन पेज (उपलब्ध) पढ़ना चाहिए ऑनलाइन) कमांड का उपयोग करने से पहले ।

अनुकूल अनुस्मारक कि यह बीटीआरएफएस जैसे गाय फाइल सिस्टम पर लगभग शून्य समझ में आ सकता है ।