ප්‍රමාණයෙන් 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 ප්‍රමාණය අනුව වර්ග කළ හැකි ක්‍රමයක් ගැන කිසිවෙකු දන්නවාද ?

2009 අගෝස්තු මාසයේදී නිකුත් කරන ලද GNU coreutils 7.5 හි පරාමිතියකට sortඉඩ සලසයි , එමඟින් -hනිපදවන ආකාරයේ සංඛ්‍යාත්මක උපසර්ගයන්ට ඉඩ ලබා දේ du -h:

du -hs * | sort -h

ඔබ භාවිතා නොකරන වර්ගයක් භාවිතා කරන්නේ නම් -h, ඔබට GNU Coreutils ස්ථාපනය කළ හැකිය. උදා: පැරණි මැක් ඕඑස් එක්ස් මත:

brew install coreutils
du -hs * | gsort -h

සිට sort අත්පොත :

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

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

Og ඩග්ලස් ලීඩර්, තවත් එක් පිළිතුරක්: ඩූ-එච් වෙතින් මිනිසුන්ට කියවිය හැකි ප්‍රතිදානය වෙනත් මෙවලමක් භාවිතයෙන් වර්ග කරන්න. පර්ල් වගේ!

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

සංස්කරණය කරන්න: පර්ල්මන්ක්ස් හි ගොල්ෆ් වට කිහිපයකින් පසුව , අවසාන ප්‍රති result ලය පහත දැක්වේ:

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

මම භාවිතා කරන ඉතා ප්‍රයෝජනවත් මෙවලමක් ncdu නමින් නිර්මාණය කර ඇති අතර එමඟින් නිර්මාණය කර ඇත්තේ එම තැටි භාවිතා කරන ෆෝල්ඩර සහ ලිපිගොනු සොයා ගැනීම සහ ඒවා ඉවත් කිරීමයි. එය කොන්සෝලය මත පදනම් වූ, වේගවත් හා සැහැල්ලු වන අතර සියලුම ප්‍රධාන බෙදාහැරීම්වල පැකේජ ඇත.

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

මට පෙනෙන පරිදි ඔබට විකල්ප තුනක් තිබේ:

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

මටත් එම ගැටලුව ඇති අතර මම දැනට ක්‍රියාමාර්ගයක් භාවිතා කරමි:

du -scBM | sort -n

මෙය පරිමාණ අගයන් නිපදවන්නේ නැත, නමුත් සෑම විටම ප්‍රමාණය මෙගාබයිට් වලින් නිපදවයි. එය පරිපූර්ණයි, නමුත් මට එය වඩා හොඳ දෙයකට වඩා හොඳයි (හෝ ප්‍රමාණය බයිට් වලින් පෙන්වීම).

මෙම පළ කිරීම වෙනත් තැනක හමු විය . එමනිසා, මෙම ෂෙල් ස්ක්‍රිප්ට් 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නාමාවලියෙහි මෙය ක්‍රියාත්මක කිරීමෙන් ලැබෙන ields ලදාව:

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

(වර්ණ පටිපාටි 3.6M අධික නොවන බව මම විශ්වාස කරමි.)

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 ට වඩා අඩු), එවිට කිසිදු ගැලපීමක් නොමැති අතර ශුන්‍යයක් ආපසු ලබා දෙනු ලැබේ (පරිපූර්ණයි! )
• නව ක්ෂේත්‍ර මුද්‍රණය කරන්න - ඒකකය, අගය (ඇල්ෆා වර්ග කිරීම නිසියාකාරව ක්‍රියාත්මක කිරීම සඳහා එය ශුන්‍ය පෑඩ්, ස්ථාවර දිග) සහ මුල් රේඛාව
• ප්‍රමාණ ක්ෂේත්‍රයේ අවසාන අක්‍ෂරය සුචිගත කරන්න
• ප්‍රමාණයේ සංඛ්‍යාත්මක කොටස අදින්න
• ප්‍රති results ල වර්ග කරන්න, අමතර තීරු ඉවතලන්න

එය 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]]}'

නාමාවලි වඩාත් සංයුක්ත සාරාංශගත ආකාරයකින් පෙන්වන උදාහරණයක් මෙන්න. එය නාමාවලි / ගොනු නාමයන්හි අවකාශය හසුරුවයි.

% 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

