309

この関数を使用して、バイト単位のファイルサイズを人間が読める形式のファイルサイズに変換しています。

function getReadableFileSizeString(fileSizeInBytes) {
    var i = -1;
    var byteUnits = [' kB', ' MB', ' GB', ' TB', 'PB', 'EB', 'ZB', 'YB'];
    do {
        fileSizeInBytes = fileSizeInBytes / 1024;
        i++;
    } while (fileSizeInBytes > 1024);

    return Math.max(fileSizeInBytes, 0.1).toFixed(1) + byteUnits[i];
};

ただし、これは100％正確ではないようです。例えば：

getReadableFileSizeString(1551859712); // output is "1.4 GB"

これはいけません"1.5 GB"か？1024で除算すると精度が低下しているようです。私は何かを完全に誤解していますか、それともこれを行うためのより良い方法がありますか？

4

21 に答える 21

474

これが私が書いたものです：

/**
 * Format bytes as human-readable text.
 * 
 * @param bytes Number of bytes.
 * @param si True to use metric (SI) units, aka powers of 1000. False to use 
 *           binary (IEC), aka powers of 1024.
 * @param dp Number of decimal places to display.
 * 
 * @return Formatted string.
 */
function humanFileSize(bytes, si=false, dp=1) {
  const thresh = si ? 1000 : 1024;

  if (Math.abs(bytes) < thresh) {
    return bytes + ' B';
  }

  const units = si 
    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'] 
    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
  let u = -1;
  const r = 10**dp;

  do {
    bytes /= thresh;
    ++u;
  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);


  return bytes.toFixed(dp) + ' ' + units[u];
}


console.log(humanFileSize(1551859712))  // 1.4 GiB
console.log(humanFileSize(5000, true))  // 5.0 kB
console.log(humanFileSize(5000, false))  // 4.9 KiB
console.log(humanFileSize(-10000000000000000000000000000))  // -8271.8 YiB
console.log(humanFileSize(999949, true))  // 999.9 kB
console.log(humanFileSize(999950, true))  // 1.0 MB
console.log(humanFileSize(999950, true, 2))  // 999.95 kB
console.log(humanFileSize(999500, true, 0))  // 1 MB

于 2013-02-17T08:57:08.960 に答える
117

計算の別の実施形態

function humanFileSize(size) {
    var i = Math.floor( Math.log(size) / Math.log(1024) );
    return ( size / Math.pow(1024, i) ).toFixed(2) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
};
于 2013-12-22T17:32:10.057 に答える
59

2進数または10進数のどちらの規則を使用するかによって異なります。

たとえば、RAMは常にバイナリで測定されるため、1551859712を〜1.4GiBとして表すのが正しいでしょう。

一方、ハードディスクメーカーは10進数を使用することを好むため、約1.6GBと呼びます。

紛らわしいことに、フロッピーディスクは2つのシステムを組み合わせて使用​​します。1MBは実際には1024000バイトです。

于 2012-05-02T19:31:37.047 に答える
36

これは、新しい国際規格を尊重して数値を読み取り可能な文字列に変換するためのプロトタイプです。

大きな数を表すには2つの方法があります。1000=103（基数10）または1024 = 2 10（基数2）の倍数で表示できます。1000で割る場合は、おそらくSIプレフィックス名を使用し、1024で割る場合は、おそらくIECプレフィックス名を使用します。問題は1024で割ることから始まります。多くのアプリケーションはそれにSIプレフィックス名を使用し、一部はIECプレフィックス名を使用します。現在の状況は混乱しています。SIプレフィックス名が表示されている場合は、その数を1000で割ったものか1024で割ったものかがわかりません。

https://wiki.ubuntu.com/UnitsPolicy

http://en.wikipedia.org/wiki/Template:Quantities_of_bytes

Object.defineProperty(Number.prototype,'fileSize',{value:function(a,b,c,d){
 return (a=a?[1e3,'k','B']:[1024,'K','iB'],b=Math,c=b.log,
 d=c(this)/c(a[0])|0,this/b.pow(a[0],d)).toFixed(2)
 +' '+(d?(a[1]+'MGTPEZY')[--d]+a[2]:'Bytes');
},writable:false,enumerable:false});

