Một công cụ tiêu chuẩn để chuyển đổi số byte thành KiB MiB của con người, v.v; như du, ls1

Có một công cụ tiêu chuẩn chuyển đổi số lượng byte nguyên thành số đếm có thể đọc được của con người với kích thước đơn vị lớn nhất có thể, trong khi vẫn giữ giá trị số trong khoảng từ 1,00 đến 1023,99?

Tôi có tập lệnh bash / awk của riêng mình, nhưng tôi đang tìm kiếm một công cụ tiêu chuẩn , được tìm thấy trên nhiều / hầu hết ... một cái gì đó thường có sẵn hơn, và lý tưởng là có dòng lệnh đơn giản, và / hoặc có thể chấp nhận đầu vào đường ống.

Dưới đây là một số ví dụ về loại đầu ra mà tôi đang tìm kiếm.

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

Đây là kịch bản byte-human (được sử dụng cho đầu ra ở trên)

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

Cập nhật  Dưới đây là phiên bản sửa đổi của tập lệnh Gilles , như được mô tả trong một nhận xét cho câu trả lời của anh ấy .. (được sửa đổi cho phù hợp với giao diện ưa thích của tôi).

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

Không, không có công cụ tiêu chuẩn như vậy.

Vì GNU coreutils 8.21 (Tháng 2 năm 2013, do đó chưa có trong tất cả các bản phân phối), trên Linux và Cygwin không được nhúng, bạn có thể sử dụng numfmt. Nó không tạo ra chính xác định dạng đầu ra giống như (như coreutils 8.23, tôi không nghĩ bạn có thể nhận được 2 chữ số sau dấu thập phân).

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

Nhiều công cụ GNU cũ hơn có thể tạo định dạng này và sắp xếp GNU có thể sắp xếp các số với các đơn vị kể từ coreutils 7.5 (tháng 8 năm 2009, do đó có mặt trên các bản phân phối Linux không nhúng hiện đại).

Tôi tìm thấy mã của bạn một chút phức tạp. Đây là phiên bản awk sạch hơn (định dạng đầu ra không giống hệt nhau):

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

(Đăng lại từ một câu hỏi chuyên sâu hơn )

Kể từ v. 8.21, coreutilsBao gồm numfmt:

numfmtđọc các số trong các đại diện khác nhau và định dạng lại chúng theo yêu cầu.
Cách sử dụng phổ biến nhất là chuyển đổi số thành / từ đại diện của con người .

ví dụ

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

5,2Ti

Nhiều ví dụ khác (bao gồm lọc, xử lý đầu vào / đầu ra, v.v.) được trình bày TẠI ĐÂY .

Ngoài ra, kể từ coreutilsv. 8.24, numfmtCó thể xử lý nhiều trường có thông số phạm vi trường tương tự cutvà hỗ trợ cài đặt độ chính xác đầu ra với --formattùy chọn,
ví dụ:

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

tx: 175,782Ki rx: 1,908Mi

Đây là một tùy chọn chỉ bash, không bchoặc bất kỳ phần tử không tích hợp nào khác, + định dạng thập phân và đơn vị nhị phân.

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]}"
}

Ví dụ:

$ bytesToHuman 123456789
117.73 MiB

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

$ bytesToHuman 
0 Bytes

Nên hoạt động tốt trên mọi phiên bản Bash ngoài kia (bao gồm cả Bash cho Windows của MSYSGit).

Đây là một bản viết lại hoàn chỉnh lấy cảm hứng từ phiên bản sửa đổi của kịch bản awk Gilles của Peter.O.

Thay đổi:

• Khắc phục lỗi của Peter.O khi anh ta tìm kiếm một chuỗi> 1 ký tự trong đó anh ta sẽ tìm kiếm một> 4 ký tự. Do lỗi đó, mã của anh ta không hoạt động cho các đơn vị ZiB.
• Loại bỏ mã hóa rất xấu của một chuỗi dài các kích thước đơn vị được phân tách bằng dấu cách.
• Thêm các công tắc dòng lệnh để bật / tắt phần đệm.
• Thêm các chuyển đổi dòng lệnh để đi từ ký hiệu cơ sở 1024 (KiB) sang ký hiệu cơ sở 1000 (KB).
• Kết thúc tất cả trong một chức năng dễ sử dụng.
• Tôi đặt nó trong phạm vi công cộng và hoan nghênh sử dụng rộng rãi.

Mã số:

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 $?
}

Test Case (nếu bạn muốn xem đầu ra):

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}.";

Thưởng thức!

Có một vài perlmô-đun trên CPAN: Format :: Human :: Bytes và Number :: Bytes :: Human , cái sau hoàn chỉnh hơn một chút:

$ 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

Và ngược lại:

$ 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

LƯU Ý: chức năng parse_bytes()đã được thêm vào trong phiên bản 0.09 (2013-03-01)

Qua linux - Có máy tính dòng lệnh để tính toán byte không? - Stack Overflow , tôi tìm thấy về Đơn vị GNU - mặc dù không có ví dụ trên trang SO; và như tôi đã không thấy nó được liệt kê ở đây, đây là một lưu ý nhỏ về nó.

