我使用这个函数将文件大小(以字节为单位)转换为人类可读的文件大小:

零二线函数 var i = -1; var byteUnits =[英国‘计划生育’‘兆’,‘和合’,‘PB’‘EB”、“ZB’,‘YB]; do { fileSizeInBytes /= 1024; 我+; while (fileSizeInBytes > 1024) 数学归来。max(fileSizeInBytes, 0.1)。toFixed(1) + byteUnits[i]; 的 控制台日志(getReadableFileSizeString (1551859712);//输出是“1.4 GB”

然而,这似乎不是百分之百准确的。例如:

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

不应该是“1.5 GB”吗?除以1024似乎失去了精度。是我完全误解了什么,还是有更好的办法?


当前回答

我写了一个大小转换函数,它也接受人类可读的格式。

JS

const bitBase = 8; const suffixes = { bit: 'b', b: 'B', kb: 'KB', mb: 'MB', gb: 'GB', tb: 'TB', }; const multipliers = { bit: { toBitHr: 1, toB: 1 / bitBase, toKB: 1 / (bitBase * 1e3), toMB: 1 / (bitBase * 1e6), toGB: 1 / (bitBase * 1e9), toTB: 1 / (bitBase * 1e12), }, B: { toBit: bitBase, toBHr: 1, toKB: 1 / 1e3, toMB: 1 / 1e6, toGB: 1 / 1e9, toTB: 1 / 1e12, }, KB: { toBit: 1 / (bitBase * 1e3), toB: 1e3, toKBHr: 1, toMB: 1 / 1e3, toGB: 1 / 1e6, toTB: 1 / 1e9, }, MB: { toBit: bitBase * 1e6, toB: 1e6, toKB: 1e3, toMBHr: 1, toGB: 1 / 1e3, toTB: 1 / 1e6, }, GB: { toBit: bitBase * 1e9, toB: 1e9, toKB: 1e6, toMB: 1e3, toGBHr: 1, toTB: 1 / 1e3, }, TB: { toBit: bitBase * 1e12, toB: 1e12, toKB: 1e9, toMB: 1e6, toGB: 1e3, toTBHr: 1, }, }; const round = (num, decimalPlaces) => { const strNum = num.toString(); const isExp = strNum.includes('e'); if (isExp) { return Number(num.toPrecision(decimalPlaces + 1)); } return Number( `${Math.round(Number(`${num}e${decimalPlaces}`))}e${decimalPlaces * -1}`, ); }; function conv( value, hr, rnd, multiplier, suffix, ) { let val = value * multiplier; if ((value * multiplier) > Number.MAX_SAFE_INTEGER) { val = Number.MAX_SAFE_INTEGER; } if (val < Number.MIN_VALUE) val = 0; if ((rnd || rnd === 0) && val < Number.MAX_SAFE_INTEGER) { val = round(val, rnd); } if (hr) return `${val}${suffix}`; return val; } const MemConv = (function _() { return { bit(value) { return { toBitHr(opts = {}) { return conv( value, true, opts.round || false, multipliers.bit.toBitHr, suffixes.bit, ); }, toB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.bit.toB, suffixes.b, ); }, toKB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.bit.toKB, suffixes.kb, ); }, toMB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.bit.toMB, suffixes.mb, ); }, toGB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.bit.toGB, suffixes.gb, ); }, toTB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.bit.toTB, suffixes.tb, ); }, }; }, B(value) { return { toBit(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.B.toBit, suffixes.bit, ); }, toBHr(opts = {}) { return conv( value, true, opts.round || false, multipliers.B.toBHr, suffixes.b, ); }, toKB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.B.toKB, suffixes.kb, ); }, toMB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.B.toMB, suffixes.mb, ); }, toGB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.B.toGB, suffixes.gb, ); }, toTB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.B.toTB, suffixes.tb, ); }, }; }, KB(value) { return { toBit(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.KB.toBit, suffixes.bit, ); }, toB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.KB.toB, suffixes.b, ); }, toKBHr(opts = {}) { return conv( value, true, opts.round || false, multipliers.KB.toKBHr, suffixes.kb, ); }, toMB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.KB.toMB, suffixes.mb, ); }, toGB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.KB.toGB, suffixes.gb, ); }, toTB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.KB.toTB, suffixes.tb, ); }, }; }, MB(value) { return { toBit(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.MB.toBit, suffixes.bit, ); }, toB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.MB.toB, suffixes.b, ); }, toKB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.MB.toKB, suffixes.kb, ); }, toMBHr(opts = {}) { return conv( value, true, opts.round || false, multipliers.MB.toMBHr, suffixes.mb, ); }, toGB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.MB.toGB, suffixes.gb, ); }, toTB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.MB.toTB, suffixes.tb, ); }, }; }, GB(value) { return { toBit(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.GB.toBit, suffixes.bit, ); }, toB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.GB.toB, suffixes.b, ); }, toKB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.GB.toKB, suffixes.kb, ); }, toMB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.GB.toMB, suffixes.mb, ); }, toGBHr(opts = {}) { return conv( value, true, opts.round || false, multipliers.GB.toGBHr, suffixes.gb, ); }, toTB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.GB.toTB, suffixes.tb, ); }, }; }, TB(value) { return { toBit(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.TB.toBit, suffixes.bit, ); }, toB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.TB.toB, suffixes.b, ); }, toKB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.TB.toKB, suffixes.kb, ); }, toMB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.TB.toMB, suffixes.mb, ); }, toGB(opts = {}) { return conv( value, opts.hr || false, opts.round || false, multipliers.TB.toGB, suffixes.gb, ); }, toTBHr(opts = {}) { return conv( value, true, opts.round || false, multipliers.TB.toTBHr, suffixes.tb, ); }, }; }, }; }()); const testCases = [1, 10, 150, 1000, 74839.67346]; const HRSuffixes = Object.values(suffixes); const roundDecimals = 2; const precision = Number(`0.${'0'.repeat(roundDecimals)}5`); const SCIENTIFIC_NOT_NUMBER_REGXP = /[-+]?[0-9]*.?[0-9]+([eE][-+]?[0-9]+)?/g; const SUFFIX_REGXP = /[a-z]+$/i; const CONVERSION_TO_REGXP = /(?<=to).*(?=hr+$)|(?<=to).*(?=hr+$)?/i; for (const conversionFrom of (Object.keys(MemConv))) { for (const tCase of testCases) { const convFunc = MemConv[conversionFrom](tCase); for (const [conversionToFn, f] of Object.entries(convFunc)) { const conversionTo = (conversionToFn.match(CONVERSION_TO_REGXP) || [conversionToFn])[0]; const result = f(); const humanReadable = f({ hr: true }); const rounded = f({ round: roundDecimals }); const roundedAndHumanReadable = f({ hr: true, round: roundDecimals }); console.log({ value: tCase, from: conversionFrom, to: conversionTo, result, humanReadable, rounded, roundedAndHumanReadable, }); } } }

