ප්‍රමාණයෙන් du ප්‍රතිදානය වර්ග කරන්නේ කෙසේද?

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

ඔබට GNU coreutils (බොහෝ ලිනක්ස් බෙදාහැරීම් වල පොදු) තිබේ නම්, ඔබට භාවිතා කළ හැකිය

du -sh -- * | sort -h

මෙම -hවිකල්පය මඟින් sortආදාන-මිනිස් කියවිය හැකි (, එසේ 1023 GNU දේ ගැලපෙන සිදුවන, 1k වඩා අඩු සලකන බව 1024 මත පදනම් ඒකකය අංකය බව du -hකරන්නේ).

මෙම අංගය 2009 අගෝස්තු මාසයේදී GNU Core Utilities 7.5 වෙත එකතු කරන ලදී .

සටහන:

ඔබ Mac OSX එකක් වන පැරණි අනුවාදයක් භාවිතා කරන්නේ නම්, ඔබ සමඟ coreutils ස්ථාපනය කිරීමට අවශ්ය brew install coreutilsනම් භාවිතා කරන්න, gsortඩ්රොප් දී පතිස්ථාපනය ලෙස sort.

මැකෝස් හි නවතම අනුවාදයන් (මොජාවේ මත සත්‍යාපනය කර ඇත) sort -hස්වදේශීයව සහාය දක්වයි.

මිනිසුන්ට කියවිය හැකි පරිදි 1K කුට්ටි ගණනය කිරීමට -k ධජය භාවිතා කිරීමට උත්සාහ කරන්න. එවිට, ඔබට පොදු ඒකකයක් ඇති අතර පහසුවෙන් සංඛ්‍යාත්මක වර්ග කිරීමක් කළ හැකිය.

du -ck | sort -n

ඔබට පැහැදිලිවම මිනිස් ඒකක අවශ්‍ය නොවේ, නමුත් ඔබ එසේ කළා නම්, එය කිරීමට ක්‍රම රාශියක් තිබේ. බොහෝ දෙනෙක් ඉහත 1K බ්ලොක් තාක්ෂණය භාවිතා කරන බව පෙනේ, පසුව ඩු වෙත දෙවන ඇමතුමක් ලබා දේ.

/server/62411/how-can-i-sort-du-h-output-by-size

එකතු කරන ලද KB ඒකක දැකීමට ඔබට අවශ්‍ය නම්, භාවිතා කරන්න:

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

ඔබට GNU coreutils හි මෑත සංස්කරණයක් නොමැති නම් , ඔබට වර්ග කළ හැකි ප්‍රතිදානයක් ලබා 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 පරාසයේ සංඛ්‍යා සඳහා දශම ඉලක්කම් පෙන්වීම පා er කයාට අභ්‍යාසයක් ලෙස ඉතිරි වේ.

ඔබට නොමැති නම් ඔබට මෙය 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/'

මෙය ඩු ලැයිස්තුව ලබා ගනී, උපසර්ගය වෙන් කරයි, සහ එය භාවිතා කරමින් වර්ග කරයි. <1K සඳහා උපසර්ගයක් නොමැති බැවින්, පළමු sed විසින් B (බයිට් සඳහා) එකතු කරයි. දෙවන sed එක ඉලක්කම් සහ උපසර්ගය අතර පරිසීමකයක් එක් කරයි. තෙවන සෙඩ් එක එම් ට වඩා විශාල වන පරිදි ජී ඉසෙඩ් බවට පරිවර්තනය කරයි; ඔබට ටෙරාබයිට් ලිපිගොනු තිබේ නම්, ඔබට G සිට Y සහ T Z බවට පරිවර්තනය කළ යුතුය. අවසාන වශයෙන්, අපි තීරු දෙකෙන් වර්ග කර, පසුව අපි G උපසර්ගය ආදේශ කරමු.

OS X මෙහෙයුම් පද්ධතිය මත, ඔබ හරහා අවශ්ය coreutils ස්ථාපනය කළ හැකි බරපැනක් :

brew install coreutils

මේ සමඟ ඔබට විධාන රේඛා පරාමිතිය gsortඇතුළත් වේ -h.

මෙම කුඩා පර්ල් පිටපත උපක්‍රමය කරයි. එය 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;

මැක් OS X මෙහෙයුම් පද්ධතිය වන කර නොමැති නිසා -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) හෝ උකුස්සන් සමඟ අත්හදා බැලුවෙමි.

මැක්හි ප්‍රතිදානයේ නියැදියක් මෙන්න:

     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 *

මෙන්න මම උබුන්ටු 10.04, සෙන්ටෝස් 5.5, ෆ්‍රීබීඑස්ඩී සහ මැක් ඕඑස් එක්ස් හි භාවිතා කරන දේ.

මම අදහස 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:~ $

මෙම පිටපත සමඟ පිස්සු වැටෙන්න -

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

GNU නොමැති විට 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 }'

සහාය නොවන whitespace හෝ ලොප් ලකුණ පිළිගනු මෙම එක් හැන්ඩ්ල් ගොනු නාමය, සහ පද්ධති මත ක්රියා xargs -dහෝ sort -h:

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

එහි ප්‍රති results ලය:

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

මෙය ප්‍රමාණය අඩු වන අනුපිළිවෙලින් ප්‍රතිදානය වර්ග කරයි:

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

මෙය ප්‍රමාණය වැඩි වන අනුපිළිවෙලින් ප්‍රතිදානය වර්ග කරයි:

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

PS: මෙය ඕනෑම තීරුවකින් වර්ග කිරීම සඳහා භාවිතා කළ හැකි නමුත් එම තීරු අගයන් එකම ආකෘතියකින් තිබිය යුතුය

සොලාරිස් මත පරීක්ෂා කර ඇත!

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

මෙය සියළුම ඩිරෙක්ටරි ප්‍රමාණයන් පුනරාවර්තව ප්‍රතිදානය කරනු ඇත, පතුලේ ගිගාබයිට් වල විශාලතම නාමාවලිය වනු ඇති අතර ඉහළම කුඩාම කිලෝබයිට් වේ.

විශාලතම පතුලේ:

du -sh * | sort -h

විධානය:

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

පැහැදිලි කිරීම:

• වර්තමාන නාමාවලියෙහි පුනරාවර්තන ලෙස සියලුම ලිපිගොනු / ෆෝල්ඩර වල ප්‍රමාණය මිනිස් කියවිය හැකි ආකාරයෙන් ලැයිස්තුගත කරන්න

du -ah .

• පළමු තීරුවේ ඇති මිනිස් කියවිය හැකි ප්‍රමාණය වර්ග කර විශාලතම 50 තබා ගන්න

sort -k1 -h | tail -n 50

ප්‍රමාණයෙන් MB අනුව වර්ග කිරීමට

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

මෙම පිටපත ඊටත් වඩා පහසු ය:

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

OSX සඳහා

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