बाइट-काउंट को मानव KiB MiB आदि में बदलने के लिए एक मानक उपकरण; du की तरह, ls1

94

क्या कोई मानक उपकरण है जो बाइट्स के पूर्णांक गणना को 1.00 और 1023.99 के बीच संख्यात्मक मान रखते हुए, सबसे बड़ी संभव इकाई आकार के मानव-पठनीय गणना में परिवर्तित करता है?

मेरे पास अपना बैश / awk स्क्रिप्ट है, लेकिन मैं एक मानक टूल की तलाश कर रहा हूं , जो कई / सबसे डिस्ट्रो पर पाया जाता है ... कुछ और आमतौर पर उपलब्ध होता है, और आदर्श रूप से सरल कमांड लाइन आर्ग होता है, और / या पाइप किए गए इनपुट को स्वीकार कर सकता है।

यहाँ आउटपुट के प्रकार के कुछ उदाहरण देख रहा हूँ।

    1    Byt  
  173.00 KiB  
   46.57 MiB  
    1.84 GiB  
   29.23 GiB  
  265.72 GiB  
    1.63 TiB

यहाँ बाइट्स-मानव स्क्रिप्ट है (उपरोक्त आउटपुट के लिए उपयोग किया जाता है)

awk -v pfix="$1" -v sfix="$2" 'BEGIN { 
      split( "Byt KiB MiB GiB TiB PiB", unit )
      uix = uct = length( unit )
      for( i=1; i<=uct; i++ ) val[i] = (2**(10*(i-1)))-1
   }{ if( int($1) == 0 ) uix = 1; else while( $1 < val[uix]+1 ) uix--
      num = $1 / (val[uix]+1)
      if( uix==1 ) n = "%5d   "; else n = "%8.2f"
      printf( "%s"n" %s%s\n", pfix, num, unit[uix], sfix ) 
   }'

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

awk 'function human(x) {
         s=" B   KiB MiB GiB TiB EiB PiB YiB ZiB"
         while (x>=1024 && length(s)>1) 
               {x/=1024; s=substr(s,5)}
         s=substr(s,1,4)
         xf=(s==" B  ")?"%5d   ":"%8.2f"
         return sprintf( xf"%s\n", x, s)
      }
      {gsub(/^[0-9]+/, human($1)); print}'

text-processing utilities units

— Peter.O
स्रोत

4

ऐसा लग रहा है कि हमारे यहाँ standard toolबनाने में एक नया है :)

— गौतम

@ गौतम - आपकी इच्छा सच हो गई होगी! मेरा जवाब नीचे या ब्लॉग पर

— FJL

ध्यान दें कि पिछले दो प्रत्ययों की अदला-बदली की जाती है; एक Yottabyte वास्तव में एक Zettabyte से बड़ा है।

— 1

89

नहीं, ऐसा कोई मानक उपकरण नहीं है।

चूंकि GNU Coreutils 8.21 (फ़रवरी 2013, इसलिए अभी तक सभी वितरण में मौजूद नहीं है), गैर-एम्बेडेड लिनक्स और साइगविन पर, आप उपयोग कर सकते हैं numfmt। यह ठीक उसी आउटपुट स्वरूप का उत्पादन नहीं करता है (जैसा कि 8.23 के कोर्यूटिल्स, मुझे नहीं लगता कि आप दशमलव अंकों के बाद 2 अंक प्राप्त कर सकते हैं)।

$ numfmt --to=iec-i --suffix=B --padding=7 1 177152 48832200 1975684956
     1B
 173KiB
  47MiB
 1.9GiB

कई पुराने GNU उपकरण इस प्रारूप का उत्पादन कर सकते हैं और GNU सॉर्ट कोर यूनिट्स 7.5 (अगस्त 2009, इसलिए आधुनिक गैर-एम्बेडेड लिनक्स वितरण पर मौजूद) से इकाइयों के साथ संख्याओं को सॉर्ट कर सकते हैं ।

मुझे आपका कोड थोड़ा जटिल लगता है। यहाँ एक क्लीनर awk संस्करण है (आउटपुट स्वरूप बिल्कुल समान नहीं है):

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)
    }
    {sub(/^[0-9]+/, human($1)); print}'