Đầu tiên, kiểm tra xem các đơn vị có mặt:

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

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

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

Cho rằng chúng là, làm một công printfcụ xác định định dạng chuyển đổi được chấp nhận để định dạng kết quả số:

$ 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

Trên thực tế, có một tiện ích thực hiện chính xác điều này. Tôi biết cos đó là tôi đã viết nó. Nó được viết cho * BSD nhưng phải biên dịch trên Linux nếu bạn có các thư viện BSD (mà tôi tin là phổ biến).

Tôi vừa phát hành một phiên bản mới, được đăng ở đây:

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

Nó được gọi là hr, và nó sẽ lấy stdin (hoặc tệp) và chuyển đổi số thành định dạng có thể đọc được theo cách mà (hiện tại) giống hệt như ls -h, v.v. và nó có thể chọn các nguồn cấp dữ liệu riêng lẻ theo dòng, chia tỷ lệ các đơn vị được chia tỷ lệ trước (ví dụ: nếu chúng ở các khối 512 byte chuyển đổi chúng thành Mb, v.v.), điều chỉnh phần đệm cột, v.v.

Tôi đã viết nó vài năm trước bởi vì tôi nghĩ cố gắng viết một kịch bản shell, mặc dù thú vị về mặt trí tuệ, cũng hoàn toàn điên rồ.

Ví dụ, sử dụng hr, bạn có thể dễ dàng nhận được một danh sách các kích thước thư mục được sắp xếp (xuất hiện theo đơn vị 1Kb và cần thay đổi trước khi chuyển đổi) với các mục sau:

du -d1 | sắp xếp -n | giờ -sK

Trong khi du sẽ tạo ra đầu ra -h, sắp xếp sẽ không sắp xếp theo nó. Việc bổ sung -h vào các tiện ích hiện có là một trường hợp kinh điển không tuân theo triết lý unix: có các tiện ích đơn giản thực hiện tốt các công việc được xác định.

Đây là một cách để làm điều đó gần như hoàn toàn trong bash, chỉ cần 'bc' cho phép toán dấu phẩy động.

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
}

Sử dụng:

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

Đầu ra:

   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

Cung cấp:

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

Thật không may, tôi không thể tìm ra làm thế nào để có được hai số thập phân chính xác. Đã thử nghiệm trên Ubuntu 14.04.

Câu trả lời đầu tiên của @ don_crissti's là tốt, nhưng thậm chí có thể ngắn hơn bằng cách sử dụng Here String , vd

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

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

hoặc thậm chí

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

nếu <<<không có sẵn, bạn có thể sử dụng, vd

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

Công cụ Python tồn tại

$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

Tôi không thấy cờ --binary :(, vì vậy bạn phải sử dụng trực tiếp python để thể hiện nhị phân:

$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

Tôi đã cùng một vấn đề và tôi nhanh chóng đưa ra một giải pháp đơn giản sử dụng awk's log()chức năng:

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

Và độ chính xác bị mất khi sử dụng số float không phải là xấu vì độ chính xác đó sẽ bị mất.

Câu trả lời cho câu hỏi của bạn là có.

Mặc dù định dạng đầu ra không chính xác theo đặc điểm kỹ thuật của bạn, nhưng việc chuyển đổi được thực hiện dễ dàng bằng một công cụ rất chuẩn (hoặc hai) . Những cái mà tôi giới thiệu là dcvà bc. Bạn có thể nhận được một báo cáo được phân đoạn bằng cách thay đổi các radice đầu ra của chúng. Như thế này:

{   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

... mà in ...

 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

Tôi sử dụng dcở trên vì nó là một mục yêu thích cá nhân, nhưng bccó thể làm tương tự với các cú pháp khác nhau và tuân thủ các quy tắc định dạng giống như được chỉ định bởi POSIX như:

• bc tuân theo

  • Đối với các cơ sở lớn hơn 16, mỗi chữ số sẽ được viết dưới dạng số thập phân nhiều chữ số riêng biệt. Mỗi chữ số ngoại trừ chữ số phân số có ý nghĩa nhất sẽ được bắt đầu bằng một khoảng trắng . Đối với các cơ sở từ 17 đến 100, bcsẽ viết các số thập phân có hai chữ số; cho các cơ sở từ 101 đến 1000, chuỗi thập phân ba chữ số, v.v. Ví dụ: số thập phân 1024 trong cơ sở 25 sẽ được viết là:

  01 15 24

  và trong cơ sở 125, như:

  008 024

Ngắn và ngọt, vỏ chỉ giải pháp:

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
}

Nó không hiển thị thuốc thập phân.

Các let VAR=expressionlà Korn-ish. Thay thế VAR=$(( expression ))cho Sinh ra một lần nữa.

AFAIK không có công cụ tiêu chuẩn nào mà bạn có thể chuyển văn bản và nó trả về dạng người có thể đọc được. Bạn có thể tìm thấy một gói để hoàn thành nhiệm vụ đã nói cho bản phân phối của bạn.

Tuy nhiên, tôi không hiểu tại sao bạn có thể cần một công cụ như vậy. Hầu hết các gói cung cấp đầu ra liên quan, thường có công tắc -h hoặc tương đương cho đầu ra có thể đọc được.