数据存储

复制import math

# 将字节数转换为人类可读格式（二进制单位：1024）
def format_bytes_binary(size_bytes: int) -> str:
    if size_bytes == 0:
        return "0 B"
    units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]
    i = int(math.floor(math.log(size_bytes, 1024)))
    i = min(i, len(units) - 1)
    value = size_bytes / (1024 ** i)
    return f"{value:.2f} {units[i]}"

# 示例
print(format_bytes_binary(123456789))  # 117.74 MiB
print(format_bytes_binary(1099511627776))  # 1.00 TiB

# 将字节数转换为人类可读格式（十进制单位：1000）
def format_bytes_decimal(size_bytes: int) -> str:
    if size_bytes == 0:
        return "0 B"
    units = ["B", "KB", "MB", "GB", "TB", "PB"]
    i = int(math.floor(math.log(size_bytes, 1000)))
    i = min(i, len(units) - 1)
    value = size_bytes / (1000 ** i)
    return f"{value:.2f} {units[i]}"

# 示例
print(format_bytes_decimal(123456789))  # 123.46 MB
print(format_bytes_decimal(1000000000000))  # 1.00 TB

复制package main

import (
	"fmt"
	"math"
)

// formatBytesBinary 将字节数转换为人类可读格式（二进制单位：1024）
func formatBytesBinary(size int64) string {
	if size == 0 {
		return "0 B"
	}
	units := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB"}
	i := int(math.Floor(math.Log(float64(size), 1024)))
	if i >= len(units) {
		i = len(units) - 1
	}
	value := float64(size) / math.Pow(1024, float64(i))
	return fmt.Sprintf("%.2f %s", value, units[i])
}

// formatBytesDecimal 将字节数转换为人类可读格式（十进制单位：1000）
func formatBytesDecimal(size int64) string {
	if size == 0 {
		return "0 B"
	}
	units := []string{"B", "KB", "MB", "GB", "TB", "PB"}
	i := int(math.Floor(math.Log(float64(size), 1000)))
	if i >= len(units) {
		i = len(units) - 1
	}
	value := float64(size) / math.Pow(1000, float64(i))
	return fmt.Sprintf("%.2f %s", value, units[i])
}

func main() {
	fmt.Println(formatBytesBinary(123456789))     // 117.74 MiB
	fmt.Println(formatBytesBinary(1099511627776)) // 1.00 TiB
	fmt.Println(formatBytesDecimal(123456789))    // 123.46 MB
	fmt.Println(formatBytesDecimal(1000000000000)) // 1.00 TB
}

复制/**
 * 将字节数转换为人类可读格式（二进制单位：1024）
 * @param {number} bytes - 字节数
 * @returns {string} 格式化后的字符串
 */
function formatBytesBinary(bytes) {
  if (bytes === 0) return '0 B';
  const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB'];
  const i = Math.min(
    Math.floor(Math.log(bytes) / Math.log(1024)),
    units.length - 1
  );
  const value = bytes / Math.pow(1024, i);
  return `${value.toFixed(2)} ${units[i]}`;
}

/**
 * 将字节数转换为人类可读格式（十进制单位：1000）
 * @param {number} bytes - 字节数
 * @returns {string} 格式化后的字符串
 */
function formatBytesDecimal(bytes) {
  if (bytes === 0) return '0 B';
  const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
  const i = Math.min(
    Math.floor(Math.log(bytes) / Math.log(1000)),
    units.length - 1
  );
  const value = bytes / Math.pow(1000, i);
  return `${value.toFixed(2)} ${units[i]}`;
}

// 示例
console.log(formatBytesBinary(123456789));     // "117.74 MiB"
console.log(formatBytesBinary(1099511627776)); // "1.00 TiB"
console.log(formatBytesDecimal(123456789));    // "123.46 MB"
console.log(formatBytesDecimal(1000000000000)); // "1.00 TB"