( अधिक विशिष्ट प्रश्न से पुनर्प्रकाशित )

— गाइल्स
स्रोत

ठीक है शुक्रिया। आपकी स्क्रिप्ट के बारे में, मैं मूल रूप से इसे पसंद करता हूं। कुछ चीजें हैं जो मेरा ध्यान आकर्षित करती हैं: (1) संस्करण sमें अग्रणी होना चाहिए B। इसके अलावा यह स्ट्रिंग आसानी से IEC बाइनरी नोटेशन में बदल जाती है। (२) यह १,१००-१०२३ की सीमा को १ <अगले आकार के पक्ष में (आसानी से परिवर्तित) कर देता है (३) इसमें दशमलव मान नहीं होता (जो मुझे चाहिए)। फिर से यह आसानी से बदल जाता है। 2 दशमलव स्थानों को प्रदर्शित करते समय, %fप्रारूप 1019-1023round-up मानों के लिए <अगले आकार> का कारण बनता है ; लेकिन यह वर्कअराउंड के लायक नहीं है। मैंने अपने उत्तर में एक संशोधित संस्करण पोस्ट किया है, सामान्य संदर्भ के लिए।

— पीटर।

osx homebrew उपयोगकर्ताओं को

— कोरुटिल

जो लोग कनवर्ट करना चाहते हैं के लिए duमानव पठनीय प्रारूप करने के लिए संख्या, जिसे आप जोड़ना आवश्यकता हो सकती है ध्यान दें --block-size=1करने के लिए duआदेश।

— पावमॉय

68

वी के रूप में। 8.21, coreutilsशामिल हैं numfmt:

numfmtअनुरोध के अनुसार विभिन्न अभ्यावेदन और सुधारों में संख्याओं को पढ़ता है।
सबसे आम उपयोग मानव अभ्यावेदन के लिए / से संख्या को परिवर्तित करना है ।

जैसे

printf %s\\n 5607598768908 | numfmt --to=iec-i

5.2Ti

विभिन्न अन्य उदाहरण (फ़िल्टरिंग, इनपुट / आउटपुट प्रोसेसिंग सहित) यहां प्रस्तुत किए गए हैं ।

इसके अलावा, के रूप में coreutilsवी। 8.24, numfmtके लिए इसी तरह क्षेत्र रेंज विनिर्देशों के साथ कई क्षेत्रों संसाधित कर सकते हैं cut, और साथ उत्पादन परिशुद्धता की स्थापना का समर्थन करता है --formatविकल्प
जैसे

numfmt --to=iec-i --field=2,4 --format='%.3f' <<<'tx: 180000 rx: 2000000'

tx: 175.782Ki rx: 1.908Mi

— don_crissti
स्रोत

numfmt कोरुटिल्स-8.21 के बाद से कोरुटिल्स पैकेज में एक नया जोड़ा गया उपकरण है।

— ज़मा कुएस

1

यह अब स्वीकृत उत्तर होना चाहिए।

— एंडी फोस्टर

23

यहां एक बैश-केवल विकल्प, कोई bcया कोई अन्य गैर-निर्मित, + दशमलव प्रारूप और बाइनरी इकाइयाँ नहीं हैं।

bytesToHuman() {
    b=${1:-0}; d=''; s=0; S=(Bytes {K,M,G,T,P,E,Z,Y}iB)
    while ((b > 1024)); do
        d="$(printf ".%02d" $((b % 1024 * 100 / 1024)))"
        b=$((b / 1024))
        let s++
    done
    echo "$b$d ${S[$s]}"
}

उदाहरण:

$ bytesToHuman 123456789
117.73 MiB

$ bytesToHuman 1000000000000 # "1TB of storage"
931.32 GiB                   #  1TB of storage

$ bytesToHuman 
0 Bytes

वहां बैश के किसी भी संस्करण पर अच्छा प्रदर्शन करना चाहिए (जिसमें विंडोज के लिए MSYSGit का बैश भी शामिल है)।

— कैमिलो मार्टिन
स्रोत

मेरी बैश जरूरतों के लिए यह सबसे अच्छा जवाब है। दुर्भाग्य से यह ओपी तिथि के बाद एक दशक 1/2 पोस्ट किया गया है जिसका अर्थ है कि मतदान की सूची को स्थानांतरित करने में थोड़ा समय लगेगा।

