เครื่องมือมาตรฐานในการแปลงจำนวนไบต์เป็นมนุษย์ KiB MiB ฯลฯ เช่น du, ls1

มีเครื่องมือมาตรฐานที่แปลงจำนวนเต็มจำนวนไบต์เป็นจำนวนที่มนุษย์สามารถอ่านได้ของหน่วยขนาดที่ใหญ่ที่สุดที่เป็นไปได้ในขณะที่รักษาค่าตัวเลขระหว่าง 1.00 ถึง 1023.99?

ฉันมีสคริปต์ทุบตี / awk ของตัวเอง แต่ฉันกำลังมองหาเครื่องมือมาตรฐานซึ่งพบได้ในหลาย / distros ส่วนใหญ่ ... บางสิ่งบางอย่างที่มีอยู่โดยทั่วไปมากขึ้นและมีคำสั่ง args บรรทัดคำสั่งง่าย ๆ และ / หรือสามารถรับอินพุต piped

นี่คือตัวอย่างของประเภทของผลลัพธ์ที่ฉันกำลังมองหา

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

อัปเดตที่  นี่เป็นสคริปต์Gillesรุ่นที่แก้ไขตามที่อธิบายไว้ในความคิดเห็นต่อคำตอบของเขา .. (แก้ไขให้เหมาะกับรูปลักษณ์ที่ฉันต้องการ)

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

ไม่ไม่มีเครื่องมือมาตรฐานดังกล่าว

ตั้งแต่ GNU coreutils 8.21 (กุมภาพันธ์ 2013 จึงยังไม่ได้อยู่ในการกระจายทั้งหมด) ที่ไม่ฝัง Linux และ Cygwin numfmtคุณสามารถใช้ มันไม่ได้สร้างรูปแบบเอาท์พุทเหมือนกันอย่างแน่นอน (จาก coreutils 8.23 ​​ฉันไม่คิดว่าคุณจะได้ตัวเลข 2 หลักหลังจุดทศนิยม)

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

เครื่องมือ GNU รุ่นเก่าจำนวนมากสามารถสร้างรูปแบบนี้และการเรียงลำดับ GNU สามารถเรียงลำดับตัวเลขกับหน่วยตั้งแต่ coreutils 7.5 (สิงหาคม 2009 ดังนั้นจึงมีอยู่ในการกระจาย Linux ที่ไม่ฝังตัวที่ทันสมัย)

ฉันพบว่ารหัสของคุณซับซ้อนเล็กน้อย นี่เป็นเวอร์ชั่น 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}'

(โพสต์จากคำถามพิเศษเพิ่มเติม )

ณ วันที่8.21, coreutilsรวมถึงnumfmt:

numfmtอ่านตัวเลขในรูปแบบต่าง ๆ และทำการฟอร์แมตใหม่ตามที่ร้องขอ
การใช้งานที่พบบ่อยที่สุดคือการแปลงตัวเลขเป็น / จาก การเป็นตัวแทนของมนุษย์

เช่น

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

5.2Ti

ตัวอย่างอื่น ๆ (รวมถึงการกรองอินพุต / เอาต์พุต ฯลฯ การประมวลผล) ถูกแสดงไว้ที่นี่

นอกจากนี้ยังเป็นของcoreutilsv. 8.24, numfmtสามารถดำเนินการหลายเขตข้อมูลที่มีคุณสมบัติหลากหลายฟิลด์คล้ายกับcutและสนับสนุนการตั้งค่าความแม่นยำการส่งออกที่มี--formatตัวเลือก
เช่น

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

tx: 175.782Ki rx: 1.908Mi

นี่คือตัวเลือก bash-only ไม่มีbcหรือไม่มี builtins อื่น ๆ + รูปแบบทศนิยมและหน่วยไบนารี

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