MB ප්‍රමාණයෙන් ගොනු වර්ග කරන්න

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

ඩුටොප් නම් ඩු සඳහා සරල නමුත් ප්‍රයෝජනවත් පයිතන් එතුම මා සතුව ඇත. "මානව" නිමැවුම කෙලින්ම වර්ග කිරීම සඳහා වර්ග කිරීම සඳහා ක්‍රියාකාරීත්වය එක් කිරීමට අපි (කෝරූටිල්ස් නඩත්තු කරන්නන්) සලකා බලමින් සිටින බව සලකන්න.

තවත් එකක් ලැබුණා:

$ 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

පලමු. එහි සිටින සියලුම පර්ල් හැකර්වරුන්ට: ඔව්, වර්ග කිරීමේ කොටස ද පර්ල් වලින් කළ හැකි බව මම දනිමි. බොහෝ විට ඩු ​​කොටස ද විය හැකිය.

මෙම ස්නිපටය 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;
     }
    '

"-G" ධජය භාවිතා කරන්න

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

මගේ / usr / local නාමාවලියෙහි මෙවැනි ප්‍රතිදානයන් නිපදවයි:

$ 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

මෙය මාර්ගගතව හමු විය ... හරි වැඩ කරන බව පෙනේ

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

තවත් එකක්:

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

මම ඊයේ මෙම උදාහරණය සංක්ෂිප්තව ඉගෙන ගත්තා. එය යම් කාලයක් ගත වූ නමුත් එය ඉතා විනෝදජනක වූ අතර මම අවදි භාවිතා කරන ආකාරය ඉගෙන ගතිමි.

එය ධාවනය වන්නේ එක් වරක් පමණක් වන අතර එහි ප්‍රතිදානය 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 ට අඩු සංඛ්‍යා පෙන්වයි.

මෙන්න මම භාවිතා කරන සරල ක්‍රමය, ඉතා අඩු සම්පත් භාවිතය සහ ඔබට අවශ්‍ය දේ ඔබට ලබා දෙයි:

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

du -cka --max-deep = 1 / var / log | sort -rn | හිස -10 | awk '{print ($ 1) / 1024, "MB", $ 2'}

ඔබට අවකාශයන් හැසිරවීමට අවශ්‍ය නම් ඔබට පහත සඳහන් දෑ භාවිතා කළ හැකිය

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

යෙදුම් සහය වැනි නම් සහිත ෆෝල්ඩර සමඟ ඇති ගැටළු සමනය කිරීමට අතිරේක sed ප්‍රකාශය උපකාරී වේ

Voilà:

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

http://dev.yorhel.nl/ncdu

විධානය: ncdu

නාමාවලි සංචලනය, වර්ග කිරීම (නම සහ ප්‍රමාණය), ප්‍රස්ථාරකරණය, මානව කියවිය හැකි යනාදිය ...

තවත් 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

මම @ptman විසින් සපයන ලද විසඳුම භාවිතා කර ඇත, නමුත් මෑත කාලීන සේවාදායක වෙනසක් නිසා එය තවදුරටත් ශක්‍ය නොවීය. ඒ වෙනුවට, මම පහත දැක්වෙන bash ස්ක්‍රිප්ට් භාවිතා කරමි:

#!/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);
}'

du -s * | sort -nr | cut -f2 | xargs du -sh

මෙහි පිළිතුරු රාශියක් ඇත, ඒවායින් බොහොමයක් අනුපිටපත් වේ. මම ප්‍රවණතා තුනක් දකිමි: දෙවන ඩු ඇමතුමකින් නල එළීම, සංකීර්ණ ෂෙල් / අව් කේත භාවිතා කිරීම සහ වෙනත් භාෂා භාවිතා කිරීම.

මෙන්න සෑම පද්ධතියකම ක්‍රියා කළ යුතු du සහ awk භාවිතා කරමින් POSIX- අනුකූල විසඳුමක් .