— विनयुनुच्स 2 यूनिक्स

@ WinEunuuchs2Unix धन्यवाद, मुझे खुशी है कि यह आपके लिए उपयोगी था :)

— कैमिलो मार्टिन

ध्यान दें कि पिछले दो प्रत्ययों की अदला-बदली की जाती है; एक Yottabyte वास्तव में एक Zettabyte से बड़ा है।

— 1

6

यह एक पूरी तरह से फिर से लिखना है जो पीटर.ओ द्वारा संशोधित गिल्स की awk स्क्रिप्ट का संशोधित संस्करण है।

परिवर्तन:

पतरस के बग को ठीक करता है जहां वह> 1 वर्ण की एक स्ट्रिंग की तलाश करता है जहां उसे एक> 4 वर्णों की तलाश करनी चाहिए। उस बग के कारण, उसका कोड ZiB इकाइयों के लिए काम नहीं करता है।
अंतरिक्ष-पृथक इकाई आकार के एक लंबे स्ट्रिंग के बहुत बदसूरत हार्डकोडिंग को हटा देता है।
पैडिंग को सक्षम / अक्षम करने के लिए कमांड लाइन स्विच जोड़ता है।
आधार -१०१ command (KiB) से आधार -१००० (KB) अंकन तक जाने के लिए कमांड लाइन स्विच जोड़ता है।
फ़ंक्शन का उपयोग करने के लिए एक आसान में इसे लपेटता है।
मैं इसे सार्वजनिक डोमेन में रखता हूं और व्यापक उपयोग का स्वागत करता हूं।

कोड:

bytestohuman() {
    # converts a byte count to a human readable format in IEC binary notation (base-1024), rounded to two decimal places for anything larger than a byte. switchable to padded format and base-1000 if desired.
    local L_BYTES="${1:-0}"
    local L_PAD="${2:-no}"
    local L_BASE="${3:-1024}"
    BYTESTOHUMAN_RESULT=$(awk -v bytes="${L_BYTES}" -v pad="${L_PAD}" -v base="${L_BASE}" 'function human(x, pad, base) {
         if(base!=1024)base=1000
         basesuf=(base==1024)?"iB":"B"

         s="BKMGTEPYZ"
         while (x>=base && length(s)>1)
               {x/=base; s=substr(s,2)}
         s=substr(s,1,1)

         xf=(pad=="yes") ? ((s=="B")?"%5d   ":"%8.2f") : ((s=="B")?"%d":"%.2f")
         s=(s!="B") ? (s basesuf) : ((pad=="no") ? s : ((basesuf=="iB")?(s "  "):(s " ")))

         return sprintf( (xf " %s\n"), x, s)
      }
      BEGIN{print human(bytes, pad, base)}')
    return $?
}

परीक्षण मामले (यदि आप आउटपुट को देखना चाहते हैं):

bytestohuman 1; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 500; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1023; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1024; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1500; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000000; echo "${BYTESTOHUMAN_RESULT}.";

bytestohuman 1 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 500 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1023 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1024 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1500 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000 no 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000000 no 1000; echo "${BYTESTOHUMAN_RESULT}.";

bytestohuman 1 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 500 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1023 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1024 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1500 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000 yes; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000000 yes; echo "${BYTESTOHUMAN_RESULT}.";

bytestohuman 1 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 500 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1023 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1024 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 1500 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";
bytestohuman 150000000000000000000 yes 1000; echo "${BYTESTOHUMAN_RESULT}.";

का आनंद लें!

— जॉन
स्रोत

5

perlसीपीएएन पर कुछ मॉड्यूल हैं: प्रारूप :: मानव :: बाइट्स और संख्या :: बाइट्स :: मानव , बाद वाला एक सा और अधिक है:

$ echo 100 1000 100000 100000000 |
  perl -M'Number::Bytes::Human format_bytes' -pe 's/\d{3,}/format_bytes($&)/ge'
100 1000 98K 96M

$ echo 100 1000 100000 100000000 |
  perl -M'Number::Bytes::Human format_bytes' -pe 's/\d{3,}/
   format_bytes($&,bs=>1000, round_style => 'round', precision => 2)/ge'
100 1.00k 100k 100M