この関数には、が含まれていないloopため、他の関数よりもおそらく高速です。

使用法：

IECプレフィックス

console.log((186457865).fileSize()); // default IEC (power 1024)
//177.82 MiB
//KiB,MiB,GiB,TiB,PiB,EiB,ZiB,YiB

SIプレフィックス

console.log((186457865).fileSize(1)); //1,true for SI (power 1000)
//186.46 MB 
//kB,MB,GB,TB,PB,EB,ZB,YB

ファイルのサイズを計算するために常にバイナリモードを使用したため、IECをデフォルトとして設定しました...1024の累乗を使用します

短いワンライナー関数でそれらの1つが必要な場合：

SI

function fileSizeSI(a,b,c,d,e){
 return (b=Math,c=b.log,d=1e3,e=c(a)/c(d)|0,a/b.pow(d,e)).toFixed(2)
 +' '+(e?'kMGTPEZY'[--e]+'B':'Bytes')
}
//kB,MB,GB,TB,PB,EB,ZB,YB

IEC

function fileSizeIEC(a,b,c,d,e){
 return (b=Math,c=b.log,d=1024,e=c(a)/c(d)|0,a/b.pow(d,e)).toFixed(2)
 +' '+(e?'KMGTPEZY'[--e]+'iB':'Bytes')
}
//KiB,MiB,GiB,TiB,PiB,EiB,ZiB,YiB

使用法：

console.log(fileSizeIEC(7412834521));

関数について質問がある場合は、

于 2013-12-09T04:11:16.973 に答える
22 
sizeOf = function (bytes) {
  if (bytes == 0) { return "0.00 B"; }
  var e = Math.floor(Math.log(bytes) / Math.log(1024));
  return (bytes/Math.pow(1024, e)).toFixed(2)+' '+' KMGTP'.charAt(e)+'B';
}

sizeOf（2054110009）;
// => "1.91 GB"

sizeOf（7054110）;
// => "6.73 MB"

sizeOf（（3 * 1024 * 1024））;
// => "3.00 MB"

于 2015-01-23T23:47:10.903 に答える
17

ReactJSコンポーネントとしてのソリューション

Bytes = React.createClass({
    formatBytes() {
        var i = Math.floor(Math.log(this.props.bytes) / Math.log(1024));
        return !this.props.bytes && '0 Bytes' || (this.props.bytes / Math.pow(1024, i)).toFixed(2) + " " + ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'][i]
    },
    render () {
        return (
            <span>{ this.formatBytes() }</span>
        );
    }
});

更新 es6を使用している人のために、これは同じコンポーネントのステートレスバージョンです。

const sufixes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
const getBytes = (bytes) => {
  const i = Math.floor(Math.log(bytes) / Math.log(1024));
  return !bytes && '0 Bytes' || (bytes / Math.pow(1024, i)).toFixed(2) + " " + sufixes[i];
};

const Bytes = ({ bytes }) => (<span>{ getBytes(bytes) }</span>);

Bytes.propTypes = {
  bytes: React.PropTypes.number,
};
于 2015-12-10T19:27:28.017 に答える
11

coccoのアイデアに基づいて、これはそれほどコンパクトではありませんが、できればより包括的な例です。

<!DOCTYPE html>
<html>
<head>
<title>File info</title>

<script>
<!--
function fileSize(bytes) {
    var exp = Math.log(bytes) / Math.log(1024) | 0;
    var result = (bytes / Math.pow(1024, exp)).toFixed(2);

    return result + ' ' + (exp == 0 ? 'bytes': 'KMGTPEZY'[exp - 1] + 'B');
}

function info(input) {
    input.nextElementSibling.textContent = fileSize(input.files[0].size);
} 
-->
</script>
</head>

<body>
<label for="upload-file"> File: </label>
<input id="upload-file" type="file" onchange="info(this)">
<div></div>
</body>
</html>
于 2014-02-25T19:08:46.133 に答える
10

ここに似た別の例

function fileSize(b) {
    var u = 0, s=1024;
    while (b >= s || -b >= s) {
        b /= s;
        u++;
    }
    return (u ? b.toFixed(1) + ' ' : b) + ' KMGTPEZY'[u] + 'B';
}