මම තරමක් වෙනස් ප්‍රවේශයක් ගෙන ඇති අතර, -xඅපි එකම ගොනු පද්ධතියේ රැඳී සිටින බව සහතික කිරීම සඳහා එකතු කරමි (මට මෙම මෙහෙයුම අවශ්‍ය වන්නේ මා තැටියේ ඉඩ ප්‍රමාණය අඩු වූ විට පමණි, එබැවින් මා මෙම එෆ්එස් ගස තුළ සවි කර ඇති හෝ ගෙන ගිය දේවල් ඉවත් කරන්නේ ඇයි? දෘශ්‍ය විග්‍රහ කිරීම පහසු කිරීම සඳහා නියත ඒකක පෙන්වීම. මෙම අවස්ථාවේ දී, මම සාමාන්‍යයෙන් වර්ග කිරීම නොකිරීමට තීරණය කරමි, එවිට මට ධූරාවලි ව්‍යුහය වඩා හොඳින් දැක ගත හැකිය.

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

(මෙම ස්ථාවර ඒකක වන බැවින්, එවිට ඔබට ඇතුලත් කළ හැකි | sort -nඔබ ඇත්තටම අවශ්ය නම් ආකාරයක ed ප්රතිඵල.)

512MB ඉක්මවීමට අසමත් වූ (සමුච්චිත) අන්තර්ගතයන් ගිගාබයිට් වලින් පෙන්වන ඕනෑම නාමාවලියක් මෙය පෙරහන් කරයි. සුපුරුදු පරිදි, භාවිතා 512-බයිට වාරණ ප්රමාණය මෙහි dU (2 awk තත්ත්වය එසේ ²⁰ කුට්ටි 512MB වන අතර එහි 2 ²¹ භාජකය GB දක්වා ඒකක පරිවර්තනය - අපි භාවිතා කළ හැකි du -kxසමග $1 > 512*1024සහ s/1024^2තවත් මානව කියවිය හැකි විය). අවුල් තත්වයේ ඇතුළත, අපි sප්‍රමාණයට සකසා ඇති බැවින් අපට එය ( $0) රේඛාවෙන් ඉවත් කළ හැකිය . මෙය පරිසීමකය රඳවා ගනී (එය තනි අවකාශයකට කඩා වැටේ), එබැවින් අවසාන කොටස %sඅවකාශයක් නිරූපණය කරන අතර පසුව සමස්ත නාමාවලියෙහි නම වේ. %7sවටකුරු %.2fGB ප්‍රමාණය %8sපෙළගස්වයි ( ඔබට> 10TB තිබේ නම් වැඩි කරන්න ).

මෙහි ඇති බොහෝ විසඳුම් මෙන් නොව, මෙය නිසි ලෙස ඔවුන්ගේ නම් වල ඇති අවකාශ සහිත ඩිරෙක්ටරි සඳහා සහය දක්වයි ( මෙය ඇතුළුව සෑම විසඳුමක්ම රේඛා බිඳීම් අඩංගු නාමාවලි නාමයන් වැරදි ලෙස හසුරුවනු ඇත).

මෙන්න උදාහරණයක්

du -h /folder/subfolder --max-depth=1 | sort -hr

ප්‍රතිලාභ:

233M    /folder/subfolder
190M    /folder/subfolder/myfolder1
15M     /folder/subfolder/myfolder4
6.4M    /folder/subfolder/myfolder5
4.2M    /folder/subfolder/myfolder3
3.8M    /folder/subfolder/myfolder2

| head -10නිශ්චිත නාමාවලියෙහි ඉහළම 10 හෝ උප ෆෝල්ඩර ගණනක් සොයා ගැනීමට ඔබට එකතු කළ හැකිය.

අවම වශයෙන් සුපුරුදු මෙවලම් සමඟ වුවද, මිනිසාට කියවිය හැකි සංඛ්‍යා ඇති ආකෘතිය නිසා මෙය දුෂ්කර වනු ඇත (508, 64, 61, 2, 2 - එය වර්ග කරන විට වර්ග කිරීම මෙහි “හොඳ කාර්යයක්” කරන බව සලකන්න. අතිරේක ගුණකයක් සමඟ පාවෙන ලක්ෂ්‍ය සංඛ්‍යා වර්ග කළ නොහැක).

මම එය වෙනත් ආකාරයකින් උත්සාහ කරමි - "du | sort -n -r" වෙතින් ප්‍රතිදානය භාවිතා කර පසුව යම් ස්ක්‍රිප්ට් එකක් හෝ වැඩසටහනක් සමඟ සංඛ්‍යා මිනිස් කියවිය හැකි ආකෘතියකට පරිවර්තනය කරන්න.

ඔබට උත්සාහ කළ හැකි දේ:

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

උපකාරවත් වන බලාපොරොත්තුව.