और रिवर्स:

$ echo 100 1.00k 100K 100M 1Z |
  perl -M'Number::Bytes::Human parse_bytes' -pe '
    s/[\d.]+[kKMGTPEZY]/parse_bytes($&)/ge'
100 1024 102400 104857600 1.18059162071741e+21

नोट: फ़ंक्शन 0.09 संस्करण में जोड़ाparse_bytes() गया था (2013-03-01)

— स्टीफन चेज़लस
स्रोत

5

वाया लिनक्स - बाइट गणना के लिए एक कमांड लाइन कैलकुलेटर है? - स्टैक ओवरफ्लो , मैंने जीएनयू इकाइयों के बारे में पाया - हालांकि एसओ पृष्ठ पर उदाहरण के बिना; और जैसा कि मैंने इसे यहां सूचीबद्ध नहीं देखा है, यहां इसके बारे में एक छोटा सा नोट है।

पहले, जांचें कि क्या यूनिट मौजूद हैं:

$ units --check-verbose |grep byte
doing 'byte'

$ units --check-verbose |grep mega
doing 'megalerg'
doing 'mega'

$ units --check-verbose |grep mebi
doing 'mebi'

यह देखते हुए कि वे हैं, रूपांतरण करते हैं - printfप्रारूप विनिर्देशक संख्यात्मक परिणाम को प्रारूपित करने के लिए स्वीकार किए जाते हैं:

$ units --one-line -o "%.15g" '20023450 bytes' 'megabytes'  # also --terse
    * 20.02345
$ units --one-line -o "%.15g" '20023450 bytes' 'mebibytes' 
    * 19.0958499908447
$ units --one-line -o "%.5g" '20023450 bytes' 'mebibytes' 
    * 19.096

— sdaau
स्रोत

3

दरअसल, एक उपयोगिता है जो वास्तव में ऐसा करती है। मुझे पता है कि यह मेरे लिए लिखा था। यह * बीएसडी के लिए लिखा गया था, लेकिन अगर आपके पास बीएसडी लाइब्रेरी (जो मुझे लगता है कि आम हैं) लिनक्स पर संकलन करने के लिए चाहिए।

मैंने अभी एक नया संस्करण जारी किया है, यहाँ पोस्ट किया गया है:

http://blog.frankleonhardt.com/2015/freebsd-hr-utility-human-readable-number-filter-man-page/

इसे hr कहा जाता है, और यह stdin (या फ़ाइलें) लेगा और संख्याओं को मानव-पठनीय प्रारूप में इस तरह से रूपांतरित करेगा, जो (अब) बिल्कुल ls -h और इसी तरह है, और यह लाइनों में व्यक्तिगत फीड्स का चयन कर सकता है, स्केल पूर्व-स्केल की गई इकाइयाँ (जैसे यदि वे 512-बाइट ब्लॉक में हैं, उन्हें एमबी आदि में परिवर्तित करती हैं), कॉलम पैडिंग को समायोजित करें, और इसी तरह।

मैंने इसे कुछ साल पहले लिखा था क्योंकि मुझे लगा कि एक शेल स्क्रिप्ट लिखने की कोशिश की जा रही है, हालांकि बौद्धिक रूप से दिलचस्प, पागलपन भी था।

उदाहरण के लिए, hr का उपयोग करके, आप आसानी से निर्देशिका आकारों की एक क्रमबद्ध सूची प्राप्त कर सकते हैं (जो 1Kb इकाइयों में निकलती हैं और परिवर्तित करने से पहले स्थानांतरण की आवश्यकता होती है) निम्नलिखित के साथ:

डु -d1 | सॉर्ट-एन | hr -sK

जबकि du -h आउटपुट का उत्पादन करेगा, इसके द्वारा सॉर्ट नहीं होगा। मौजूदा उपयोगिताओं के लिए -h के अलावा यूनिक्स दर्शन का पालन नहीं करने का एक क्लासिक मामला है: सरल उपयोगिताओं को परिभाषित नौकरियों को वास्तव में अच्छी तरह से करना है।

— FJL
स्रोत

2

यहाँ यह लगभग पूरी तरह से बैश में करने का एक तरीका है, बस फ़्लोटिंग पॉइंट गणित के लिए 'bc' की आवश्यकता है।