ควรทำงานได้ดีกับ Bash ทุกรุ่น (รวมถึง MSYSGit's Bash สำหรับ Windows)

นี่คือการเขียนที่สมบูรณ์แบบซึ่งได้แรงบันดาลใจมาจากสคริปต์ของ Gilles 'awk ที่แก้ไขโดย Peter.O

การเปลี่ยนแปลง:

• แก้ไขข้อผิดพลาดของ Peter.O ที่เขามองหาสตริง> 1 ตัวอักษรที่เขาควรมองหา> 4 ตัวอักษร เนื่องจากข้อผิดพลาดนั้นรหัสของเขาไม่ทำงานสำหรับหน่วย ZiB
• ลบการเข้ารหัสฮาร์ดโค้ดที่น่าเกลียดมากของขนาดยาวของหน่วยที่คั่นด้วยช่องว่าง
• เพิ่มสวิตช์บรรทัดคำสั่งเพื่อเปิดใช้งาน / ปิดใช้งานการขยาย
• เพิ่มสวิตช์บรรทัดคำสั่งเพื่อเปลี่ยนจาก base-1024 (KiB) ไปเป็นสัญกรณ์ฐาน 1000 (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}.";

สนุก!

มีperlโมดูลอยู่สองสามรายการใน CPAN: Format :: Human :: Bytes and Number :: Bytes :: Human , อันหลังนั้นสมบูรณ์มากขึ้นอีกเล็กน้อย:

$ 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

หมายเหตุ:ฟังก์ชั่นparse_bytes()ถูกเพิ่มเข้ามาในเวอร์ชั่น 0.09 (2013-03-01)

Via linux - มีตัวคำนวณบรรทัดคำสั่งสำหรับการคำนวณจำนวนไบต์หรือไม่? - Stack Overflowฉันพบเกี่ยวกับหน่วย GNU - แม้ว่าไม่มีตัวอย่างในหน้า SO; และเมื่อฉันไม่เห็นมันอยู่ที่นี่นี่เป็นบันทึกย่อเกี่ยวกับมัน

ขั้นแรกตรวจสอบว่ามีหน่วยอยู่หรือไม่:

$ 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

จริงๆแล้วมียูทิลิตี้ที่ทำสิ่งนี้ ฉันรู้เพราะมันเป็นฉันไม่ได้เขียน มันถูกเขียนขึ้นสำหรับ * BSD แต่ควรคอมไพล์บน Linux ถ้าคุณมีไลบรารี่ BSD (ซึ่งฉันเชื่อว่าเป็นเรื่องธรรมดา)

ฉันเพิ่งเปิดตัวเวอร์ชันใหม่โพสต์ที่นี่:

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

มันเรียกว่า hr และมันจะใช้ stdin (หรือไฟล์) และแปลงตัวเลขเป็นรูปแบบที่มนุษย์อ่านได้ในแบบที่ (ตอนนี้) เหมือนกับ ls -h และอื่น ๆ และสามารถเลือกแต่ละฟีดในบรรทัดสเกล หน่วยที่ปรับขนาดล่วงหน้า (เช่นถ้าอยู่ในบล็อกขนาด 512- ไบต์จะแปลงเป็น Mb ฯลฯ ) ปรับเปลี่ยนการขยายคอลัมน์และอื่น ๆ

ฉันเขียนเมื่อไม่กี่ปีที่ผ่านมาเพราะฉันคิดว่าการพยายามเขียนเชลล์สคริปต์ถึงแม้ว่าจะน่าสนใจ แต่ก็ยังบ้าคลั่งอยู่

ตัวอย่างเช่นการใช้ชั่วโมงคุณสามารถรับรายการขนาดของไดเรกทอรีที่เรียงลำดับ (ซึ่งออกมาในหน่วย 1Kb และต้องเปลี่ยนก่อนการแปลง) ด้วยรายการต่อไปนี้:

du -d1 | เรียง -n | ชม. - SK

ในขณะที่ du จะสร้างผลลัพธ์ -h เรียงลำดับจะไม่เรียงลำดับตามมัน การเพิ่ม -h ไปยังยูทิลิตี้ที่มีอยู่เป็นกรณีที่คลาสสิกที่ไม่เป็นไปตามปรัชญาของยูนิกซ์: มียูทิลิตี้อย่างง่ายที่ทำงานที่กำหนดไว้ได้ดีจริงๆ

นี่คือวิธีที่จะทำมันเกือบหมดจดในทุบตีเพียงแค่ต้องการ '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

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

@ don_crissti คำตอบแรกดี แต่อาจสั้นกว่านี้ได้โดยใช้Here Stringsเช่น

$ 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

เครื่องมือ Python มีอยู่

$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

ฉันไม่เห็น --binary flag :( ดังนั้นคุณต้องใช้ python โดยตรงในการแทนค่าไบนารี่:

$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

ฉันมีปัญหาเดียวกันและฉันได้อย่างรวดเร็วขึ้นมาด้วยวิธีง่ายๆโดยใช้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]
  }
'

และความแม่นยำที่หายไปในการใช้ตัวเลขลอยตัวนั้นไม่ได้แย่ขนาดนั้นเพราะความแม่นยำนั้นจะหายไปอย่างไรก็ตาม

คำตอบสำหรับคำถามของคุณคือใช่

ในขณะที่รูปแบบการออกไม่ตรงกับข้อกำหนดของคุณ, การแปลงตัวเองจะกระทำได้ง่ายโดยเครื่องมือมาตรฐานมาก(หรือสอง) สิ่งที่ฉันแนะนำคือdcและbc. คุณสามารถรับรายงานที่แบ่งกลุ่มโดยการเปลี่ยน radices ผลลัพธ์ แบบนี้:

{   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 ถึง 1,000 สตริงทศนิยมสามหลักและอื่น ๆ ตัวอย่างเช่นเลขฐานสิบ 1024 ในฐาน 25 จะถูกเขียนเป็น:

  01 15 24

  และในฐาน 125 ขณะที่:

  008 024

วิธีแก้ปัญหาเปลือกสั้นและหวาน:

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เป็น Korn-ish ทดแทนด้วยVAR=$(( expression ))สำหรับ Born-again-ish

AFAIK ไม่มีเครื่องมือมาตรฐานดังกล่าวซึ่งคุณสามารถส่งข้อความและส่งคืนแบบฟอร์มที่มนุษย์อ่านได้ คุณอาจสามารถหาแพ็คเกจเพื่อทำงานดังกล่าวให้สำเร็จสำหรับ distro ของคุณ

อย่างไรก็ตามฉันไม่เข้าใจว่าทำไมคุณอาจต้องใช้เครื่องมือดังกล่าว แพ็กเกจส่วนใหญ่ที่ให้เอาต์พุตที่เกี่ยวข้องมักจะมี -h หรือสวิตช์ที่เทียบเท่าสำหรับเอาต์พุตที่มนุษย์อ่านได้