同様の機能を持つ他のものよりも無視できるほど優れたパフォーマンスを測定します。

于 2016-12-30T20:46:27.247 に答える
8

小数点以下の桁数が数値のサイズに比例する「ファイルマネージャ」の動作（Windowsエクスプローラなど）が必要でした。どうやら他の答えのどれもこれをしません。

function humanFileSize(size) {
    if (size < 1024) return size + ' B'
    let i = Math.floor(Math.log(size) / Math.log(1024))
    let num = (size / Math.pow(1024, i))
    let round = Math.round(num)
    num = round < 10 ? num.toFixed(2) : round < 100 ? num.toFixed(1) : round
    return `${num} ${'KMGTPEZY'[i-1]}B`
}

次にいくつかの例を示します。

humanFileSize(0)          // "0 B"
humanFileSize(1023)       // "1023 B"
humanFileSize(1024)       // "1.00 KB"
humanFileSize(10240)      // "10.0 KB"
humanFileSize(102400)     // "100 KB"
humanFileSize(1024000)    // "1000 KB"
humanFileSize(12345678)   // "11.8 MB"
humanFileSize(1234567890) // "1.15 GB"
于 2019-06-28T11:45:23.907 に答える
6

2020年以降、ファイルサイズのnpmパッケージを使用できます。これは、IEC（1024の累乗、デフォルト）、SI（1000の累乗）、およびJEDEC（代替SI単位表記）でのフォーマットをサポートします。

npm install file-size

import filesize from "filesize";

// outputs: 186.46 MB
filesize(186457865).human('si');

// outputs: 177.82 MiB
filesize(186457865).human();

https://www.npmjs.com/package/file-size

于 2020-07-09T10:47:12.770 に答える
5

私の答えは遅いかもしれませんが、それは誰かを助けると思います。

メトリックプレフィックス：

/**
 * Format file size in metric prefix
 * @param fileSize
 * @returns {string}
 */
const formatFileSizeMetric = (fileSize) => {
  let size = Math.abs(fileSize);

  if (Number.isNaN(size)) {
    return 'Invalid file size';
  }

  if (size === 0) {
    return '0 bytes';
  }

  const units = ['bytes', 'kB', 'MB', 'GB', 'TB'];
  let quotient = Math.floor(Math.log10(size) / 3);
  quotient = quotient < units.length ? quotient : units.length - 1;
  size /= (1000 ** quotient);

  return `${+size.toFixed(2)} ${units[quotient]}`;
};

バイナリプレフィックス：

/**
 * Format file size in binary prefix
 * @param fileSize
 * @returns {string}
 */
const formatFileSizeBinary = (fileSize) => {
  let size = Math.abs(fileSize);

  if (Number.isNaN(size)) {
    return 'Invalid file size';
  }

  if (size === 0) {
    return '0 bytes';
  }

  const units = ['bytes', 'kiB', 'MiB', 'GiB', 'TiB'];
  let quotient = Math.floor(Math.log2(size) / 10);
  quotient = quotient < units.length ? quotient : units.length - 1;
  size /= (1024 ** quotient);

  return `${+size.toFixed(2)} ${units[quotient]}`;
};

例：

// Metrics prefix
formatFileSizeMetric(0)      // 0 bytes
formatFileSizeMetric(-1)     // 1 bytes
formatFileSizeMetric(100)    // 100 bytes
formatFileSizeMetric(1000)   // 1 kB
formatFileSizeMetric(10**5)  // 10 kB
formatFileSizeMetric(10**6)  // 1 MB
formatFileSizeMetric(10**9)  // 1GB
formatFileSizeMetric(10**12) // 1 TB
formatFileSizeMetric(10**15) // 1000 TB

// Binary prefix
formatFileSizeBinary(0)     // 0 bytes
formatFileSizeBinary(-1)    // 1 bytes
formatFileSizeBinary(1024)  // 1 kiB
formatFileSizeBinary(2048)  // 2 kiB
formatFileSizeBinary(2**20) // 1 MiB
formatFileSizeBinary(2**30) // 1 GiB
formatFileSizeBinary(2**40) // 1 TiB
formatFileSizeBinary(2**50) // 1024 TiB
于 2020-04-07T15:09:11.550 に答える
4