TSVersion

test

import assert from 'assert';

function test() {
  const testCases = [1, 10, 150, 1000, 74839.67346];
  const HRSuffixes = Object.values(suffixes);
  const roundDecimals = 2;
  const precision = Number(`0.${'0'.repeat(roundDecimals)}5`);
  const SCIENTIFIC_NOT_NUMBER_REGXP = /[-+]?[0-9]*.?[0-9]+([eE][-+]?[0-9]+)?/g;
  const SUFFIX_REGXP = /[a-z]+$/i;
  const CONVERSION_TO_REGXP = /(?<=to).*(?=hr+$)|(?<=to).*(?=hr+$)?/i;

  for (const conversionFrom of (Object.keys(MemConv) as (keyof typeof MemConv)[])) {
    for (const tCase of testCases) {
      const convFunc = MemConv[conversionFrom](tCase);
      for (const [conversionToFn, f] of Object.entries(convFunc)) {
        const conversionTo = (conversionToFn.match(CONVERSION_TO_REGXP) || [conversionToFn])[0];
        const expectedSuffix = suffixes[conversionTo.toLowerCase() as keyof typeof suffixes];
        const multiplier = multipliers[conversionFrom][conversionToFn as keyof typeof multipliers[typeof conversionFrom]];
        const expectedResult = tCase * multiplier > Number.MAX_SAFE_INTEGER
            ? Number.MAX_SAFE_INTEGER
            : tCase * multiplier;

        const result = f();
        const humanReadable = f({ hr: true });
        const rounded = f({ round: roundDecimals });
        const roundedAndHumanReadable = f({ hr: true, round: roundDecimals });

        const resHrNumber = Number((humanReadable.match(SCIENTIFIC_NOT_NUMBER_REGXP) || [''])[0]);
        const resHrSuffix = (humanReadable.match(SUFFIX_REGXP) || [0])[0];
        const resRoundHrNumber = Number((roundedAndHumanReadable.match(SCIENTIFIC_NOT_NUMBER_REGXP) || [''])[0]);
        const resRoundHrSuffix = (roundedAndHumanReadable.match(SUFFIX_REGXP) || [0])[0];

        if (/hr$/i.test(conversionToFn)) {
          const resNumber = Number((humanReadable.match(SCIENTIFIC_NOT_NUMBER_REGXP) || [''])[0]);
          const resSuffix = (humanReadable.match(SUFFIX_REGXP) || [0])[0];
          assert(typeof result === 'string');
          assert(typeof resSuffix === 'string');
          assert(typeof resRoundHrNumber === 'number');
          assert(typeof rounded === 'string');
          assert(result === humanReadable);
          assert(resSuffix === expectedSuffix);
          assert(resNumber <= expectedResult + precision && resNumber >= expectedResult - precision);
        } else {
          assert(typeof result === 'number');
          assert(result === resHrNumber);
          assert(typeof rounded === 'number');
          assert(result <= expectedResult + precision && result >= expectedResult - precision);
        }

        console.log({
          value: tCase,
          from: conversionFrom,
          to: conversionToFn,
          result,
          humanReadable,
          rounded,
          roundedAndHumanReadable,
        });

        assert(typeof resHrSuffix === 'string');
        assert(typeof resHrNumber === 'number');
        assert(resHrSuffix === expectedSuffix);
        assert(resHrSuffix === resRoundHrSuffix);
        assert(HRSuffixes.includes(resHrSuffix));
      }
    }
  }
}
test();