function bytesToHR() {
        local SIZE=$1
        local UNITS="B KiB MiB GiB TiB PiB"
        for F in $UNITS; do
                local UNIT=$F
                test ${SIZE%.*} -lt 1024 && break;
                SIZE=$(echo "$SIZE / 1024" | bc -l)
        done

    if [ "$UNIT" == "B" ]; then
        printf "%4.0f    %s\n" $SIZE $UNIT
    else
        printf "%7.02f %s\n" $SIZE $UNIT
    fi
}

उपयोग:

bytesToHR 1
bytesToHR 1023
bytesToHR 1024
bytesToHR 12345
bytesToHR 123456
bytesToHR 1234567
bytesToHR 12345678

आउटपुट:

   1    B
1023    B
   1.00 KiB
  12.06 KiB
 120.56 KiB
   1.18 MiB
  11.77 MiB

— जेफ्री
स्रोत

1

user@host:/usr$ alias duh="du -s -B1 * | sort -g | numfmt --to=iec-i --format='%10f'"
user@host:/usr$ duh

देता है:

 4.0Ki games
 3.9Mi local
  18Mi include
  20Mi sbin
 145Mi bin
 215Mi share
 325Mi src
 538Mi lib

दुर्भाग्य से मैं समझ नहीं पा रहा हूँ कि दो दशमलव सटीकता कैसे प्राप्त करें। Ubuntu 14.04 पर परीक्षण किया गया।

— क्रिस
स्रोत

1

@ don_crissti का पहला उत्तर अच्छा है, लेकिन यहां स्ट्रिंग्स , जैसे का उपयोग करके भी कम किया जा सकता है

$ numfmt --to=iec-i <<< "12345"
13Ki

$ numfmt --to=iec-i --suffix=B <<< "1234567"
1.2MiB

या और भी

$ numfmt --from=iec-i --to=iec-i --suffix=B <<< "12345Ki"
13MiB

यदि <<<उपलब्ध नहीं है तो आप उदाहरण के लिए उपयोग कर सकते हैं

$ echo "1234567" | numfmt --to=iec-i --suffix=B
1.2MiB

— craeckie
स्रोत

1

अजगर उपकरण मौजूद हैं

$pip install humanfriendly  # Also available as a --user install in ~/.local/bin

$humanfriendly --format-size=2048
2.05 KB
$humanfriendly --format-number=2048
2,048