これが私のものです-本当に大きなファイルでも機能します-_-

function formatFileSize(size)
{
    var sizes = [' Bytes', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB', ' ZB', ' YB'];
    for (var i = 1; i < sizes.length; i++)
    {
        if (size < Math.pow(1024, i)) return (Math.round((size/Math.pow(1024, i-1))*100)/100) + sizes[i-1];
    }
    return size;
}
于 2015-03-06T10:10:21.757 に答える
4

coccoの回答に基づいていますが、少し非難されており（正直なところ、私が快適だったものは残り/追加されています）、末尾のゼロは表示されませんが、0をサポートしています。他の人に役立つことを願っています。

function fileSizeSI(size) {
    var e = (Math.log(size) / Math.log(1e3)) | 0;
    return +(size / Math.pow(1e3, e)).toFixed(2) + ' ' + ('kMGTPEZY'[e - 1] || '') + 'B';
}


// test:
document.write([0, 23, 4322, 324232132, 22e9, 64.22e12, 76.22e15, 64.66e18, 77.11e21, 22e24].map(fileSizeSI).join('<br>'));

于 2016-08-11T13:24:41.517 に答える
4

ここにはたくさんの素晴らしい答えがあります。しかし、本当に簡単な方法を探していて、人気のあるライブラリを気にしないのであれば、優れたソリューションはfilesize https://www.npmjs.com/package/filesizeです。

たくさんのオプションがあり、使い方は簡単です。

filesize(265318); // "259.1 KB"

彼らの優れた例から引用

于 2020-12-03T10:22:12.187 に答える
3 
1551859712 / 1024 = 1515488
1515488 / 1024 = 1479.96875
1479.96875 / 1024 = 1.44528198242188

あなたの解決策は正しいです。1551859712に到達するには、からに到達するために1.51000で除算する必要がありますが、バイトは1024の2進数から10進数へのチャンクでカウントされるため、ギガバイト値が小さいのはなぜですか。

于 2012-05-02T19:43:01.520 に答える
3

不要な端数の丸めを行わない、SIシステム用のシンプルで短い「PrettyBytes」関数。

実際、数値のサイズは人間が読める形式であると想定されているため、「1000分の1」の表示はもはや人間ではありません。

小数点以下の桁数はデフォルトで2ですが、関数を他の値に呼び出すときに変更できます。一般的なほとんどの表示は、デフォルトの小数点以下第2位です。

コードは短く、NumberStringTripletsのメソッドを使用しています。

// Simple Pretty Bytes with SI system
// Without fraction rounding

function numberPrettyBytesSI(Num=0, dec=2){
if (Num<1000) return Num+" Bytes";
Num =("0".repeat((Num+="").length*2%3)+Num).match(/.{3}/g);
return Number(Num[0])+"."+Num[1].substring(0,dec)+" "+"  kMGTPEZY"[Num.length]+"B";
}

console.log(numberPrettyBytesSI(0));
console.log(numberPrettyBytesSI(500));
console.log(numberPrettyBytesSI(1000));
console.log(numberPrettyBytesSI(15000));
console.log(numberPrettyBytesSI(12345));
console.log(numberPrettyBytesSI(123456));
console.log(numberPrettyBytesSI(1234567));
console.log(numberPrettyBytesSI(12345678));

于 2020-07-02T19:04:24.167 に答える
2

@coccoの回答は興味深いと思いましたが、次の問題がありました。

  1. ネイティブタイプまたは所有していないタイプを変更しないでください
  2. 人間のためにクリーンで読みやすいコードを記述し、ミニファイアにマシン用のコードを最適化させます
  3. （TypeScriptユーザーへのボーナス）TypeScriptではうまく機能しません

TypeScript：

 /**
 * Describes manner by which a quantity of bytes will be formatted.
 */
enum ByteFormat {
  /**
   * Use Base 10 (1 kB = 1000 bytes). Recommended for sizes of files on disk, disk sizes, bandwidth.
   */
  SI = 0,
  /**
   * Use Base 2 (1 KiB = 1024 bytes). Recommended for RAM size, size of files on disk.
   */
  IEC = 1
}

/**
 * Returns a human-readable representation of a quantity of bytes in the most reasonable unit of magnitude.
 * @example
 * formatBytes(0) // returns "0 bytes"
 * formatBytes(1) // returns "1 byte"
 * formatBytes(1024, ByteFormat.IEC) // returns "1 KiB"
 * formatBytes(1024, ByteFormat.SI) // returns "1.02 kB"
 * @param size The size in bytes.
 * @param format Format using SI (Base 10) or IEC (Base 2). Defaults to SI.
 * @returns A string describing the bytes in the most reasonable unit of magnitude.
 */
function formatBytes(
  value: number,
  format: ByteFormat = ByteFormat.SI
) {
  const [multiple, k, suffix] = (format === ByteFormat.SI
    ? [1000, 'k', 'B']
    : [1024, 'K', 'iB']) as [number, string, string]
  // tslint:disable-next-line: no-bitwise
  const exp = (Math.log(value) / Math.log(multiple)) | 0
  // or, if you'd prefer not to use bitwise expressions or disabling tslint rules, remove the line above and use the following:
  // const exp = value === 0 ? 0 : Math.floor(Math.log(value) / Math.log(multiple)) 
  const size = Number((value / Math.pow(multiple, exp)).toFixed(2))
  return (
    size +
    ' ' +
    (exp 
       ? (k + 'MGTPEZY')[exp - 1] + suffix 
       : 'byte' + (size !== 1 ? 's' : ''))
  )
}

// example
[0, 1, 1024, Math.pow(1024, 2), Math.floor(Math.pow(1024, 2) * 2.34), Math.pow(1024, 3), Math.floor(Math.pow(1024, 3) * 892.2)].forEach(size => {
  console.log('Bytes: ' + size)
  console.log('SI size: ' + formatBytes(size))
  console.log('IEC size: ' + formatBytes(size, 1) + '\n')
});
于 2019-12-16T23:47:29.333 に答える
1

これはmpen回答のサイズ改善です

function humanFileSize(bytes, si=false) {
  let u, b=bytes, t= si ? 1000 : 1024;     
  ['', si?'k':'K', ...'MGTPEZY'].find(x=> (u=x, b/=t, b**2<1));
  return `${u ? (t*b).toFixed(1) : bytes} ${u}${!si && u ? 'i':''}B`;    
}


function humanFileSize(bytes, si=false) {
  let u, b=bytes, t= si ? 1000 : 1024;     
  ['', si?'k':'K', ...'MGTPEZY'].find(x=> (u=x, b/=t, b**2<1));
  return `${u ? (t*b).toFixed(1) : bytes} ${u}${!si && u ? 'i':''}B`;    
}


// TEST
console.log(humanFileSize(5000));      // 4.9 KiB
console.log(humanFileSize(5000,true)); // 5.0 kB

于 2020-04-29T15:35:24.657 に答える
0

を使用する人のために、これのためのパイプを持っているAngularと呼ばれるパッケージがあります：angular-pipes

ファイル

import { BytesPipe } from 'angular-pipes';

使用法

{{ 150 | bytes }} <!-- 150 B -->
{{ 1024 | bytes }} <!-- 1 KB -->
{{ 1048576 | bytes }} <!-- 1 MB -->
{{ 1024 | bytes: 0 : 'KB' }} <!-- 1 MB -->
{{ 1073741824 | bytes }} <!-- 1 GB -->
{{ 1099511627776 | bytes }} <!-- 1 TB -->
{{ 1073741824 | bytes : 0 : 'B' : 'MB' }} <!-- 1024 MB -->

ドキュメントへのリンク。

于 2019-05-11T12:30:03.063 に答える
0

投票されたソリューションで小数点以下の桁数を動的に調整するには、bytes.toFixed(dp)を数値に変換してから、次のように文字列に戻します。

return Number(bytes.toFixed(dp)).toString() + " " + units[u];

これにより、100.00GiBではなく100GiBが表示されます。jsで動的にtoFixed（）の質問への参照

于 2022-02-23T20:02:53.010 に答える
-2

バイト=1024* 10 * 10 * 10;

console.log（getReadableFileSizeString（bytes））

1MBではなく1000.0Кбを返します

于 2018-12-06T02:05:36.303 に答える