使用

// GB to GB humanReadable
console.log(MemConv.GB(11.1942).toGBHr()); // 11.1942GB;
// GB to MB
console.log(MemConv.GB(11.1942).toMB());// 11194.2;
// MB to MB humanReadable
console.log(MemConv.MB(11.1942).toGB({ hr: true }));// 0.011194200000000001GB;
// MB to MB humanReadable with rounding
console.log(MemConv.MB(11.1942).toGB({ hr: true, round: 3 }));// 0.011GB;

其他回答

这取决于你是想使用二进制还是十进制约定。

例如,RAM总是用二进制来度量,因此将1551859712表示为~1.4GiB是正确的。

另一方面,硬盘制造商喜欢使用十进制,所以他们称它为~1.6GB。

只是让人迷惑的是,软盘混合使用了这两种系统——它们的1MB实际上是1024000字节。

我的回答可能晚了,但我想它会帮助到某人。

度量前缀:

/**
 * 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

另一个类似的例子

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

它所衡量的性能比其他具有相似特性的算法好得可以忽略不计。

我发现@cocco的回答很有趣,但有以下问题:

不要修改原生类型或您不拥有的类型 为人类编写干净、可读的代码,让最小化器为机器优化代码 (对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')
});

我想要“文件管理器”行为(例如,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"