मुझे एक -बिना ध्वज नहीं दिखता है :(, इसलिए आपको बाइनरी प्रतिनिधित्व के लिए सीधे अजगर का उपयोग करना होगा:

$python -c 'import sys, humanfriendly; print(humanfriendly.format_size(int(sys.argv[1]), binary=True))' 2048
2 KiB
$python -c 'import sys, humanfriendly; print(humanfriendly.format_size(int(sys.argv[1]), binary=True))' 2000
1.95 KiB

— ThorSummoner
स्रोत

1

मैं एक ही समस्या थी और मैं जल्दी का उपयोग कर एक सरल उपाय के साथ आया था awk's log()समारोह:

awk '
  BEGIN {
    split("B,kiB,MiB,GiB", suff, ",")
  }

  {
    size=$1;
    rank=int(log(size)/log(1024));
    printf "%.4g%s\n", size/(1024**rank), suff[rank+1]
  }
'

और फ्लोट नंबरों का उपयोग करने में खोई गई सटीकता खराब नहीं होती है क्योंकि उस परिशुद्धता को वैसे भी खो दिया जाएगा।

— बेंस किग्सिस
स्रोत

0

आपके प्रश्न का उत्तर है - हां।

हालांकि आउटपुट स्वरूप आपके विनिर्देशन के समान नहीं है, रूपांतरण स्वयं एक बहुत ही मानक उपकरण (या दो) द्वारा आसानी से किया जाता है । जिन लोगों को मैं संदर्भित करता हूं वे हैं dcऔर bc। आप उनके आउटपुट मूलक को बदलकर खंडित रिपोर्ट प्राप्त कर सकते हैं। ऐशे ही:

{   echo 1024 o           #set dc's output radix
    echo 1023 pc          #echo a number then print + clear commands
    echo 1024 pc
    echo 1025 pc
    echo 8000000 pc
} | dc

... जो प्रिंट करता है ...

 1023                    #1 field 1023 bytes
 0001 0000               #2 fields 1k 0b
 0001 0001               #2 fields 1k 1b
 0007 0644 0512          #3 fields 7m 644k 512b or 7.64m

मैं dcऊपर का उपयोग करता हूं क्योंकि यह एक व्यक्तिगत पसंदीदा है, लेकिन bcविभिन्न सिंटैक्स के साथ भी ऐसा ही कर सकते हैं और एक ही प्रारूप के नियमों का पालन करते हैं जैसे कि POSIX द्वारा निर्दिष्ट किया गया है:

bc obase
- 16 से अधिक आधारों के लिए, प्रत्येक अंक को एक अलग बहु अंकों दशमलव संख्या के रूप में लिखा जाएगा। सबसे महत्वपूर्ण अंश वाले अंक को छोड़कर प्रत्येक अंक एक ही स्थान से पहले होगा । 17 से 100 तक के ठिकानों के लिए, bcदो अंकों की दशमलव संख्या लिखेंगे; 101 से 1000 तक के बेस के लिए, तीन-अंकीय दशमलव तार, और इसी तरह। उदाहरण के लिए, बेस 25 में दशमलव संख्या 1024 इस प्रकार लिखा जाएगा:
01 15 24

और बेस 125 में,

008 024

— mikeserv
स्रोत

-1

लघु और मीठा, केवल समाधान खोल:

convertB_human() {
NUMBER=$1
for DESIG in Bytes KB MB GB TB PB
do
   [ $NUMBER -lt 1024 ] && break
   let NUMBER=$NUMBER/1024
done
printf "%d %s\n" $NUMBER $DESIG
}

यह दशमलव औषधि नहीं दिखाता है।

let VAR=expressionकॉर्न-ish है। साथ VAR=$(( expression ))जन्मे फिर से ish के लिए स्थानापन्न ।

— जोहान
स्रोत

यह समाधान एक टन त्रुटि का परिचय देता है क्योंकि / 1024 हमेशा गोल होता है, मुझे यकीन है कि आप 1.5 TiB से 2 TiB तक का चक्कर नहीं लगाना चाहेंगे।

— ज्योफ्री

-2

AFAIK ऐसा कोई मानक उपकरण नहीं है जिससे आप पाठ को पास कर सकें और यह एक मानव पठनीय रूप देता है। आप अपने डिस्ट्रो के लिए उक्त कार्य को पूरा करने के लिए एक पैकेज खोजने में सक्षम हो सकते हैं।

हालाँकि, मुझे समझ नहीं आ रहा है कि आपको ऐसे उपकरण की आवश्यकता क्यों हो सकती है। अधिकांश पैकेज जो संबंधित आउटपुट देते हैं, आमतौर पर मानव-पठनीय आउटपुट के लिए -h या समकक्ष स्विच होता है।

— darnir
स्रोत

1

समझ के प्रयोजनों के लिए: मानव-पठनीय का मतलब बस यही है; मनुष्यों द्वारा पठनीय। आपके द्वारा उल्लिखित टूल द्वारा दिखाए गए आकार की विभिन्न विभिन्न इकाइयां प्रोग्रामेटिक गणनाओं के लिए अभिप्रेत नहीं हैं, जिनके लिए इकाइयों की एकरूपता आवश्यक है। बाइट्स के साथ काम करना, जो हमेशा पूर्णांक होते हैं, एकमात्र तरीका है जो बैश उनके साथ कोई भी अंकगणित कर सकता है। तो ... बाइट्स में गणना करें ... रिपोर्ट में मानव , जैसे। "आप स्थायी रूप से 3 फ़ाइलों को नष्ट करने वाले हैं, कुल 2.44 GiB। जारी रखें?

— पीटर।

मुझे लगता है कि यह आपके प्रश्न का हिस्सा होना चाहिए। मुझे लगता है जैसे आपको समस्या हल हो गई है। सौभाग्य।

— शेल्टर

1

एक सामान्य अनुप्रयोग छँटाई के लिए बाइट्स की संख्या उत्पन्न करना और छँटाई के बाद मानव-पठनीय इकाइयों में बदलना है।

— गाइल्स