<demo><bytes><字节转换>

Author: iceopen

demo/bytes/README.md

@@ -0,0 +1,21 @@
+# Bytes
+
+- Format bytes integer to human readable bytes string.
+- Parse human readable bytes string to bytes integer.
+
+### Format
+
+```go
+println(bytes.Format(13231323))
+```
+
+`12.62MB`
+
+### Parse
+
+```go
+b, _ = Parse("2M")
+println(b)
+```
+
+`2097152`

demo/bytes/bytes.go

@@ -0,0 +1,108 @@
+package bytes
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+)
+
+type (
+	// Bytes struct
+	Bytes struct{}
+)
+
+const (
+	_  = 1.0 << (10 * iota) // ignore first value by assigning to blank identifier
+	KB
+	MB
+	GB
+	TB
+	PB
+	EB
+)
+
+var (
+	pattern = regexp.MustCompile(`(?i)^(-?\d+(?:\.\d+)?)([KMGTPE]B?|B?)$`)
+	global  = New()
+)
+
+// New creates a Bytes instance.
+func New() *Bytes {
+	return &Bytes{}
+}
+
+// Format formats bytes integer to human readable string.
+// For example, 31323 bytes will return 30.59KB.
+func (*Bytes) Format(b int64) string {
+	multiple := ""
+	value := float64(b)
+
+	switch {
+	case b >= EB:
+		value /= EB
+		multiple = "EB"
+	case b >= PB:
+		value /= PB
+		multiple = "PB"
+	case b >= TB:
+		value /= TB
+		multiple = "TB"
+	case b >= GB:
+		value /= GB
+		multiple = "GB"
+	case b >= MB:
+		value /= MB
+		multiple = "MB"
+	case b >= KB:
+		value /= KB
+		multiple = "KB"
+	case b == 0:
+		return "0"
+	default:
+		return strconv.FormatInt(b, 10) + "B"
+	}
+
+	return fmt.Sprintf("%.2f%s", value, multiple)
+}
+
+// Parse parses human readable bytes string to bytes integer.
+// For example, 6GB (6G is also valid) will return 6442450944.
+func (*Bytes) Parse(value string) (i int64, err error) {
+	parts := pattern.FindStringSubmatch(value)
+	if len(parts) < 3 {
+		return 0, fmt.Errorf("error parsing value=%s", value)
+	}
+	bytesString := parts[1]
+	multiple := parts[2]
+	bytes, err := strconv.ParseFloat(bytesString, 64)
+	if err != nil {
+		return
+	}
+
+	switch multiple {
+	default:
+		return int64(bytes), nil
+	case "K", "KB":
+		return int64(bytes * KB), nil
+	case "M", "MB":
+		return int64(bytes * MB), nil
+	case "G", "GB":
+		return int64(bytes * GB), nil
+	case "T", "TB":
+		return int64(bytes * TB), nil
+	case "P", "PB":
+		return int64(bytes * PB), nil
+	case "E", "EB":
+		return int64(bytes * EB), nil
+	}
+}
+
+// Format wraps global Bytes's Format function.
+func Format(b int64) string {
+	return global.Format(b)
+}
+
+// Parse wraps global Bytes's Parse function.
+func Parse(val string) (int64, error) {
+	return global.Parse(val)
+}

demo/bytes/bytes_test.go

@@ -0,0 +1,152 @@
+package bytes
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBytesFormat(t *testing.T) {
+	// B
+	b := Format(0)
+	assert.Equal(t, "0", b)
+	// B
+	b = Format(515)
+	assert.Equal(t, "515B", b)
+
+	// KB
+	b = Format(31323)
+	assert.Equal(t, "30.59KB", b)
+
+	// MB
+	b = Format(13231323)
+	assert.Equal(t, "12.62MB", b)
+
+	// GB
+	b = Format(7323232398)
+	assert.Equal(t, "6.82GB", b)
+
+	// TB
+	b = Format(7323232398434)
+	assert.Equal(t, "6.66TB", b)
+
+	// PB
+	b = Format(9923232398434432)
+	assert.Equal(t, "8.81PB", b)
+
+	// EB
+	b = Format(math.MaxInt64)
+	assert.Equal(t, "8.00EB", b)
+}
+
+func TestBytesParseErrors(t *testing.T) {
+	_, err := Parse("B999")
+	if assert.Error(t, err) {
+		assert.EqualError(t, err, "error parsing value=B999")
+	}
+}
+
+func TestFloats(t *testing.T) {
+	// From string:
+	str := "12.25KB"
+	value, err := Parse(str)
+	assert.NoError(t, err)
+	assert.Equal(t, int64(12544), value)
+
+	str2 := Format(value)
+	assert.Equal(t, str, str2)
+
+	// To string:
+	val := int64(13233029)
+	str = Format(val)
+	assert.Equal(t, "12.62MB", str)
+
+	val2, err := Parse(str)
+	assert.NoError(t, err)
+	assert.Equal(t, val, val2)
+}
+
+func TestBytesParse(t *testing.T) {
+	// B
+	b, err := Parse("999")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(999), b)
+	}
+	b, err = Parse("-100")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(-100), b)
+	}
+	b, err = Parse("100.1")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(100), b)
+	}
+	b, err = Parse("515B")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(515), b)
+	}
+
+	// KB
+	b, err = Parse("12.25KB")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(12544), b)
+	}
+	b, err = Parse("12KB")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(12288), b)
+	}
+	b, err = Parse("12K")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(12288), b)
+	}
+
+	// MB
+	b, err = Parse("2MB")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(2097152), b)
+	}
+	b, err = Parse("2M")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(2097152), b)
+	}
+
+	// GB
+	b, err = Parse("6GB")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(6442450944), b)
+	}
+	b, err = Parse("6G")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(6442450944), b)
+	}
+
+	// TB
+	b, err = Parse("5TB")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(5497558138880), b)
+	}
+	b, err = Parse("5T")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(5497558138880), b)
+	}
+
+	// PB
+	b, err = Parse("9PB")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(10133099161583616), b)
+	}
+	b, err = Parse("9P")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(10133099161583616), b)
+	}
+
+	// EB
+	b, err = Parse("8EB")
+	if assert.NoError(t, err) {
+		assert.True(t, math.MaxInt64 == b-1)
+	}
+	b, err = Parse("8E")
+	if assert.NoError(t, err) {
+		assert.True(t, math.MaxInt64 == b-1)
+	}
+}